zondag 31 maart 2013

I²C Real time Clock

Als je de Raspberry Pi op internet hebt staan heb je altijd de juiste tijd en datum, maar wat als je de Raspberry Pi eens voor een lange tijd niet op internet hebt staan, dan loopt je tijd niet meer goed en als je alle pech hebt ben je datum en tijd kwijt.

Om dit te voorkomen kunnen we gebruik maken van een Realtime Clock.
Dit is een ds1307 IC die de datum en tijd onthoud aan de hand van een knoop batterij van 3V.



Deze ds1307 werkt perfect op I²C want hij werkt op 5V.

Om deze op het I²C te zetten bouwen we de volgende schema op.

Alle poorten moeten we dus aansluiten behalve de SQW/OUT poort niet , deze blijft vrij.

Proef opstelling van bovenstaande.:


Eerst laden de RTC module door het volgende te typen.:
pi@raspberrypi ~ $ sudo modprobe rtc-ds1307

Als alles aangesloten is krijgt deze adres 0x68 toegewezen.
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Het onderstaande gedeelte is niet verplicht want je kunt met bovenstaande het wel laten werken via Python maar de zonder python niet , wil je het niet zonder ython laten werken dan kun je onderstaande gebruiken.
 
Type in de console het volgende.:
pi@raspberrypi ~ $ echo ds1307 0x68 > /sys/class/i2c-adapter/i2c-1/new_device

Dit doen we om de real time clock vast als adres in de I²C lijn te krijgen , als je de real time clock nu van het systeem zou verwijderen blijft het adres UU toch zichtbaar (dit is zo lang je niet opnieuw de software op je sd kaart zet).
Als je opnieuw een detectie doet ziet men dat de realtime clock is aangepast naar UU.:
pi@raspberrypi ~ $ sudo i2cdetect -y 1

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- UU -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Om te testen of iets word getoond van tijd en datum proberen we in de console het volgende.:
pi@raspberrypi ~ $ cat /sys/class/rtc/rtc0/time
00:00:00
pi@raspberrypi ~ $ cat /sys/class/rtc/rtc0/date
2000-01-01
Of controleer de tijd met sudo hwclock - r die de tijd van de DS1307 module lezen zal.
Als dit de eerste keer is dat de module gebruikt word, zal het resultaat Jan 1 2000 zijn.

Nu om de tijd in de realtime clock vast te zetten wat van de RPI afkomt (die is wel juist) typen we het volgende.:
pi@raspberrypi ~ $ sudo hwclock -w

Als we nu opnieuw tijd en datum oproepen via sudo hwclock -r zie je dat het wel goed ingesteld is.
pi@raspberrypi ~ $ cat /sys/class/rtc/rtc0/time
10:12:38
pi@raspberrypi ~ $ cat /sys/class/rtc/rtc0/date
2013-03-31

Update.:

Printje is nu klaar en werkend.

Je ziet rechts boven in nog 1 pin vrij.
Het schijnt volgens de datasheet van de ds1307 ic dat die SQW/OUT wat ik eerder vermelde vrij te houden gebruikt kan worden voor het alarm.
Dus die pin heb ik erbij gemaakt voor eventueel later te gaan gebruiken.

Als je het gedeelte zou gebruiken dat je met Python de tijd en datum zou willen uitlezen kun je deze code gebruiken.:

#!/usr/bin/python
# Raspberryboard I2C bus scan V0.1
# voor de Raspberry Pi Revision 2
#
# Author : Pascal Schuffelers
# Site   : http://www.vbib.be
# 
# Date   : 3/03/2013 tijd.: 19:57 uur.
#
# Uitlezen van Realtime Clock

import smbus

def BCD2Up( bcd ):    # Functie om de 4 hogere bits weg te halen van de byte
        return (str(bcd >> 4))

def BCD2Lo( bcd ):     # Functie om de 4 lagere bits weg te halen van de byte
        return (str(bcd & 0x0F))

bus = smbus.SMBus(1)  # bus number 1

czas = []
data = []

# Lees ruwe data van DS1307
sec = bus.read_byte_data(0x68, 0)
min = bus.read_byte_data(0x68, 1)
hour = bus.read_byte_data(0x68, 2)
day = bus.read_byte_data(0x68, 3)
date = bus.read_byte_data(0x68, 4)
month = bus.read_byte_data(0x68, 5)
year = bus.read_byte_data(0x68, 6)

# converteer naar strings
czas.append(BCD2Up(hour & 0x3F))
czas.append(BCD2Lo(hour & 0x3F))
czas.append(BCD2Up(min))
czas.append(BCD2Lo(min))
czas.append(BCD2Up(sec))
czas.append(BCD2Lo(sec))

data.append(BCD2Up(date))
data.append(BCD2Lo(date))
data.append(BCD2Up(month))
data.append(BCD2Lo(month))
data.append(BCD2Up(year))
data.append(BCD2Lo(year))

sc = czas[0] + czas[1] + ':' + czas[2] + czas[3] + ':' + czas[4] + czas[5]
sd = data[0] + data[1] + '/' + data[2] + data[3] + '/20' + data[4] + data[5]

print "Huidige tijd is: " + sc + "   " + sd

donderdag 28 maart 2013

DHT11 temperatuur en luchtvochtigheid sensor op I²C

Vervolg op dit stuk.: LINK 

Ik spreek dus over deze sensor.:
Deze sluit ik aan op de print die ik ook eerder in mijn blog heb genoemd , die dus 1 wire hardware omvormt naar I²C.


 
Word aan gewerkt.

I²C-bus en Main Unit Voedingen/Omvormers (Geupdate 03-04-2013)

Omdat ik enkele hardware prints ga maken die op 3.3V werken en het bus systeem op 5V werkt moet ik dus gaan omvormen.
Om dit voor elkaar te krijgen maak ik gebruik van een LM1085-3.3 Spanningsregelaar Positief Fixed.





Hier kan ik netjes 5V op zetten en er komt precies 3.3V uit.
De schema ziet er zo uit.:


Van het printje heb ik geen foto gemaakt want het is eigenlijk maar een printje met 2 kroonsteentjes , de LM1085 en 2 condensatortjes, rechtop rechtaan dus.

Update 30-03-2013 .:
Omdat de testvoeding voor de main unit in principe nu goed is, kan een goede voeding op print gemaakt worden, wetende wat nu het verbruik ervan is.

Om de Raspberry Pi te voeden en ook de I²C-bus ga ik gebruik maken van deze.:


Printtrafo met bevestigingsoren, 
prim:230 volt sec:12-0-12 volt (of 1x24volt), 1Amp (24VA), 
geheel ingegoten model gewikkeld op twee aparte kamers, 
afm:64x54x45mm de flappen niet meegerekend.

En om beide lcd's en overige te voeden , ga ik gebruik maken van deze.

Printtrafo 9Volt-366mA-3,2VA.
Afm: 41x35x23mm

Alleen moet ik , door pasen dit weekend, wachten ergens tot komende week eer ik die krijg geleverd.

Update 03-04-2013.

Trafo's zijn binnen en print is klaar om getest te worden.






Tevens gekozen voor alles met connectors te doen zodat uitwisselen of vervangen van de print makkelijker gaat zonder alles te moeten slopen.

 
 
Update 06-04-2013.
 
 
Tijdens het meten bleek alles normaal goed te werken, maar na alles goed aangesloten te hebben kwam ik tot de conclusie dat de blauw gekleurde trafo te min aan amperage te leveren.
 
Om te berekenen wat een trafo aan voltage en amperage leverd na gelijkrichten kun je deze formules aanhouden.:
 
 
DC spanning = 1,4 * AC spanning
DC stroom = AC Stroom / 1,4
 
Nieuwe sterkere trafo is besteld en zal maandag in bezit zijn als alles goed verloopt.



maandag 25 maart 2013

1-wire hardware op I²C-bus (Geupdate 26-03-2013).

Het I²C systeem dat ik in ons huis ga toepassen is ook wel bekend als 2-wire hardware.
Maar er bestaan ook hardware onderdelen die 1-wire zijn.

1-Wire producten bieden combinaties van geheugen, signaal, gemengd en beveiligde verificatie en functioneert via een enkele contact seriële interface. Met zowel kracht en communicatie geleverd via de serieel protocol, 1-Wire apparaten zijn ongeëvenaard in hun vermogen om belangrijke functies op systemen waar interconnectie moet worden geminimaliseerd.

Voordelen en toepassingen heb ik hieronder even geplaatst.:


Voordelen
  • Één aansluiting voldoende voor controle en werking
  • Unieke ID fabriek-Gelaserd in elk apparaat
  • Multidrop ondersteunend: ondersteunt meerdere apparaten op één lijn
  • Uitzonderlijke ESD prestaties
Typische toepassingen
  • Print Cartridge ID
  • Medical Consumable ID
  • Rek kaart kalibratie en controle
  • PCB ID en verificatie
  • Accessoire/randapparaat identificatie en controle
  • IP-bescherming, veilige functiebeheer kloon preventie


Op I²C systeem zijn deze zeer makkelijk toe te passen met een tussen hulp van speciale ic's.
Een voorbeeld van zo een ic is een DS2482-100, hier kan men 1 1-wire hardware op aansluiten.


Het aansluiten van bovenstaande ic (DS2482-100) gaat als volgt.:



Deze ic is een  I²C ic die met 1-wire hardware kan werken zonder problemen te veroorzaken.
Men kan ook bv. een DS2482-800, hier kan men 8 stuks van 1-wire hardware op aansluiten.



Het aansluiten van 1-wire op  I²C DS2482-800 met deze ic ziet er dan zo ongeveer uit.:



Ik heb namelijk om de buitentemperatuur en vochtigheid te meten een sensor ooit gekocht die ik hier nu mooi bij kan gebruiken.
DHT11 temperatuur en luchtvochtigheid sensor module


Hier word aan begonnen zodra de relai kaart hier genoemd klaar is.

(Tussen tijdse update)
De print voor de  DS2482-100 heb ik reeds ook klaar.
Word idem herkend op adres.:

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- 18 -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --

De print heb ik zo gemaakt.:




De reden is ervoor dat ik links de I²C aansluitingen heb en rechts om de adressen te selecteren en de 1wire hardware aan te sluiten, zo blijft het mooi gescheiden.

zaterdag 23 maart 2013

I²C uitgebreide relaiskaart (Geupdate 27-03-2013)

In mijn I²C bus systeem wil ik uiteraard ook 220V apparaten schakelen.
Mijn lay-out van de print ziet er als volgt uit.:


Zoals sommige van jullie misschien opvallen , zit rechts op de print boven de aansluiting van de I²C een extra aansluiting om een externe 5V adapter erop aan te sluiten (met nummer 1 gemarkeerd).
Dit is gedaan voor als de I²C bus te weinig stroom zou leveren , dat ik deze dan apart kan voeden zodat de I²C lijn niet extra belast word.
Dit kan gewoon gedaan worden met een jumpertje.
Tevens kan ik op deze kaart ook gelijk zelf kiezen welk I²C adres ik wil hebben.
Dit is gedaan door 3 jumper mogelijkheden te maken hier (met nummer 2 gemarkeerd).:




De rechter jumper op de foto is wat ik eerder vermelde voor de extra 5V aansluiting (met nummer 1 gemarkeerd).

In deze print maak ik gebruik van een MCP23017 IC die ook weer speciaal is voor het I²Csysteem.

Uiteindelijk resultaat na het maken van de print.
Door hulp van Stynus (http://www.schematheek.net/) heb ik die print kunnen afmaken want ik kwam enkele relais te kort en kwam er zelf niet maar aan, maar Stynus kon me nog enkele bezorgen (hiervoor mijn dank.)


Diverse pogingen geprobeerd om de relaiskaart herkend te krijgen ben ik erachter gekomen dat ik de verkeerde Ic's erin heb zitten.
Ik meende dat ik een MCP23017 erin geplaatst had maar na controle bleek het een MCP23S17 te zijn waardoor ik hem op deze print niet krijg gevonden.

Het verschil tussen de MCP23017 en de MCP23S17 is de pin indeling.
Zie hieronder wat het verschil is.:



Rechts de MCP23S17 heeft pin 11-12-13 en 14 anders.
Dit is normaal geen probleem, maar op die pin posities heb ik mijn relaiskaart niet gemaakt.






Dus nu moet ik even wachten dat ik die IC binnen krijg, hij is wel al besteld, dus hopelijk morgen of overmorgen binnen.



Update.:
Vandaag (26-03-2013) de juiste IC binnen gekregen.
Met als resultaat dat de relaiskaart nu wel word herkent.
Omdat op internet nergens de adressen tabel van die IC te vinden is , heb ik even een klein moment erin gestoken om het adressen tabel hier van te maken.
Van de MCP23S17 word uitgezocht als ik hem ga gebruiken maar die van de MCP23017 heb ik bij een in een Excel bestand gezet..

 Nu nog een test code schrijven voor de relaiskaart om te kunnen testen en we kunnen weer verder.

Update 27-03-2013

Even begeven aan de relaiskaart script.
Ik heb nu een werkende test script geschreven die de relaiskaart aan stuurt.
Deze loopt alle poorten na , eerst maakt deze betreffende poort hoog en dan laag.

Het test script ziet er als volgt uit.:

#!/usr/bin/python
# Raspberryboard Mainunit V0.1
#
# Author : Pascal SChuffelers
# Site   : http://www.vbib.be
#
# Date   : 27/03/2013 tijd.: 20:07 uur.
# Relay kaart test script voor aansturing aansturing

import smbus
import sys
import getopt
import time 
bus = smbus.SMBus(1)

address = 0x20 # I2C adres gekozen op de MCP23017
bus.write_byte_data(0x20,0x00,0x00) # Stel alle banken A als uitgang 
bus.write_byte_data(0x20,0x01,0x00) # Stel alle banken B als uitgang 

def set_relay(data,bank):
  if bank == 1:
   bus.write_byte_data(address,0x12,data)
  else:
   bus.write_byte_data(address,0x13,data)
  return

# Handel de commando lijn argumenten
def main():
   a = 0
delay = 0.5   
while True:

# Beweeg relay naar links  
   for x in range(0,8):
     a = 1 << x
     set_relay(a,0)
     time.sleep(delay)
   set_relay(0,0)
   for x in range(0,8):
     a = 1 << x
     set_relay(a,1)
     time.sleep(delay)
   set_relay(0,1)  
 
# Beweeg relay naar rechts 
   for x in range(7,-1,-1):
     a = 1 << x
     set_relay(a,1)
     time.sleep(delay)
   set_relay(0,1)
 
   for x in range(7,-1,-1):
     a = 1 << x
     set_relay(a,0)
     time.sleep(delay)
   set_relay(0,0)
   
  
if __name__ == "__main__":
   main()

Werking van relaiskaart.


I²C Bussysteem check script.

Op internet zijn behoorlijk veel scripts te vinden voor de Raspberry Pi en I²C samen.
Maar helaas nog nergens een script die je kunt gebruiken in je bussysteem om te scannen op aanwezige hardeware.

Men kan wel in de console bij de Raspberry Wheezy de volgende commando gebruiken.:
sudo i2cdetect -y 1
Alleen je kunt het niet in je programma gebruiken.

Omdat ik dit wel wil, heb ik dus de moeite genomen om tijd erin te steken een script te maken die dit wel kan.
Met als resultaat dat het gelukt is.
Met onderstaand Python script kan men de I²C bus wel laten scannen.
Het script toont welk busnummer een PCF8575 bevat en alles wat hierop niet reageerd maar wel is aangesloten word als overige I²C ic aangegeven.

Ik weet het word door vele niet gedaan, maar toch vraag ik het, indien men hiervan gebruik maakt neem mijn author naam mee.

#!/usr/bin/python
# Raspberryboard I2C bus scan V0.1
# voor de Raspberry Pi Revision 2
#
# Author : Pascal Schuffelers
# Site   : http://www.vbib.be
# 
# Date   : 21/03/2013 tijd.: 01:14 uur.
#
# Bussysteem scannen op hardware aanwezig


#Doe imports
import smbus
import time
import pylcdlib
import os
import random

from time import sleep
from datetime import datetime
from subprocess import *

i2c = smbus.SMBus(1)


#Signaal code voor PCF8575
#Controleer voor I/0 fouten (geen device aangesloten)
temp = 0x55AA
#Gehele I2C detection.
locations = [0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
   0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,
   0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
   0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,
   0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,
   0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
   0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77]

print "****************************************************************"
print "* Het bussysteem word gescanned op aangesloten hardware , deze *"
print "* word met een signaalcode voor de PCF8575 aangeroepen.        *"
print "* Alle gevonden hardware word getoont en alles wat een PCF8575 *"
print "* bevat word erachter vermeld, indien anders word              *"
print "* dit ook vermeld.                                             *" 
print "****************************************************************"


b = 0 
d = 0
e = 0
for device in locations:
 
 try:
  b = b + 1
  i2c.write_byte(device,temp)
  a = int(device) - 12
  devicebyte = int(i2c.read_byte(device))
  c = (b * 2.702702702702702)
  sleep(0.1)
    
  #temp = signaal code 0x55AA voor de PCF8575 word als 170 getoont.
  if devicebyte == 170:
   #print "IC PCF8575"
   d=d+1
   print 'Hardware gevonden op I2C bus met nummer.: ' + str(a) + " ,deze bevat een IC PCF8775"
  if devicebyte == 0:
   e=e+1
   print 'Hardware gevonden op I2C bus met nummer.: ' + str(a) + " ,deze bevat een andere I2C IC."
  #sleep(0.1)
  
 except:
  if device == 'end':
   print "Geen unit gevonden op "+ device
   exit()

I²C LM97 Temperatuur sensor

In I²C unit wil ik toch voor de zekerheid een temperatuurmeter hebben.
Ik heb gekozen voor een LM97 temperatuur sensor.
LET OP!!! Deze ic werkt op 3.3V !!




0,5'C / 1'C  12 bit +Sign Temperatuur Sensor, 2 wire.





Na even 4 kabeltjes als test opstelling te solderen ziet het even er zo uit.
Helaas krijg ik geen betere foto ervan gemaakt , maar het gaat om het idee. ;)
 Ik vond wel een soort gelijkenis die duidelijker is , maar niet van mij afkomstig is.


De print die ik hiervoor gemaakt heb ziet er dan in layout zo eruit.:

Het adres dat ik toegewezen krijg is.:
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --
Om dit geheel uit te lezen gebruik ik deze code.:
#!/usr/bin/python
# Raspberryboard Mainunit V0.1
#
# Author : Pascal Schuffelers
# Site   : http://www.vbib.be
# 
# Date   : 23/03/2013 tijd.: 02:44 uur.
#

import smbus

bus = smbus.SMBus(1)
address = 0x48
lm96temp = bus.read_byte_data(address, 0x00)
factor = 1.9 
lm96eindtemp = lm96temp * factor
print lm96eindtemp

De correctie factor om de juiste temperatuur te zien heb ik gemeten en komt dus uit op 1.9.
Dit heb ik gemeten met een digitale temperatuur meter die ik eens via marktplaats heb gekocht, deze word veel in de industrie gebruikt, dus de nauwkeurigheid is zeer goed.

Raspberry Hoofdunit deel 3.

Nu de lcd , cpu led bar , de knoppen klaar zijn en de benodigde extra connectors bijeen zijn kan ik geheel inbouwen.
Voor de connectors heb ik even niet op het geld gekeken, dus de beste kwaliteit die te krijgen gekocht.
De volgende connectors heb ik dus genomen.:
 



Deze connectors hebben het voordeel dat alles vrij makkelijk koppelbaar is zoals je kunt zien op de foto's.
De Raspberry Pi word op zich niet erg warm , maar extra koeling te krijgen heb ik 2 extra voorzieningen genomen.
De Raspberry word op 3 plaatsen warm die op onderstaande warmte foto te zien is.
 
De eerste voorziening is om alle warmte delen op de Raspberry Pi te voorzien van koel elementen die hier speciaal voor te krijgen zijn.




De 2de extra voorziening is een extra ventilator deze gaat aan wanneer de kast word ingeschakeld.
Deze voorziening heb ik gekozen omdat ik 2 aparte voedingen in de behuizing gebruik , 1 om de Raspberry te voeden en 1 om het overige te voeden, dus de ventilator en de panels om de I2C lijn te testen.
De panels die ik gebruik om de I2C lijnen te testen zijn deze.
 De aansluitingen zijn zo verwerkt.


De middelste foto klopt nu niet meer, de adapter stekker is dus vervangen voor een 220V stekker.
Het geheel in de front weg gewerkt ziet het er zo uit.
Hierbij zijn de volgende adressen nu vast voor deze unit.
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- 23 -- -- 26 27 -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --

De werking van de kast kunnen jullie vinden op www.vbib.be

Raspberry Hoofdunit deel 2.





In Raspberry Hoofdunit deel 1 liet ik al zien dat het lcd scherm al werkt , dus klaar is om ingebouwd te worden in de behuizing.


De volgende hardware gedeelte is de CPU indicator die de bezigheid van de cpu laat zien van de Raspberry Pi.
Om het mooi te houden heb ik niet voor losse leds gekozen maar voor 2 verschillende led bars.
1 met 3 kleuren rood en 7 kleuren groen en 1 met alleen groene leds.

Deze is wat ik dus gebruik ervoor.:





Deze 2 ledbars stuur ik met een MCP23017 IC.
 De layout ziet er zo uit.:


Ik heb gekozen op deze print om deels met smd te werken zodat het enigszins nog compact blijft.

Het resultaat is dan ook als volgt.:
Voor meer video's en foto's van dit te zien kun je deze vinden op www.vbib.be.
Werkend ziet het er dan zo uit.:
Moet wel even erbij vermelden dat de bovenste ledbar vervangen is door 1 met alleen maar groene leds voor mooier resultaat.

 

De code die ik gebruik om de CPU meter te laten werken in Python is als volgt.:

#!/usr/bin/python -tt
# Raspberryboard Mainunit V0.1
#
# Author : Pascal Schuffelers
# Site   : http://www.vbib.be
# 
# Date   : 15/03/2013 tijd.: 00:01
#
# Main unit interne vast adressen.:


import psutil as ps, smbus #make sure you have those modules!

bus = smbus.SMBus(1)

def write(*bytes):
	bus.write_byte_data(*bytes)
	
write(0x27, 0x00, 0x00)
write(0x27, 0x01, 0x00)
#global bank_a
#global bank_b

	
def led_bar(usage):
	
	bank_a = 1
	bank_b = 0
	nr_leds = int(round(usage/6.40)) #was 6.25
	
	if nr_leds <= 8 and nr_leds > 0:
		bank_a = (1< 8:
		bank_a = 255
		bank_b = (1<<(nr_leds-8))-1
	write(0x27, 0x12, bank_a)
	write(0x27, 0x13, bank_b)

def main():
	while True:
		usage = ps.cpu_percent(interval=0.1, percpu=False) #interval was 0.1
		led_bar(usage)
		
if __name__ == '__main__':
	main()

Raspberry Hoofdunit deel 1.

Het scherm dat ik in mijn hoofdunit wil gaan gebruiken is een 4*20 lcd.
Dat houd in 4 lijnen aan 20 tekens per lijn.





Om dit scherm op mijn I2C van mijn Raspberry Pi te laten werken heb ik een print gemaakt die hiermee kan communiceren.

Omdat men diverse adressen kan aanmaken bij sommige ic's probeer ik dus mijn prints zodanig te maken dat ik de adressen zelf kan kiezen d.m.v. jumpers.

In bovenstaand geval heb ik dit reeds al gedaan bij het scherm wat ik eerder heb genoemd.
Tevens heb ik gekozen om de I2Cop 5V te laten lopen omdat meerder deel van de te verkrijgen hardware hier op werkt.
Zou een stukje hardware op een lager voltage werken is dit dan ook geen probleem.

Het printje om bovenstaande lcd te laten werken ziet er als volgt uit.


Zoals je kunt zien op de layout heb ik hier gebruik van 2 PCF8574's.
Waarom 2 ? de reden hiervan is dat 1 ervan is om de lcd aan te sturen en 1 om de knop bediening.
Die van de knopbediening zit links en voor de lcd midden boven.

De adressen die mogelijk zijn te kiezen bij de PCF8574 zijn.:


Het adres dat mijn print heeft op de I2C lijn is 0x26.

Om het scherm aan te sturen maak ik gebruik van een libery pylcdlib.
Code van deze libery is.:
import smbus
from time import *

# General i2c device class so that other devices can be added easily
class i2c_device:
 def __init__(self, addr, port):
  self.addr = addr
  self.bus = smbus.SMBus(port)

 def write(self, byte):
  self.bus.write_byte(self.addr, byte)

 def read(self):
  return self.bus.read_byte(self.addr)

 def read_nbytes_data(self, data, n): # For sequential reads > 1 byte
  return self.bus.read_i2c_block_data(self.addr, data, n)


class lcd:
 #initializes objects and lcd
 '''
 Reverse Codes:
 0: lower 4 bits of expander are commands bits
 1: top 4 bits of expander are commands bits AND P0-4 P1-5 P2-6
 2: top 4 bits of expander are commands bits AND P0-6 P1-5 P2-4
 '''
 def __init__(self, addr, port, reverse=0):
  self.reverse = reverse
  self.lcd_device = i2c_device(addr, port)
  if self.reverse:
   self.lcd_device.write(0x30)
   self.lcd_strobe()
   sleep(0.0005)
   self.lcd_strobe()
   sleep(0.0005)
   self.lcd_strobe()
   sleep(0.0005)
   self.lcd_device.write(0x20)
   self.lcd_strobe()
   sleep(0.0005)
  else:
   self.lcd_device.write(0x03)
   self.lcd_strobe()
   sleep(0.0005)
   self.lcd_strobe()
   sleep(0.0005)
   self.lcd_strobe()
   sleep(0.0005)
   self.lcd_device.write(0x02)
   self.lcd_strobe()
   sleep(0.0005)

  self.lcd_write(0x28)
  self.lcd_write(0x08)
  self.lcd_write(0x01)
  self.lcd_write(0x06)
  self.lcd_write(0x0C)
  self.lcd_write(0x0F)

 # clocks EN to latch command
 def lcd_strobe(self):
  if self.reverse == 1:
   self.lcd_device.write((self.lcd_device.read() | 0x04))
   self.lcd_device.write((self.lcd_device.read() & 0xFB))
  if self.reverse == 2:
   self.lcd_device.write((self.lcd_device.read() | 0x01))
   self.lcd_device.write((self.lcd_device.read() & 0xFE))
  else:
   self.lcd_device.write((self.lcd_device.read() | 0x10))
   self.lcd_device.write((self.lcd_device.read() & 0xEF))

 # write a command to lcd
 def lcd_write(self, cmd):
  if self.reverse:
   self.lcd_device.write((cmd >> 4)<<4 data-blogger-escaped-0x0f="" data-blogger-escaped-cmd="" data-blogger-escaped-else:="" data-blogger-escaped-self.lcd_device.write="" data-blogger-escaped-self.lcd_strobe="" data-blogger-escaped-x0="">> 4))
   self.lcd_strobe()
   self.lcd_device.write((cmd & 0x0F))
   self.lcd_strobe()
   self.lcd_device.write(0x0)

 # write a character to lcd (or character rom)
 def lcd_write_char(self, charvalue):
  if self.reverse == 1:
   self.lcd_device.write((0x01 | (charvalue >> 4)<<4 data-blogger-escaped-0x0f="" data-blogger-escaped-2:="" data-blogger-escaped-charvalue="" data-blogger-escaped-if="" data-blogger-escaped-self.lcd_device.write="" data-blogger-escaped-self.lcd_strobe="" data-blogger-escaped-self.reverse="=" data-blogger-escaped-x01="" data-blogger-escaped-x04="" data-blogger-escaped-x0="">> 4)<<4 data-blogger-escaped-0x0f="" data-blogger-escaped-charvalue="" data-blogger-escaped-else:="" data-blogger-escaped-self.lcd_device.write="" data-blogger-escaped-self.lcd_strobe="" data-blogger-escaped-x04="" data-blogger-escaped-x0="" data-blogger-escaped-x40="">> 4)))
   self.lcd_strobe()
   self.lcd_device.write((0x40 | (charvalue & 0x0F)))
   self.lcd_strobe()
   self.lcd_device.write(0x0)

 # put char function
 def lcd_putc(self, char):
  self.lcd_write_char(ord(char))

 # put string function
 def lcd_puts(self, string, line):
  if line == 1:
   self.lcd_write(0x80)
  if line == 2:
   self.lcd_write(0xC0)
  if line == 3:
   self.lcd_write(0x94)
  if line == 4:
   self.lcd_write(0xD4)

  for char in string:
   self.lcd_putc(char)

 # clear lcd and set to home
 def lcd_clear(self):
  self.lcd_write(0x1)
  self.lcd_write(0x2)

 # add custom characters (0 - 7)
 def lcd_load_custon_chars(self, fontdata):
  self.lcd_device.bus.write(0x40);
  for char in fontdata:
   for line in char:
    self.lcd_write_char(line)


En het resultaat van hierboven genoemde in test opstelling is dus dat het werkt.
Om bovenstaand werkend te krijgen heb ik deze code in Python gemaakt.:
#!/usr/bin/python
# Raspberryboard Mainunit V0.1
#
# Author : Pascal Schuffelers
# Site   : http://www.vbib.be
# 
# Date   : 15/03/2013 tijd.: 00:01
#
# Main unit interne vast adressen.:
# -Display groot is adres 0x26
 
#Doe imports
import smbus
import time
import pylcdlib
import os
import random
 
from time import sleep
from datetime import datetime
from subprocess import *
 
#Ken PCF8575 adressen toe aan variabelen
i2c_addr4x20 = 0x26
i2c = smbus.SMBus(1)
 
lcd = pylcdlib.lcd(i2c_addr4x20,1)
lcd.lcd_puts("   I2C bussysteem   ",1) #toon op lijn 1
lcd.lcd_puts("       test 1       ",2) #toon op lijn 2
lcd.lcd_puts("       test 2       ",3) #toon op lijn 3
lcd.lcd_puts("       test 3       ",4) #toon op lijn 4

Voor meer video's en foto's van deze lcd's te zien kun je deze vinden op www.vbib.be.