Raspberry Pi met pilight voor noobs deel 1

Door Koffie op zondag 26 januari 2014 18:21 - Reacties (8)
Categorie: -, Views: 13.984

Omdat ik nog wel eens reacties krijg dat men een Raspberry Pi (van een verloren XBMC projectje) over heeft en graag met simpele domotica wil beginnen leek het mij leuk om in een aantal posts stap voor stap uit te leggen wat je moet doen. Aan het eind van deze serie posts heb je een Raspberry Pi waarmee je diverse lampen en je kachel kunt aansturen (voor de kachel ga ik uit van een normale CV of 2-wegklep welke een normaal aan/uit contact gebruikt).
Deze eerste post is simpel, we gaan beginnen bij het begin :)

Benodigdheden:
Raspberry Pi
Meest recente versie Raspbian
Win32 Disk imager
SD kaart
USB wifi dongle (optioneel)
Putty (optioneel)

Raspbian downloaden en installeren
Download Raspbian en Win32 Disk imager via bovenstaande links.
Na het downloaden start je Wind32 Disk imager en schrijf je het gedownloade IMG bestand naar je SD kaart.

http://zooi.oostindie.com/images/654win32diskimager2_tn.jpg

Tip : mocht je een SD kaart die eerder in een Raspberry Pi gezeten heeft opnieuw willen gebruiken, en je krijgt de melding dat er te weinig ruimte is omdat er slechts een partitie van 8 Mb is : stop de kaart in je camera en kies voor formatteren ;)

De eerste keer booten
Deze stap kan op 2 manieren : via SSH of via een HDMI scherm aan de pi (met keyboard).
Als je via SSH wil connecten zul je uiteraard even in je DHCP server moeten kijken wat het IP adres is.
Maak vervolgens verbinding met putty naar het IP adres van je Raspberry Pi.

http://zooi.oostindie.com/images/509putty_tn.jpg http://zooi.oostindie.com/images/655pi_login_tn.jpg

Standaard username is pi met als wachtwoord raspberry.

Wanner je gewoon een scherm met toetsenbord gebruikt hoef je niet in te loggen.
Het eerste wat je nu moet doen, is een korte configuratie doorlopen. Configureren doe je met het commando sudo raspi-config.

http://zooi.oostindie.com/images/508raspi_config_tn.jpg http://zooi.oostindie.com/images/381raspi_config_new_tn.jpg

Van boven naar beneden zijn dit de belangrijkste wijzigingen die je aan moet brengen. Indien je een nieuwere versie van raspi-config hebt, zal het er iets minder nerdie staan (de tweede omschrijving).

- expand_rootfs / Expand filesystem
Deze optie zorgt ervoor dat de partitie op je SD kaart vergroot word naar het maximaal haalbare voor je kaartje. Standaard is de partitie maar 2 Gb, de rest is dan ongebruikt.

- change_pass / Change user password
Het is verstandig om het standaard wachtwoord aan te passen naar iets anders :)

-change_timezone / Internationalisation Options -> Change timezone
Stel deze in op Europe en daarna Amsterdam.

-memory_split / Advanced options -> memory split
Hiermee kun je de verdeling van het geheugen wijzigen tussen de GPU en CPU Standaard zet ik het geheugen voor de GPU op 16 Mb, aangezien we zoveel mogelijk geheugen voor processen willen en de Raspberry Pi ergens headless in de hoek gegooid zal worden.

-SSH / Advanced options -> SSH
Eerlijk gezegd weet ik niet of de Raspberry Pi eenmalig met SSH opstart, of dat dit default aan staat. Voor de zekerheid maar even enablen dus ;)

-update / Advanced options -> Update
Hiermee update je raspi-config zelf. Zeker als je geen optie 'camera' ziet is het verstandig een update te draaien.

Als echte dwangneuroot wil je na deze opties je Raspberry Pi rebooten: sudo reboot.
Na het rebooten kun je de Raspberry Pi headless gebruiken, het is niet meer nodig om deze aan een scherm met toetsenbord te hangen (mag wel).

Upddaten en basis software installeren
Afhankelijk van hoe oud je Raspbian image is, is het verstandig eerst een update te draaien. Let op : afhankelijk van de snelheid van je SD kaart kan dit even duren.
Eerst start je het commando sudo apt-get update hiermee ververs je de lokale lijst met repositories. Na het updaten start je sudo apt-get upgrade. Met dit commando update je lokale software die via apt-get geinstalleerd is.

Na deze update ronden moet er nog wat extra software geÔnstalleerd worden. Voer de volgende regels stap voor stap uit (voor de gevorderde gebruiker : ik weet dat je alles met 1 lange opdracht kunt downloaden installeren, maar ik vind het fijner om het stap voor stap te doen).
sudo apt-get install git-core
sudo apt-get install php5
sudo apt-get install php5-mysql
sudo apt-get install samba samba-common samba-common-bin

Samba configureren
Om enigszins op makkelijk wijze bestanden van en naar de Raspberry Pi te hevelen maken we gebruik van samba. Voer de volgende stappen uit om een share aan te maken.
Maak een directory aan in de homedirectory van user pi (standaard zit je al in deze directory bij het starten van een SSH sessie) : mkdir share.
Ga naar de samba directory: cd /etc/samba/
Verwijder de default configuratie : sudo rm -rf smb.conf
Maak een nieuwe configuratie : sudo nano smb.conf
Zorg dat je nieuwe config er als volgt uit ziet:


code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
[global]
workgroup = WORKGROUP
netbios name = RASPBERRYPI
server string = %h server (Samba %v)
log file = /var/log/samba/log.%m
max log size = 1000
syslog = 0

[SHARE]
path=/home/pi/share
browseable=yes
writeable=yes
valid users = pi
admin users = pi



Sluit af met de toetsencombinatie CTRL-x en bevestig het schrijven van de wijzigingen door op y te drukken. Houd de opgegeven naam aan.
Voer het volgende commando uit om je username en password voor de share op te geven: sudo smbpasswd –a pi wanneer er om een wachtwoord gevraagd word kun je deze opgeven. Ik kies er altijd voor (zoals aan de commando's te merken is) om zowel username als password gelijk te houden aan het linux account pi.
Vanaf nu kun je via \\raspberrypi.local\share (of via het IP adres) bij je nieuwe samba share

WiFi installeren (optioneel)
Let op : voor gebruik van een USB WiFi dongle heb je een goede voeding nodig. Indien je voeding te weinig ampere kan leveren, is de kans groot dat je Raspberry Pi instabiel word.
Als je gebruik wilt maken van een USB WiFi dongle, volg dan de volgende stappen uit:
Start de Raspberry Pi op met de USB dongle erin.
Maak verbinding met SSH (bedraad)
Controleer of je dongle gezien word met het commando lsusb in mijn test setup word deze gevonden als "Belkin Components F7D2101 802.11n Surf & Share Wireless Adapter v1000 [Realtek RTL8192SU]". Mocht je dongle niet gevonden worden, zul je een guide moeten zoeken hoe je een driver installeert - ik heb namelijk nog nooit een WiFi dongle gehad die niet direct herkend werd :+
Nu we weten dat de WiFi dongle gevonden word, kunnen we de juiste software installeren.
sudo apt-get install wicd wicd-curses
Als de installatie klaar is start je met sudo wicd-curses de grafische configuratie op.

http://zooi.oostindie.com/images/285wicd_curses_tn.jpg

Als het goed is, zie je nu tenmisnte je eigen WiFi netwerk. Selecteer het juiste WiFi netwerk en druk op het pijltje naar rechts. Je kunt nu je verbinding configureren.
De belangrijkste opties die je hier moet kiezen zijn "Use DHCP Hostname" , " Automaticly connect to this network" en uiteraard je WPA key.
Sla de wijzigingen op met F10

http://zooi.oostindie.com/images/843wicd_curses2_tn.jpg

Sluit de configuratie af door de q in te toetsen.
Als laatste moet er nog een kleine aanpassing de netwerkconfiguratie plaatsvinden. Bewerk de configuratie met het volgende commando: /etc/network/interfaces
Zorg dat de inhoud er als volgt uit ziet:

code:
1
2
3
4
5
6
7
8
9
10
auto lo

iface lo inet loopback
iface eth0 inet dhcp

allow-hotplug wlan0
auto wlan0
iface wlan0 inet dhcp
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp


Sluit af met de toetsencombinatie CTRL-x en bevestig het schrijven van de wijzigingen door op y te drukken. Houd de opgegeven naam aan.
Reboot de Raspberry Pi middels sudo reboot en trek de netwerkkabel er uit.
Zoek in je DHCP server op welk IP adres je Raspberry Pi nu heeft gekregen (indien je geen vast IP hebt opgegeven) en test of je een verbinding kunt maken met SSH.

Je hebt nu een Raspberry Pi (al dan niet draadloos) klaar voor de volgende stappen. Have fun with it :)
Mocht je nog vragen hebben, kun je die uiteraard in het reactie venster hieronder kwijt.

DIY draadloze temperatuursensor voor pilight

Door Koffie op zondag 26 januari 2014 16:41 - Reacties (17)
Categorie: -, Views: 9.884

Zoals uit mijn eerdere posts al op te maken is, gebruik ik de Raspberry Pi voor het aansturen van centrale verwarming.

Door een probleem met de electrabuizen in mijn plafond komt de DS18B20 sensor op een onhandige plaats uit : een centraaldoos in het plafond vlakbij een radiator.
Aangezien warme lucht stijgt, de sensor in de buurt van een radiator zit en dit geheel ook nog eens om de hoek van de zithoek hangt (mijn woonkamer is een L vorm) geeft dit een totaal vertekend beeld van de werkelijkheid tov wat de sensor meet.
Hier moest dus iets aan gedaan worden!
Na een weekend prutsen ben ik tot het volgende gekomen:

http://zooi.oostindie.com/images/3362014_01_12_11_tn.43_tn.11_tn.jpg

Nu je zul je direct willen roepen 'maar ik zie niets!' en dat was nu precies de bedoeling ;)
Wat je ziet is een oud fotolijstje met daarachter een breadboard geplakt, Op het breadboard zit een ATtiny84 met een DS18B20 en een 433MHz Superheterodyne RF sender.
De ATtiny is zo geprogrammeerd dat deze elke minuut de temperatuur uitleest en via de RF module de lucht instuurt.
Omdat ik geen zin (en kennis) had een heel nieuw RF protocol te verzinnen voor pilight, heb ik de KaKu_new protocol misbruikt.
Het KaKu_New dimmer protocol bied de optie om een dimstand van 0 t/m 15 te versturen. Als je dus een bepaald ID neemt en daar 2 opeenvolgende unit's van pakt heb je al 2 x 15 waardes om te versturen.
pilight kan out of the box al KaKu_new dimmer ontvangen, dus het is alleen nog een kwestie van het detecteren van de broadcast en deze waarde uit te lezen. Vervolgens deze waarde naar een generic_weather protcol sturen en klaar ben je.

Nu weet ik dat pilight ook diiverse andere weather protocols onderstuend, maar op de een of andere manier krijg ik de output van mijn Alecto weerstation niet op pilight binnen. Aangezien het versturen van de omgevingstemperatuur al in de planning lag voor onze te bouwen module, was dit een mooi begin.

Voor de ATtiny heb je de volgden code nodig:

code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <OneWire.h> // http://www.pjrc.com/teensy/arduino_libraries/OneWire.zip
#include <DallasTemperature.h> // http://download.milesburton.com/Arduino/MaximTemperature/DallasTemperature_LATEST.zip
#include <NewRemoteTransmitter.h>

#define txPin 10     // RF TRANSMITTER PIN
const int ledPin = 8;

#define ONE_WIRE_BUS 9

OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance
DallasTemperature sensors(&oneWire); // Pass our oneWire reference to Dallas Temperature

void setup() {
    pinMode(ledPin, OUTPUT); // LED
    pinMode(txPin, OUTPUT); // RF sender
}

void loop() {
  int NewUnit;
  int NewId;
  int temperature;

NewRemoteTransmitter transmitter(8934000, txPin, 245,2);
  Blink(ledPin,2);  
  sensors.begin(); //start up temp sensor
  sensors.requestTemperatures(); // Get the temperature
  temperature = sensors.getTempCByIndex(0);
  int RoundTemp = round(temperature);

  if(RoundTemp <= 15) {
    NewId = 1;
  }
  
  if(RoundTemp >= 16) {
    NewId = 2;
    RoundTemp = RoundTemp - 15;
  }  
  
  transmitter.sendDim(NewId, RoundTemp);    
  delay(60000);
}

void Blink(int led, int times){
  for (int i=0; i< times; i++){
    digitalWrite(ledPin,HIGH);
    delay (50);
    digitalWrite(ledPin,LOW);
    delay (50);
  }
}



Deze code zorgt ervoor dat de ATtiny elke minuut de temperatuur uitleest en als KaKu_new dimmer code lucht instuurt.
Wanneer het 6 graden is, word er dus het volgende verstuurd : unit [b]8934000[/b[ id 1 dimlevel 6. Wanner het echter 16 graden is, zal hij het volgende versturen: unit [b]8934000[/b[ id 2 dimlevel 1.

Nu is het een kwestie van een process script draaien op je Raspberry Pi welke alle ontvangen protocollen in de gaten houd, en reageert wanneer er een unit 8934000 voorbij komt.
In een latere post zal ik het process script wat ik voor pilight gebruik uitleggen.

Het eindresultaat ziet er dan zo uit:

Het gevecht met het bubbelbad (en hoe de Raspberry Pi won)

Door Koffie op zaterdag 18 januari 2014 22:19 - Reacties (12)
Categorie: -, Views: 7.429

Mijn vorige blogpost sloot ik af met de melding dat ik nog uitleg zou geven over de 'aanwezigheidsmelder' die ik in de badkamer heb ingebouwd.
Eerst een korte uitleg over die aanwezigheidsmelder. Aan de bestaande schakelaar van de badkamer hangt een AWMT-230.
Elke keer als je de schakelaar van je bestaande verlichting schakelt, word er een OF of OFF signaal verzonden.
Op deze manier zou je met 1 bestaande schakelaar diverse KaKu ontvangers kunnen schakelen.
De zender die ik in de badkamer heb geplaatst, stuurt echter helemaal niets aan.
De enige reden dat deze zender geplaatst is, is om te zorgen dat de Raspberry Pi een ON en OFF signaal ontvangt wanneer iemand in de badkamer komt en weer weggaat (het komt eigenlijk niet voor dat de badkamer gebruikt word zonder de verlichting te schakelen).

Goed, het is nu duidelijk dat er op een simpele manier gedetecteerd kan worden dat er iemand in de badkamer aanwezig is. Maar waarom al deze moeite?!
Dat is eigenlijk heel simpel. Wij hebben een bubbelbad met jetstreams en waterstralen. Erg leuk en lekker om in te dobberen.
Dit type bad heeft echter 1 groot nadeel : zodra de sensor water heeft gezien, zal hij zichzelf na circa 10 minuten droog blazen. Leuke feature, maar onhandig als de controller van het bad geen flauw benul van de tijd heeft. Inderdaad, als het bad vind dat hij moet blazen dan doet hij dat. Ook al is het midden in de nacht :X
Het wil nog wel eens voorkomen dat ik even vlug mijn kop onder de douchekop van het bad steek om even op te frissen. Als dit 's avonds laat is, zal het bad een kwartier later gaan blazen.
Ook op een hete klamme vochtige zomerdag wil de sensor wel eens wat van slag raken en enkele keren gaan blazen.
Enfin, te pas en te onpas staat dat ding te blazen terwijl de rest van het huishouden mag bijkomen van een hartverzakking.

Ik dacht dit simpel op te lossen door een KaKu ACM-1000 tussen de voeding van het bad te plaatsen, en deze alleen aan te schakelen wanneer er iemand in de badkamer aanwezig was.
Leuk idee, echter is de firmware van het bad zo ingesteld dat deze bij inschakelen ook altijd even een blaasconcert geeft. Terug bij af dus.
Tijd om technische documentatie van het bad door te nemen en de bedradingen van de controllerbox te bekijken.
Vanaf de controllerbox loopt een dikke kabel naar de luchtpomp. De aanname dat dit een rechtstreekse 220v verbinding naar de pomp was (zonder dataverbinding) bleek juist.
De kabel heb ik doorgeknipt en voorzien van een relais.
Ook de hoofdvoeding van de controllerbox heb ik voorzien van een relais, en vervolgens beide relais op een Raspberry Pi aangesloten.
Nu was ik eindelijk in staat om het bad te laten blazen wanneer het mij uitkomt, in plaats van andersom :D
Omdat er toch een Raspberry Pi in de badkamer kwam, heb ik er meteen een DHT11 sensor op aangesloten, zodat ik de temperatuur en luchtvochtigheid kan meten. Deze data worden in een MySQL database gelogd.

De laatste stap was beide systemen aan elkaar knopen: Standaard staat het relais van de hoofdvoeding naar het bad aan, maar die van de luchtpomp uit. Het bad kan blazen wat hij wil, er gebeurd niets.
Wanneer er iemand de badkamer in komt (lees: het licht aan zet), word er een script gestart. Dit script controleert het tijdstip. Wanneer het buiten de gewenste tijden valt (06:30 tot 22:00), stopt het script direct.
Binnen de ingestelde tijden zal het script het relais naar de luchtpomp aan zetten en stopt het script.
Wanneer iemand de badkamer verlaat word weer het script gestart. Is het buiten de ingestelde tijden, dan zal deze direct het relais uit zetten. Is het echter binnen de tijden, dan gaat er een timer van 15 minuten lopen. Na deze 15 minuten zal het script het relais uit zetten. Gedurende deze 15 minuten word er voortdurend in de gaten gehouden of het licht niet weer ingeschakeld is. In die geval stopt het script zonder iets met het relais te doen.

Het heeft allemaal wat voeten in de aarde gehad, maar dit was een gevecht tussen een man en zijn badkamer, waar maar 1 winnaar uit kon komen .. ook al was het met behulp van een Raspberry Pi :+
Volgende stap is om de Raspberry Pi te vervangen voor een breadboard/protoboard met ATtiny, maar destijds had ik nog niet de kennis om dit met een ATtiny te doen.

Update
Op verzoek even een soort schema gemaakt.
Omdat dit de eerste keer is dat ik met dergelijke software werk, was het even zoeken naar een relais in de software.
Aan de andere kant van de relais zit dan de kabel die dmv het relais geschakeld moet worden.
Weerstand is 4.7K

http://zooi.oostindie.com/images/270badkamer_bb_tn.jpg

KlikAan KlikUit besturen met de Raspberry Pi

Door Koffie op donderdag 16 januari 2014 17:36 - Reacties (20)
Categorie: -, Views: 29.165

In mijn vorige post schreef ik hoe ik mijn eerste stapjes op domoticagebied zette met behulp van een Raspberry Pi.
Zoals aangegeven is de thermostaat van de muur gerukt en is het regelen van de kleppen aan de Raspberry Pi overgedragen.
Hier moest natuurlijk nog wel een stuk script voor komen en een begrijpelijke webinterface:

http://zooi.oostindie.com/images/989kachel_WI_oud_tn.jpg

Het hele verhaal was begonnen met het aansturen van KlikAan KlikUit (KaKu) door middel van een RF send en receive setje. We begonnen met de lights software uit deze blogpost, maar al snel waren we over op de software van CurlyMo : de voorloper van pilight (in een latere post hierover meer).
Nadat we de eerste hobbels overwonnen hadden was het natuurlijk fantastisch om vanaf je Raspberry Pi een lamp draadloos aan en uit te zetten :D
Vanaf dat moment was mij al direct duidelijk dat ook hier een (fatsoenlijke) webinterface noodzakelijk was wilde dit enigszins slagen bij de rest van de bewoners (lees: mijn vrouw).
De eerste versie was vooral praktisch, maar kon er mee door:

http://zooi.oostindie.com/images/364kaku_wi_tn.jpg

Tot nu toe allemaal leuk om mee te spelen, maar vooralsnog werd alles met de hand geschakeld. Het zou al een stuk mooier zijn als de verlichting vanzelf zou schakelen. Een simpele cronjob zou al genoeg moeten zijn, maar dan mag je dit elke week gaan bijstellen.
Zolang er nog geen draadloze schermdetector (LDR) was moest ik iets anders verzinnen.
Uiteindelijk heb ik besloten om gebruik te maken van sunwait. Via een cronbjob word elke dag om 15:00 sunwait opgestart, met als parameters dat deze een half uur voor zonsondergang de 2 plafondlampen van de woonkamer aan te zetten.
Op een enkele regenachtige dag werkt dit prima. Precies op het moment dat je denkt 'straks even een lichtje aanzetten' springen de lampen aan.

Als snel kwam ik tot de conclusie dat het eigenlijk echt gaat werken als je 100% terugkoppeling hebt van de status van al je lampen.
Omdat KaKu gebaseerd is op de het oude X10 protocol, zit er geen terugkoppeling in. Hier moest dus iets op verzonnen worden.
De enige manier om eigenlijk zeker te zijn van de status van je verlichting, is alles via je Raspberry Pi te laten verlopen. Klinkt leuk, maar in de praktijk niet te doen. De rest van de familie wil namelijk toch graag gebruik blijven maken van de ouderwetse schakelaars in de muur. De KaKu schakelaars kunnen alleen maar ontvangen niet zenden.
Om toch gegarandeerd te zijn van statusupdates heb ik besloten alle schakelaars die KaKu aansturen ook te voorzien van KaKu zenders zoals de AWMT-230.
Op deze manier kun je dmv een KaKu signaal een schakelaar op ON zetten en krijg je netjes een signaal wanneer de schakelaar op OFF gezet word (je hebt dan nog wel een probleem met een draadloos geschakelde lamp die je UIT wilt zetten terwijl de KaKu schakelaar in de OFF positie staat. Later hierover meer).
Er kwam nu wel een ander probleem aan het licht ( :+ ) : de RF receiver van iPrototype bleek niet in staat te zijn alle signalen in het huis op te vangen.
Inmiddels was CurlyMo overgestapt naar een nieuwe versie van zijn software : pilight met daarbij een eigen forum.
Op dit forum werd druk gediscussieerd over antennes en hoe die te bouwen, dus heb ik op dat moment besloten de uitkomsten daarvan eerst af te wachten.

De AWMT-230 zenders bleken ook heel erg handig voor andere toepassingen : hang een zender aan een bestaande schakelaar zonder dat je de code de van de KaKu zender ergens op inleerd en je hebt een simpele 'aanwezigheidsmelder' voor vertrekken waar je gegarandeerd altijd de verlichting gebruikt.
Ik heb zo'n zender in de badkamer geplaatst, zodat de Raspberry PI altijd weer wanneer er iemand in de badkamer is. De reden leg ik uit in een andere blogpost ;)

http://zooi.oostindie.com/images/4412013_12_15_11_tn.14_tn.28_tn.jpg http://zooi.oostindie.com/images/1112013_12_15_11_tn.14_tn.31_tn.jpg http://zooi.oostindie.com/images/2342013_12_15_11_tn.13_tn.47_tn.jpg

Hoe de Raspberry Pi alles veranderde

Door Koffie op woensdag 15 januari 2014 21:36 - Reacties (22)
Categorie: -, Views: 15.207

Long long time ago .. of om precies te zijn : 2-3-2013 bestelde ik een Raspberry Pi bij RS Components. Geen idee eigenlijk wat ik er precies mee ging doen, maar het was tijd om er eentje te bestellen. Het was in ieder geval niet de bedoeling om er XBMC op te draaien,daar had ik al genoeg andere apparaten voor :)

Tijdens het wachten op de levering ben ik me maar eens gaan inlezen wat je dan nog meer met dit wonderlijke apparaat allemaal kon doen. Er ging een wereld voor me open toen ik de aanwezigheid en functie van de GPIO pinnen ontdekte.
Al snel liep het hoofd over van een volledige geautomatiseerd huishouden op basis van een Raspberry Pi. Een bijzonder grote uitdaging, maar uitdagingen zijn er om genomen te worden.
De uitdaging was voor mij ongeveer net zo groot als voor iemand in een rolstoel bedenkt dat hij in de spits van het Nederlands elftal wil staan.
De enige reden waarom ik ooit een soldeerbout in handen had gehad, was om wat klodders soldeertin op 2 draadjes laten vallen om zo een stevige verbinding te maken. Weerstanden? Geen flauw benul wat die doen. Breadboard? Lekker, doe mij maar een XL met extra saus. Programmeren? Euh nou .. scripten is haalbaar :+

Ondanks deze 'tekortkomingen' werden er grootste plannen gemaakt: de Raspberry Pi zou ingezet worden als domotica controller welke alles in het huis zou aansturen, van verlichting tot kachel .. zelfs als zelfbouw alarmsysteem.
Ondertussen werd een collega ook enthousiast en zag het wel zitten om dit project samen te doen.
Niet veel later arriveerde de eerste grote doos van iPrototype vol leuke onderdelen:

Raspberry Pi Cobbler
RF Transmitter - 434MHz
RF Receiver - 434MHz
Half breadboard
Jumpwires M/M
LDR
Weerstanden assortiment
Soldeer Starter kit
Derde Hand

Vol goede moed startte wij aan ons nieuwe project. De allereerste stap die we wilde maken was het aansturen van KlikAan KlikUit (KaKu) apparaten via RF (met behulp van deze guide)
Helaas hadden we hier al direct onze eerste tegenslag te pakken. Wat we ook probeerde, niets maar dan ook niets werkte.
Op een avond hadden we een klein succesje : we konden KaKu berichten versturen vanaf de ene Raspberry Pi en konden die dan ontvangen op een andere Raspberry Pi. CONTACT!
Helaas werd het troubleshooten nu nog moeilijker. Waarom ontvangen we niets op de Raspberry Pi en KaKu terwijl er wel degelijk RF communicatie plaats vind :?
De volgende dag begon er een lampje te branden (nog niet via KaKu helaas), en bij thuiskomst bleek de brainfart te kloppen : de geleverde modules werkten op 315 Mhz ipv 433 Mhz 8)7 Foutje van de leverancier.
Na korte uitleg (en dubbelcheck dat wij wel degelijk de 433 versie hadden besteld) konden we de modules omruilen en kon het project nu echt beginnen!

Na dat succes smaakte het naar meer. Veel meer.
Bij de eerstvolgende bestelling werd er een relais besteld. Nog nooit eerder zo'n ding van dichtbij gezien, maar ik had me inmiddels aardig ingelezen.
Het relais werd aan de Raspberry Pi gekoppeld, en de 2-weg klep voor stadsverwarming werd bruut ontkoppeld van de thermostaat.
Vanaf dat moment was ik direct 'hooked'. Met een commandline opdracht via een SSH sessie je kachel aan en uit zetten, wie wilt dat nu niet?!



Uiteraard is de 2-weg klep daarna weer aan de thermostaat geknoopt, maar ik was nu echt vastberaden om de Raspberry Pi om te toveren tot domotica controller, te beginnen als thermostaat.
In de tussentijd moest er een script verzonnen worden die de klep (relais) open en dicht kon zetten op basis van gewenste temperatuur.
Ook moest er nog een manier verzonnen worden om de temperatuur in de woonkamer uit te lezen. De installateur had destijds telefoonkabel gebruikt voor de verbinding tussen de thermostaat en de 2-weg klep, genoeg aders om een DS18B20 temperatuur sensor aan te sluiten op de plek van de thermostaat.
Niet veel later is de thermostaat definitief van de muur gerukt en ging de Raspberry Pi 'live'

http://zooi.oostindie.com/images/993552899_433877713370268_tn.jpg

Inmiddels is de Raspberry Pi definitief verantwoordelijk voor het aansturen van de kachels en lampen en zijn we druk bezig met het ontwikkelen van een eigen draadloze module voor de in de woonkamer, maar meer hierover in de volgende blogposts.