TRAPVERLICHTING OP 5V NAAR BOVEN EN NAAR DE ZOLDER

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.

 

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 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!

 

LEDS 1W

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.

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

 

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

 

 

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.

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

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.

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

Programming an ATtiny w/ Arduino 1.6 (or 1.0)

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.

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:

 

 

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

 

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.)

 

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:

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

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:

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:

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!!!

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.