TRAPVERLICHTING OP 5V NAAR BOVEN EN NAAR DE ZOLDER

TRAPVERLICHTING OP 5V NAAR BOVEN EN NAAR DE ZOLDER

Automatische trapverlichting op 5V
Automatische trapverlichting op 5V

De trapverlichting naar boven (1e verdieping) en naar de zolder is gerealiseerd en werkt redelijk naar behoren.
Om de trapverlichting naar boven uit te voeren heb ik verschillende dingen aangeschaft.
Als eerste de Arduino. Dit is een programmeerbare microprocessor waar je via een IDE software in kunt stoppen en zo de Arduino verschillende dingen kunt laten schakelen.


Dit was nodig om een verschillende volgorde van leds te kunnen realiseren.
Ook heb ik 1W leds aangeschaft en nog wat PIR sensoren
Verschillende dingen waar het systeem aan moet voldoen:
1. De persoon moet worden gedetecteerd (beneden of boven aan de trap)
2. De led moeten afhankelijk van de richting van de persoon gaan branden en achter de persoon weer uit gaan.
3. Het hele systeem moet later op 12V komen te werken
4. De arduino moet niet worden gebruikt. Alleen maar voor het ontwikkelen en uittesten

DE ARDUINO

Arduino is een open-source electronica platform. Een soort microcontroller die je kunt programmeren. De Arduino heeft input en output poorten waarop je allerlei sensoren en actoren kan aansluiten. Een sensor is bijvoorbeeld een schakelaar, magneetcontact, temperatuursensor, bewegingsmelder of een lichtsensor. Een actor is bijvoorbeeld een relais (elektronische schakelaar), een LED of een electro motor.

 

De arduino Uno
De arduino Uno

Arduino

Met de Arduino kun je op basis van een input een output regelen. Bijv. als er beweging wordt geconstateerd in een ruimte, gaat een lamp aan. Of als er een schakelaar omgezet wordt, dat een electro motor gaat draaien. Er zijn vele mogelijkheden. Op mijn website kun je allerlei artikelen vinden met voorbeelden van het gebruik van de Arduino.
Voor het voeden van de input poorten van een Arduino, maak je gebruik van electronica. Dat kunnen simpele enkelvoudige componenten zijn (zoals een lichtcel) tot complete elektronische schakelingen op een printpraat (om bijv. te ‘voelen’ of er 220 Volt op een draad staat). Hetzelfde geldt voor de output poorten. Je kunt er iets eenvoudigs als een LED op aansluiten, maar ook bijvoorbeeld een meer ingewikkelde schakeling op een printpraat om een elektronische wisselschakelaar op 220 V aan te sturen. Bijvoorbeeld voor het schakelen van een lamp op 220 V.

Arduino met fotocell op Breadboard
Arduino met fotocell op Breadboard

 

Arduino met Photocell

Moet je een ervaren programmeur of electrotechneut zijn? Nee! Een beetje affiniteit is natuurlijk handig, maar iedereen kan dit leren. Je begint met iets eenvoudigs en leert al doende. Voor je het weet, bouw je je eigen robot, alarmsysteem of 220V. schakelingen! Zo ben ik ook begonnen en enthousiast geworden. Op mijn website vind je veel informatie om je op weg te helpen en links naar bijv. leveranciers.

Tot slot nog even dit. Jan Hindrik wees mij op een interessante link waar in de vorm van een stripverhaal duidelijk en leuk wordt uitgelegd wat Arduino is. A must read!

Stripje over Arduino
Stripje over Arduino

 

LEDS 1W

1W gel leds
1W gel leds

Deze leds heb ik gekocht in China waar ik regelmatig dingen bestel. Deze leds van 1W geven goed licht wat ik op de trap wel graag wil.
De leds werden geleverd in zakjes van 15 stuks voor € 2,=. Dit was dus niet veel
Dit zijn gel leds.

PIR SENSOREN

De pir sensoren gebruik ik om te detecteren of er iemand de trap op wil lopen. Als dit het geval is, gaat er een signaaltje naar de Arduino die weer een signaal doorstuurt naar een 74HC595 chip die op zijn beurt de leds aan of uit schakeld.

PIR sensor
PIR sensor

WERKING VAN DE COMBINATIE

De combinatie is opgebouwd zoals gezegd uit een Arduino, een 74HC595, twee PIR’s en een x aantal leds
Als eerste heb ik uitgezocht hoe ik de 74HC595 aan moest sluiten op de Arduino. Dit was nogal een klus omdat hier erg veel over op internet staat.

AANSLUITINGEN 74HC595

 

Aansluitingen 74hc595 schuifregister
Aansluitingen 74hc595 schuifregister

De aansluitingen pin 1-7 en pin 15 zijn voor het aansluiten van de leds. Hier is pin 15 de eerste led die wordt aangestuurd.

AANSLUITING ARDUINO OP DE 74HC595

 

Arduino aansluiten op breadboard met 74hc595
Arduino aansluiten op breadboard met 74hc595

 

Schema aansluitingen Arduino, 74hc595 en leds
Schema aansluitingen Arduino, 74hc595 en leds

De Arduino zorgt voor de voeding van het hele systeem. Deze heeft 5V aan boord en een Ground. Het voordeel van de Arduino is, dat er 5-12V in kan worden gevoerd. Dit kan door middel van een transformator. Ik heb er voor gekozen om later de Arduino te vervangen door een IC.

PROGRAMMEREN VAN DE ARDUINO

Het programmeren van de arduino gebeurt in C. Dit is voor mij niet moeilijk, omdat ik in het verleden veel in C heb geprogrammeerd.
In feite bestaat de structuur die wordt gebruikt uit de volgende onderdelen
void setup() {
// put your setup code here, to run once:

}

void loop() {
// put your main code here, to run repeatedly:

}
In het setup deel plaats je de dingen die één keer moeten worden gedraaid, zoals het declareren van de variabelen
In de loop worden dingen geplaatst die nodig zijn om het hele verhaal te laten lopen. Dit is wel even wennen. Er is uiteraard geen scherm of toetsenbord aanwezig. Dus er is een constante loop van een programma. Dit wordt niet door een knop (op het scherm) of toetsenbord geactiveerd.

DE EIGEN GESCHREVEN SOFTWARE VOOR DE ARDUINO

Er zijn verschillende eisen waaraan het systeem moet voldoen.
Dit zijn de volgende:
• De persoon moet worden gedetecteerd (beneden of boven aan de trap)
• De led moeten afhankelijk van de richting van de persoon gaan branden en achter de persoon weer uit gaan.

1 DETECTIE VAN DE PERSOON

De detectie van de persoon gebeurt door de PIR die ik heb geinstalleerd bij de trapopgang

2 LEDS MOETEN IN DE LOOPRICHTING GAAN BRANDEN

Dit betekend, dat de leds afhankelijk van de PIR moeten gaan branden. Dus als de PIR beneden een persoon detecteerd, dan moeten de leds van onder naar boven gaan branden

Het programma ziet er als volgt uit:
/*
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 =8; // voor attiny 0;
//Pin connected to SH_CP of 74HC595
int clockPin =12;// voor attiny 4;
////Pin connected to DS of 74HC595
int dataPin = 11;//voor attiny 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[12];
byte dataArrayDown[13];
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] = 0x60; //01100000
dataArrayUp[9] = 0x60; //01100000
dataArrayUp[10] = 0x60; //01100000
dataArrayUp[11] = 0x00; //00000000

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

}

void loop() {

if (digitalRead(7)==HIGH)// voor attiny: if (digitalRead(2)==HIGH) //van beneden naar boven
{
//##BEGIN – code voor schuiven naar result
for (int j = 0; j < 12; 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();
}

if (digitalRead(9)==HIGH) // voor attiny: if (digitalRead(1)==HIGH) //van beneden naar boven
{
//##BEGIN – code voor schuiven naar result
for (int j = 0; j < 13; 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);
}

Het voert te ver om dit hele programma uit te gaan leggen, maar de volgorde van branden is te vinden in de dataArrayUp en de dataArrayDown.

waarheidstabel automatische trapverlichting
waarheidstabel automatische trapverlichting

Het voorbeeld hierboven is van de trap naar de overloop. Hier is te zien dat ik twee leds aan elkaar heb gekoppeld en er zo voor heb gezorgd, dat ik maar maximaal 8 uitgangen van de 74HC595 nodig had. Anders had ik twee 74HC595 IC’s moeten koppelen.
Dit omzet naar een waarheids tabel geeft het volgende

Waarheidstabel trapverlichting
Waarheidstabel trapverlichting

S1 en S2 zijn de sensoren die onder en boven aan te trap zitten.
Als deze 1 worden betekend dat de sensor wat heeft gezien. Er is dus een persoon gedetecteerd. De actie die dan volgt is afhankelijk van welke sensor actief is geworden.

Waarheidstabel met omzetting naar hexadecimaal voor de 74hc595
Waarheidstabel met omzetting naar hexadecimaal voor de 74hc595

Zoals te zien is, is het naar beneden lopen uitgewerkt, in welke volgorde de leds moeten gaan branden. Dit is weer om te zetten zoals hierboven te zien is naar hexadecimale getallen.
Deze hexadecimale getallen worden door de Arduino in de 74HC595 gestuurd en deze kan dan met deze gegevens de leds laten branden.
De laatste kolom is ook weer te vinden in het programma een eindje terug in dit document.

SOFTWARE IN EEN ATTINY PLAATSEN

Omdat de Arduino niet constant gebruikt kon worden om de trap te verlichten, maar er ook nog andere dingen op moeten worden getest en gedaan is er besloten om de software in de Arduino om te programmeren in een ATTiny 85.
Er is voor de ATTiny85 gekozen omdat deze 5 verschillende in/uitgangen heeft. Hierdoor is het mogelijk om de drie uitgangen die nodig zijn voor het aansturen van de 74HC595 te realiseren en ook nog twee ingangen over te houden voor de sensoren.
De programmering van een ATTiny houdt in dat de Arduino moet worden gezet in de programmeerstand en hierdoor de software in de chip kan worden geplaatst.

AANSLUITEN EN PROGRAMMEREN

De onderstaande pagina’s welke schuin zijn gedrukt, komen van http://highlowtech.org/?p=1695 en van http://highlowtech.org/?p=1706
http://highlowtech.org/?p=1695

Programming an ATtiny w/ Arduino 1.0

This tutorial shows you how to program an ATtiny45, ATtiny85, ATtiny44 or ATtiny84 microcontroller using the Arduino software. These are small, cheap ($2-3) microcontrollers that are convenient for running simple programs. The ATtiny45 and ATtiny85 have eight legs and are almost identical, except that the ATtiny85 has twice the memory of the ATtiny45 and can therefore hold more complex programs. The ATtiny44 and ATtiny84 have 14-legs and more inputs and outputs. Thanks to Mark Sproul for his work on making the Arduino core portable across processors.
ATtiny45/85 vs. an Arduino Board
The ATtiny45 or 85 is a great option for running simple Arduino programs: it’s small, cheap and relatively easy to use. It does, however, have some limitations relative to the ATmega328P on an Arduino Uno. There are fewer pins, meaning you can’t connect as many components. There’s less flash memory (4KB or 8KB instead of 32KB), meaning your programs can’t be as big. There’s less RAM (256 or 512 bytes instead of 2KB), meaning you can’t store as much data. And there’s no hardware serial port or I2C port (Wire library), making communication trickier. (There are workarounds, like the SoftwareSerial library or the TinyWire library, but they’re not as robust and flexible.)
In short, then, if your project requires only a few simple inputs and/or outputs, you’re probably fine using an ATtiny. If you’re trying to hook up more components or do more complex communication or data processing, though, you’re probably better off with something like the ATmega328P on an Arduino Uno. If you want something smaller and cheaper than a full Arduino board, you might try using an ATmega328P on a breadboard instead.

Materials and Tools

For this tutorial, you’ll need:

An in-system programmer (ISP), a piece of hardware used to load programs onto the ATtiny. Options include:
The Tiny AVR Programmer, a board we developed with SparkFun specifically for programming ATtiny45/85s.

Another commercial programmer like the AVRISP mkII or USBtinyISP.

a Arduino Uno or Duemilanove (w/ an ATmega328, not an older board with an ATmega168). See this tutorial for using an Arduino board as a programmer
ATtiny45 or ATtiny85 (8-pin DIP package) or an ATtiny44 or ATtiny84.

a solderless breadboard and jumper wires (unless you’re using the TinyProgrammer w/ the ATtiny45 or 85)
For more information, see our list of materials and parts and our list of prototyping supplies.
Download
ATtiny master.zip (hosted by GitHub)

Installing ATtiny support in Arduino

If you haven’t already, download the Arduino software, version 1.0.4 (1.0.3 and 1.0.1 should work too, but NOT 1.0.2). Install the Arduino software, following the instructions for Windows or for Mac OS X.
Download the ATiny master.zip file from the link above.
Unzip the attiny master.zip file. It should contain an “attiny-master” folder that contains an “attiny” folder.
Locate your Arduino sketchbook folder (you can find its location in the preferences dialog in the Arduino software)

Create a new sub-folder called “hardware” in the sketchbook folder, if it doesn’t exist already.

Copy the “attiny” folder (not the attiny-master folder) from the unzipped ATtiny master.zip to the “hardware” folder. You should end up with folder structure like Documents > Arduino > hardware > attiny that contains the file boards.txt and another folder called variants.
Restart the Arduino development environment.
You should see ATtiny entries in the Tools > Board menu.

Selecteren attiny in de Arduino IDE
Selecteren attiny in de Arduino IDE

Connecting the ATtiny

You’ll need to provide power to the ATtiny and connect it to your programmer. That is, connecting MISO, MOSI, SCK, RESET, VCC, and GND of the programmer to the corresponding pins on the ATtiny. (Or, if you’re using an circuit w/ an ATtiny, simply connect the programmer to the ISP header on the board – you may also need to power the board separately.)
Instructions and diagrams are available for:

 

 

Aansluitschema attiny op de Arduino
Aansluitschema attiny op de Arduino

Programming the ATtiny

Next, we can use the Arduino as an ISP to upload a program to the ATtiny:
Open the Blink sketch from the examples menu.
Change the pin numbers from 13 to 0.

Select the appropriate item from the Tools > Board menu (leave the serial port set to that of your Arduino board).

Select the appropriate item from the Tools > Programmer menu (e.g. “Arduino as ISP” if you’re using an Arduino board as the programmer, USBtinyISP for the USBtinyISP, FabISP, or TinyProgrammer, etc).

Upload the sketch.

You should see “Done uploading.” in the Arduino software and no error messages. If you then connect an LED between pin 0 and ground, you should see it blink on and off. Note that you may need to disconnect the LED before uploading a new program.
Configuring the ATtiny to run at 8 MHz (for SoftwareSerial support)

By default, the ATtiny’s run at 1 MHz (the setting used by the unmodified “ATtiny45″, etc. board menu items). You need to do an extra step to configure the microcontroller to run at 8 MHz – necessary for use of the SoftwareSerial library. Once you have the microcontroller connected, select the appropriate item from the Boards menu (e.g. “ATtiny45 (8 MHz)”). Then, run the “Burn Bootloader” command from the Tools menu. This configures the fuse bits of the microcontroller so it runs at 8 MHz. Note that the fuse bits keep their value until you explicitly change them, so you’ll only need to do this step once for each microcontroller. (Note this doesn’t actually burn a bootloader onto the board; you’ll still need to upload new programs using an external programmer.)
ATtiny Microcontroller Pin-Outs

Pinout Attiny45 en Attiny 85
Pinout Attiny45 en Attiny 85
Pinout ATtiny 44 en ATTiny 84
Pinout ATtiny 44 en ATTiny 84

 

ARDUINO AS PROGRAMMER

http://highlowtech.org/?p=1706
This tutorial shows you how to wire up an Arduino used as an ISP (programmer) to an ATtiny45 or ATtiny85. To find out how to write code for the microcontroller, see the the tutorial on programming an ATtiny using the Arduino 1.0.1 software (or the older version for Arduino 0022).

Materials and Tools

For this tutorial, you’ll need:
Arduino Uno or Duemilanove (w/ an ATmega328, not an older board with an ATmega168)
ATtiny45 or ATtiny85 (8-pin DIP package)
a 10 uF capacitor (e.g. from Sparkfun or from Digi-Key)
a breadboard
jumper wires
For more information, see our list of materials and parts and our list of prototyping supplies.
Download and Install the Arduino Software
You’ll need the Arduino software (version 1.0.1 or 0022). Installation instructions for the Arduino software are available for Windows and for Mac OS X.

Turning the Arduino board into a programmer

We’re going to use the Arduino board to program the ATtiny. First, we’ll need to turn the Arduino board into an “in-system programmer” (ISP). To this:
Run the Arduino development environment.
Open the ArduinoISP sketch from the examples menu.
Note for Arduino 1.0: you need to make a small change to the ArduinoISP sketch before uploading it. Find the line in the heartbeat() function that says “delay(40);” and change it to “delay(20);”.
Select the board and serial port that correspond to your Arduino board.

Upload the ArduinoISP sketch.

Connecting the Arduino board and the ATtiny

We’ll connect the Arduino board to the ATtiny as shown in the following diagram. Use the dot in the corner of the ATtiny to orient it properly. We’ll also connect a 10 uF capacitor between reset and ground on the Arduino board as shown in the diagram (the stripe on the capacitor that’s marked with a negative sign (-) should go to ground). The capacitor prevents the Arduino board from resetting (which starts the bootloader), thus ensuring that the Arduino IDE talks to the ArduinoISP (not the bootloader) during the upload of sketches. (The capacitor is needed if you’re using an Arduino Uno, and might also be necessary for an Arduino Duemilanove.)

Aansluitingen Arduino en Attiny
Aansluitingen Arduino en Attiny

 

Pin connections:

ATtiny Pin 2 to Arduino Pin 13 (or SCK of another programmer)
ATtiny Pin 1 to Arduino Pin 12 (or MISO of another programmer)
ATtiny Pin 0 to Arduino Pin 11 (or MOSI of another programmer)
ATtiny Reset Pin to Arduino Pin 10 (or RESET of another programmer)

Het schema wat ik heb gebruikt en wat mij goed bevalt is het volgende:

Aansluitingen ATTiny85 en de Aruino
Aansluitingen ATTiny85 en de Aruino

Bijgeschreven zijn de pennummers van de Arduino mega.

AANSLUITEN ATTINY85 EN 74HC595 MET LEDS

Om een aansluiting op de ATTiny te realiseren, moet er worden nagedacht over de pennen die worden gebruikt voor de in en output

Attiny 85
Attiny 85

De pinout die worden gebruikt na programmeren zijn pin 0, pin 1, pin 2, pin 3 en pin 4
In het programma heb ik dit al staan als het volgende:
//Pin connected to ST_CP of 74HC595
int latchPin =8; // voor attiny 0;
//Pin connected to SH_CP of 74HC595
int clockPin =12;// voor attiny 4;
////Pin connected to DS of 74HC595
int dataPin = 11;//voor attiny 3;
in de regel: int latchPin =8; // voor attiny 0; moet acht worden vervangen door 0. Dat houdt in dat de aansluiting 8 van de arduino wordt vervangen door 0 van de ATTiny!!!

 

Voor het aansluiten heb ik gebruik gemaakt van het volgende schema:

getekend schema Attiny, 74hc595 en leds
getekend schema Attiny, 74hc595 en leds

Het is een beetje slecht te zien, maar vanaf de 74HC595 zijn enkele wijzigingen doorgevoerd:
Vanaf pin 11 loopt nu een draadje naar pin 4 op de ATTiny
Vanaf pin 14 loopt nu een draadje naar pin 3 op de ATTiny
De sensoren zijn verplaatst van pen 3 en 4 naar pen 1 en 2.

SENSOREN (PIR)

De sensoren waar ik gebruik van maak zijn de volgende sensoren:

Pinout PIR module
Pinout PIR module

Deze sensoren zijn erg gevoelig en kunnen tot 7 meter afstand meten. Dit kan soms handig zijn om op grotere afstanden iemand te detecteren om bijvoorbeeld een lamp aan of uit te schakelen of een alarm in te schakelen.
Deze sensoren zijn niet duur, varierend van $1 tot $5 per stuk. Even zoeken op ebay. Daar zijn ze vaak wel goedkoop te krijgen. LET WEL OP DE VERZENDKOSTEN!!!

PIR sensor, module met potmeters
PIR sensor, module met potmeters

De GND en de V+ sluit je respectievelijk aan op de GND van je voeding en op de +5V.
Het signaal OUT is het signaal wat je aansluit op je Arduino of op – zoals hiervoor besproken- op de pennen 1 en 2.
Nadat alles was gemaakt op een breadboard, getest en gedaan (nu kun je de ATTiny nog programmeren) en alles is goed getest, kan alles op een printje worden gemonteerd. Hiervoor heb ik geen PCB gemaakt omdat ik daar hier de faciliteiten niet voor heb dus ik heb een bordje in elkaar geknutseld en tot nu toe werkt alles naar behoren.

13 gedachten over “TRAPVERLICHTING OP 5V NAAR BOVEN EN NAAR DE ZOLDER”

  1. Ik wil in een verticale transparante kunststof buis van 500 mm. diameter een lichtverloop realiseren. Een verloop van boven naar beneden en weer andersom. Wie kan mij helpen ? Het betreft een kunstobject.
    Hartelijke groet,
    Arno Arts

    1. Beste Arno,

      in feite is dat hetzelfde als ik hier heb gerealiseerd. Alleen hoeven er dan geen sensoren worden gebruikt.

      Groeten André

  2. Hallo Andre

    Ik kan alle plaatjes niet zien.
    Wil graag zelf ook zoiets bouwen.
    Hoe kan ik hem bouwen met 2 shift registers, heb 13 trap treden.
    Heb een Arduino One

    1. Hallo Harreld,

      Ik heb de site nog even na gekeken, maar zo te zien gaat het met de plaatjes wel goed..

      Je kunt hem inderdaad bouwen met twee shift registers.
      Ik heb zelf ook 13 treden geloof ik, maar ik had geen zin om twee shift registers te bestellen.
      Dus heb ik er voor gekozen om twee leds per keer te laten aan en uit gaan.
      In het totaal branden er dus elke keer 6 leds. Dit geeft genoeg licht om naar boven/beneden te lopen.

      De tekst hieronder heb ik gevonden op: http://arduino.cc/en/Tutorial/ShiftOut

      Mocht je nog vragen hebben, dan hoor ik het wel.

      In this example you’ll add a second shift register, doubling the number of output pins you have while still using the same number of pins from the Arduino.
      The Circuit
      1. Add a second shift register.

      Starting from the previous example, you should put a second shift register on the board. It should have the same leads to power and ground.

      null

      2. Connect the 2 registers.

      Two of these connections simply extend the same clock and latch signal from the Arduino to the second shift register (yellow and green wires). The blue wire is going from the serial out pin (pin 9) of the first shift register to the serial data input (pin 14) of the second register.

      null

      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
      null

      Circuit Diagram
      null


      //**************************************************************//
      // 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 74HC595
      int latchPin = 8;
      //Pin connected to SH_CP of 74HC595
      int clockPin = 12;
      ////Pin connected to DS of 74HC595
      int dataPin = 11;

      //holders for infromation you're going to pass to shifting function
      byte 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 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<

      1. Hallo Andre,

        Dat met die plaatjes is inmiddels opgelost, ze werden geblokkeerd door mijn internet content filter.

        Ik ben van plan om 13 x een 2W 12V led te gebruiken.
        http://www.banggood.com/G4-2W-LED-Bulb-Crystal-Light-Bulb-White-and-Warm-White-Light-p-89609.html

        Kan ik deze zo maar aansluiten op de uitgangs poort van de shift registers, (5V) heb 12V nodig voor LED en kan de arduino de stroom leveren als ze alle 13 tegelijk branden, of moet ik achter de poort van de shift register een TIP120 NPN Power Darlington Transistor plaatsen, en de leds voeden d.m.v externe 12v voeding.

        1. Eh Harreld,

          Dat is even een goede vraag…

          Een led zal branden naar het vermogen dat hij aangeleverd krijgt, hoewel ik zelf denk als je alle 13 leds laat branden, de Arduino dit vermogen niet kan leveren. Ik zou het zelf dan via een andere manier gaan doen zoals inderdaad je NPN transistor. Daar ben ik weer niet zo in thuis… Maar daar zijn op internet wel plaatjes enzo van te vinden. Ik zou zelf niet proberen om zoveel uit de Arduino te gaan halen, maar een externe voeding gebruiken eventueel dmv die tip120

          Mijn leds zijn 1W, maar ook 12V volgens mij. Ik laat er max 6 tegelijk branden anders is voor mij het idee van een traploop-licht verdwenen.

          1. Andre Bedankt voor de informatie, ga er mee bezig het programmeren zal het lastigste worden denk ik daar ben ik niet zo in thuis.

  3. Ach Harreld, al doende leer je… En bij vragen kun je eventueel ook hier wel terecht.. Misschien kan ik ze oplossen 🙂

    Ik hoor het wel

  4. Hallo Andre,

    Ik ga toch maar 8 leds gebruiken, het is toch een beetje overkill aan licht.
    Ik heb geprobeerd om jouw code te gebruiken in een sketch.
    Maar ik krijg steeds foutmeldingen bij het compileren.
    Heb de code geknipt van de site en in de Arduino software geplakt. Enig idee waar het fout gaat ?

    Gr Harreld

    Zie hieronder de foutmelding.

    Arduino: 1.6.1 (Windows 7), Board:”Arduino Uno”

    C:\Program Files (x86)\Arduino/hardware/tools/avr/bin/avr-g++ -c -g -Os -w -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -MMD -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10601 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR -IC:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino -IC:\Program Files (x86)\Arduino\hardware\arduino\avr\variants\standard C:\Users\WERK\AppData\Local\Temp\build1664355984146818950.tmp\TrapKloppenburg.cpp -o C:\Users\WERK\AppData\Local\Temp\build1664355984146818950.tmp\TrapKloppenburg.cpp.o
    TrapKloppenburg.ino:133:1: error: stray ‘\’ in program
    TrapKloppenburg.ino: In function ‘void shiftOut(int, int, byte)’:
    TrapKloppenburg.ino:133:19: error: expected ‘)’ before ‘u2013’
    TrapKloppenburg.ino:133:19: error: ‘u2013’ was not declared in this scope
    TrapKloppenburg.ino:133:24: error: expected ‘;’ before ‘)’ token
    TrapKloppenburg.ino:157:1: error: expected ‘}’ at end of input
    Fout bij compileren.

  5. Hoi Herrald,

    ik heb het eens een beetje nagekeken, maar de code is inderdaad niet goed. Dat komt doordat er gekopieerd en geplakt is vanuit de arduino naar mijn website.

    Ik heb de code online geplaatst op het volgende adres:
    klik hier

    Veel succes er mee en mocht het niet lukken hoor ik het wel.

    Groeten André

    1. Bedankt voor de snelle respons! Dit script lijkt het wel te doen, ga hem proberen.
      Met de TIP120 Transistors is ook gelukt, kan nu zwaardere apparaten schakelen, tussen de schift register en de Tip 120 zit een weerstand van 2,2kOHM op de base, en het lijkt te functioneren. getest met 12V en een 2W led. Nu verder uitbouwen naar 8 Leds

Geef een reactie

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

Deze website gebruikt Akismet om spam te verminderen. Bekijk hoe je reactie-gegevens worden verwerkt.