joi, 17 iulie 2014

BeagleBoard - presiuni si temperaturi - senzorul BMP085

Avem un BeagleBoard si dorim sa citim presiunea atmosferica prin intermediul uni senzor de presiune barometrica BMP085. Senzorul este grozav pentru pretul sau, ofera inclusiv un senzor de temperatura (totusi limitat de la 0 la 65 de grade Celsius) si cu ajutorul sau poti inclusiv sa afli altitudinea (presiunea atmosferica variaza cu altitudinea).
Senzorul BMP085 este un senzor digital ce se conecteaza prin I2C (adica el este un dispozitiv ce are o adresa si diversi registri in care scriem si dispozitivul executa o functie sau ofera informatii localizate in alti registri (pe care ii citim)). 
Sa trecem la treaba:
-citim documentatia senzorului si aflam semnificatia pinilor, mai aflam si ca senzorul functioneaza cu niveluri logice intre 3V3 si 5V.


 

Schema modulului cu BMP085. Acolo exista un regulator de la 5Vcc la 3.3Vcc, iar liniile I2C sunt trase la 3.3Vcc. Totusi modulul si BeagleBoard se inteleg in ciuda faptului ca in manual scrie ca I2Cul de pe BeagleBoard merge la 1.8Vcc
 
-punem firele necesare la senzor (SDA, SCL, GND, Vcc)


-citim documentatia placii BeagleBoard RevC4 si aflam unde sunt pinii I2C cu care trebuie sa legam senzorul BMP085 (conectorul J3). Pe J3 conector avem 5V.
-conectorul J3 nu este fizic pe placa, deci va trebui sa il lipim acolo, am ales un conector header cu pini la 2.54mm la 90 de grade


-legam firele SDA (pin 23), SCL (pin 24), GND (pin 27 sau 28) si 5Vcc (pin 2) de la conectorul J3 de pe placa BeagleBoard.


-acum partea hardware este in buna stare, trebuie sa o folosim: trebuie instalat pachetul i2c tools:
sudo apt-get install i2c-tools
-verificam ce busuri I2C sunt disponibile pe placa - cel cu 2 e pentru expansion header (conectorul J3):
i2cdetect -l

 Rezultatul:
i2c-1   i2c             OMAP I2C adapter                        I2C adapter
i2c-2   i2c             OMAP I2C adapter                        I2C adapter
i2c-3   i2c             OMAP I2C adapter                        I2C adapter

Update pt Ubuntu 14.04:
i2c-0   i2c             OMAP I2C adapter                        I2C adapter
i2c-1   i2c             OMAP I2C adapter                        I2C adapter
i2c-2   i2c             OMAP I2C adapter                        I2C adapter


Inseamna ca I2C de pe J3 este disponibil -    i2c-2 (sau i2c-1 pt Ubuntu 14.04)
Acum scanam sa vedem ce dispozitive sunt legate pe acest bus (-y e pt a evita intrebarea Y/N) – daca apare un dispozitiv conectat de noi, il deconectam si mai cautam o data pt a fi siguri ca acela este - in cazul nostru BMP085 are adresa 0x77:

sudo i2cdetect -y -r 2

0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- 77 
(sau pt Ubuntu 14.04:  sudo i2cdetect -y -r 1)

 -pentru programare si utilizare I2C in Python, trebuie instalat pachetul python-smbus:


sudo apt-get install python-smbus

Documentatia senzorului BMP085 ofera algoritmul de citire a temperaturii cat si al presiunii atmosferice. De asemenea ofera algoritmul de calcul al inaltimii in functie de presiunea atmosferica. Astfel ca se poate incropi cod simplu in C, in Python sau se poate lua codul gata scris de altii si adapta la aplicatie:


#! /usr/bin/env python
import smbus
import time

class BMP085():

    OSS = 3

    def __init__(self, i2c, address):
        self.i2c = i2c
        self.address = address
        self.ac1 = self.readSignedWord(0xaa)
        self.ac2 = self.readSignedWord(0xac)
        self.ac3 = self.readSignedWord(0xae)
        self.ac4 = self.readWord(0xb0)
        self.ac5 = self.readWord(0xb2)
        self.ac6 = self.readWord(0xb4)
        self.b1 = self.readSignedWord(0xb6)
        self.b2 = self.readSignedWord(0xb8)
        self.mb = self.readSignedWord(0xba)
        self.mc = self.readSignedWord(0xbc)
        self.md = self.readSignedWord(0xbe)

    def readWord(self, reg):
        msb = self.i2c.read_byte_data(self.address, reg)
        lsb = self.i2c.read_byte_data(self.address, reg + 1)
        value = (msb << 8 ) + lsb
        return value

    def readSignedWord(self, reg):
        msb = self.i2c.read_byte_data(self.address, reg)
        lsb = self.i2c.read_byte_data(self.address, reg+1)
        if (msb > 127):
            msb = msb - 256
        value = (msb << 8 ) + lsb
        return value

    def readUT(self):
        self.i2c.write_byte_data(self.address, 0xf4, 0x2e)
        time.sleep(0.0045)
        ut = self.readWord(0xf6)
        return ut

    def readTemperature(self):
        ut = self.readUT()
        x1 = ((ut - self.ac6) * self.ac5) >> 15
        x2 = (self.mc << 11) / (x1 + self.md)
        self.b5 = x1 + x2
        return ((self.b5 + 8 ) >> 4) / 10.0

    def readUP(self):
        self.i2c.write_byte_data(self.address, 0xf4, 0x34 + (self.OSS << 6))
        delay = (2 + (3 << self.OSS)) / 1000.0
        time.sleep(delay)
        msb = self.i2c.read_byte_data(self.address, 0xf6)
        lsb = self.i2c.read_byte_data(self.address, 0xf7)
        xlsb = self.i2c.read_byte_data(self.address, 0xf8)
        up = (msb << 16) + (lsb << 8 ) + xlsb
        up = up >> (8 - self.OSS)
        return up



    def readPressure(self):
        up = self.readUP()
        b6 = self.b5 - 4000
       
        x1 = (self.b2 * (b6 * b6)>>12)>>11
        x2 = (self.ac2 * b6)>>11
        x3 = x1 + x2
       
        b3 = (self.ac1 * 4 + x3)<>2
       
        x1 = (self.ac3 * b6) >> 13
        x2 = (self.b1 * ((b6 * b6)>>12))>>16
        x3 = ((x1 + x2) + 2)>>2
       
        b4 = (self.ac4 * (x3 + 32768))>>15
        b7 = (up - b3) * (50000>>self.OSS)
        if (b7 < 0x80000000):
            p = (b7<<1 b4="" br="">        else:
            p = (b7/b4)<<1 br="">       
        x1 = (p>>8) * (p>>8)
        x1 = (x1 * 3038)>>16
        x2 = (-7357 * p)>>16
       
        p += (x1 + x2 + 3791)>>4
       
        return p

i2c = smbus.SMBus(2) #sau pt Ubuntu 14.04: i2c = smbus.SMBus(1)
bmp085 = BMP085(i2c, 0x77)
t = bmp085.readTemperature()
p = bmp085.readPressure()

print "Temperature: %.2f C" % t
print "Pressure: %.2f hPa" % (p / 100)


Documentatie i2c tools:


Programarea interfetei  I2C:

Ceva hardware (EEPROM si altele):

Daca folosim niveluri logice diferite, este necesar un level shifter la 3V3 la 5V (de exemplu):


marți, 15 iulie 2014

Raspberry Pi = metoda "cum sa inveti programare"

Probabil ca daca citesti aceste rinduri esti interesat de programare si de hardware / electronica. Asta e doar de bine, caci uita-te in jur: peste tot gasesti electronica, peste tot sunt dispozitive electronice care "gandesc" intr-o anumita masura, deci e bine sa sti despre ele, poti avea chiar o viata profesionala in domeniu.

Ca sa te apuci de programare e simplu, ai deja un calculator, mai pui pe el ceva gen Python (gratis / OpenSource) si esti gata de drum. Ca sa te apuci de electronica e ceva mai lung drumul, ai nevoie de rabdare, de scule (care costa bani, daca nu iti place electronica, ramai cu ele, pe cand la programare e simplu, daca mergi pe OpenSource nu costa bani, daca nu iti place, un Delete - si nu mai sunt), indeminarea si experienta se castiga in timp etc.

Daca perseverezi, ajungi sa le faci pe ambele cumva, adica programul scris de tine sa interactioneze cu mediul extern: sa trimita semnale sau sa receptioneze semnale: aprinde un bec, stie ca ai apasat un intrerupator (cele mai simple lucruri).

Chestia e ca unii, fundatia Raspberry Pi au incercat sa atraga lumea spre acest domeniu - unde programezi, mai inveti ei electronica, apoi lipesti fire, aprinzi beculete etc.

De ceva vreme a aparut conceptul de single board computer (am scris aici despre BeagleBoard) si iata ca obiectul in sine - placa electronica a devenit accesibila ca si pret. Asta in forma Raspberry Pi proiectata de membrii fundatiei RPi - o placa electronica de marimea unui card bancar, cu porturi USB, cu port de retea, cu conector HDMI full HD, cu conector de alimentare micro USB.

Aici gasiti detalii despre miscarea RaspberryPi si aici gasiti de cumparat placa (nu e o clona, scrie pe ea Made in UK, element14).

Bun, acum eu va sfatuiesc sa luati o placa "cheala", caci aveti de toate in casa astfel incat sa o puteti utiliza si mai si invatati ceva pe deasupra.

Ce aveti nevoie:
-tastatura si maus USB
-TV cu intrare S-video (mufa RCA) sau HDMI / monitor de computer cu HDMI sau intrare digitala
-conectare la retea prin cablu Ethernet (conector RJ45)
-incarcator de la celular sau tableta cu conector micro USB
-card SD de 8 GB (sau micro SD cu adaptor la SD)
-acces la Internet
-computer cu Linux (de exemplu Ubuntu) - se poate si de sub Windows, dar urmatoarele rinduri se refera la prietenia dintre o placa Raspberry Pi si un computer cu Ubuntu

Sa intelegem cum functioneaza un Single Board Computer (SBC) Raspberry Pi (RPi):
-programelele lui sunt stocate pe un card de memorie SD (exact, din ala de care ai vazut la aparatul foto), deci acel card trebuie sa il "fabrici" cumva
-la pornire, adica atunci cand conectezi cablul cu micro USB (din ala ai la incarcatorul de smart phone / tableta), RPi-ul va cauta cardul SD si daca e ce trebuie acolo, va incepe procesul de boot-are
-dupa ce boot-eaza, RPiul este numai bun de folosit

1. Creearea cardului SD pt Raspberry Pi
-se da jos imaginea dorita (eu prefer sa folosesc Rasbian, NOOBS pare simplu de utilizat, dar pe mine m-a incurcat) - de aici: http://www.raspberrypi.org/downloads/
-se copiaza imaginea pe un card SD cu comanda dd sub Linux:
*care este cardul SD: df -h
*unmount la card in vederea scrierii imaginii (sdX este numele cardului): umount /dev/sdX
*scriem imaginea data jos mai inainte: dd bs=4M if=.img> of=/dev/sdX
Detalii: aici si aici.
-comanda sync, apoi dam un eject la cardul SD
-introducem cardul SD in placa RaspberryPi
-alimentam placa

2. Pornesti placa :)

Dupa cum se vede e destul de simplu, asta au avut in vedere cei de la fundatia RPi de la bun inceput: simplitate si costuri reduse (folosesti ce ai deja acasa: card SD, incarcator micro USB, cablu de retea si internet, TV sau monitor PC).

Mai sunt de facut cateva setari care aduc optiuni utile:
-vrei sa ai acces la RPi-ul tau si din afara retelei, asa ca poti sa il setezi sa fie accesibil din internet cu inaDyn si cu cont de DynDNS de pe afraid.freedns.org (aici am descris cum se face pt SBC BeagleBoard, aici gasesti pentru RPi)
sudo apt-get install inadyn

-din cauza ca RPi foloseste un card SD ce are o viata scurta (numar limitat de scrieri), e bine sa il crutati si sa instalati ramlog - o chestie utila a carei instalare este descrisa aici (cautati in text).
sudo apt-get install rsync
sudo apt-get install lsof
wget http://www.tremende.com/ramlog/download/ramlog_2.0.0_all.deb
sudo dpkg -i ramlog_2.0.0_all.deb

-de asemenea, daca te vei conecta prin SSH la RPi si vei da o comanda de compilare ce va dura 4-5-6 ore, vei avea surpriza ca daca intrerupi conexiunea (adica opresti computerul sau tai cablul de retea) - totul se duce de ripa - asa ca e bine sa deschizi o consola cu screen bash: aici sunt detaliile.
sudo apt-get install screen
Utillizare screen
screen bash #deschidem o instanta
CTRL + A # inchidem instanta deschisa si o lasam sa lucreze in backround
screen list # vedem toate instantele deschise
screen -r #ne conectam la o instanta specificata in screen list, daca e doar una, -r e suficient
CTRL + D #oprim instanta, nu va rula in background

-e bine sa ai imaginea cardului SD la indemina: la prima pornire vei avea de setat diverse detalii / compilat chestii (care pot dura 4-5-6 ore), daca dintr-un motiv sau altul strici cardul SD (adica ajungi sa il formatezi), vei reface detalii si pierzi vremea. De asta fa o imagine la configuratia actuala cu dd (detalii aici):
sudo dd if=/dev/sdb of=/home/RaspberryPi_sd_card.bin

Cum cream un card SD din imaginea facuta anterior:
dd if=/home/RaspberryPi_sd_card.bin of=/dev/sdb

Raspberry Pi (sistemul de operare Rasbian (un fel de Linux)) are un mediu de programare grafica usor de folosit de catre copii, Scratch se numeste, poti da copilului de lucru acolo ore bune :).

Tot pentru invatare, recomand Python, Rasbian il are preinstalat si pe net sunt multe tutoriale.

Spor!

Adaugat noiembrie 2014: daca apar mesaje de eroare "perl: please check that your locale settings...", trebuie definite setarile (am observat acest lucru si la Ubuntu 14.04):
sudo locale-gen ro_RO.utf8
sudo dpkg-reconfigure locales
sudo reboot
locale
locale -a

marți, 8 iulie 2014

Pestera Ursilor, Cetatile Ponorului si Ghetarul de la Scarisoara

Peștera Urșilor, Cetațile Ponorului și Ghețarul de la Scarișoara

Cele 3 locuri mentionate mai sus sunt probabil printre atractiile majore / foarte cunoscute / foarte mediatizate din Muntii Apuseni. Iata situatia la momentul iulie 2014 (posibil ca in 3-4 ani lucrarile la drumuri sa fie finalizate si deplasarea sa fie mai rapida, mai placuta). Am pornit din Timisoara, ne-am intors in Timisoara.

Ruta spre Pestera Ursilor:
Timisoara - Arad (DN69 / E671)
Arad - Salonta (DN79 / E671)  - drum european model romanesc cu 1 banda pe sens si cu trafic de toate felurile, denivelari reduse, trece prin localitati

Salonta - Tinca - (DJ795) Intersectie cu DN76 / E79 spre Beius (faci dreapta) drum bun, acceptabil

Intersectie DJ795 cu DN76 / E79 - Beius - Sudrigiu (DN76 / E79) - drum in lucru, circulatie pe o banda, semafoare, au-au (imi aduce aminte de Timisoara - Lugoj - Recas)

Sudrigiu - Stancesti - Bradet - Chiscau (DJ763) - drum bun

Pestera Ursilor se afla la Chiscau, accesul cu masina se face pina la 5 minute de mers pe jos spre  intrarea in pestera, parcarea costa 2 lei de masina, oameni amabili care te indruma unde sa parchezi, sa iti iei haine groase ca in pestera sunt 10 grade Celsius.

Pestera Ursilor este amenajata vizitarii, nu este o pestera oarecare avand un numar impresionant de formatiuni, iar ghidul este un om foarte fain. La iesire ai tot felul de tarabe cu diverse, noi am luat o placinta excelenta cu cartofi si brinza de la o doamna din partea locului.

Dupa Pestera Ursilor, coborim putin in Chiscau si dam de Muzeul Flutur - un muzeu plin de lucruri vechi, caci asta este: un colectionar a strins in decursul vietii sale lucruri folosite de oamenii zonei. Sunt exponate care arata viata de odinioara, merita vizitat, caci reprezinta pasiunea de o viata si arata ca lucruri faine se pot face si fara gramezi de bani. Nu uitati sa lasati o mica donatie (sau sa cumparati ceva ce au de vinzare acolo), intrarea este libera, dar muzeul trebuie ajutat cumva.

Ruta spre Cetatile Ponorului:
din Chiscau facem cale intoarsa cu masina pina la drumul DJ763, unde facem la dreapta catre Pietroasa si urmam firul drumului care urca urca si tot urca (DJ763). Atentie: drumul spre Padis este asfaltat si intr-o stare excelenta (aviz celor cu biciclete de sosea, cursiere).
Dupa ce am urcat pina in golul alpin, se face la dreapta un drum nemodernizat cu un indicator: Glavoi, 4 km. Urmam acel drum si ajungem in Poiana Glavoi. Lasam masina acolo si pornim mai departe pe jos pe marcaj punct albastru (pe drumul ce duce la Cabana Cetatile Ponorului). Intram in padure si apoi ajunem la Balcoane, se vede fain in jos, apoi coborim si vedem de aproape ce am vazut de sus de la Balcoane, se aude apa cum curge prin pestera (se poate parcurge, dar nu de oricine si nu in orice moment), apoi urcam la loc ce am coborit si ajungem din nou la drumul catre Cabana Cetatile Ponorului (care e la dreapta), noi facem la stinga catre Poiana Glavoi (se poate continua pe punct albastru pina in Poiana Ponor - Poiana Rotunda). Durata traseului Glavoi - Cetatile Ponorului - Glavoi: 3,5 ore. In Poiana Glavoi am mincat clatite, foarte bune.

De deasupra, de la balcoane

Poiana Glavoi - Padis


Cum ne-am intors repede la masina, am hotarit ca nu vrem sa campam la Glavoi, deci am mers pina la capatul drumului asfaltat din Padis. Am mai zabovit acolo cat sa ne desfatam ochii cu peisajul si am pornit spre Sudrigiu (DJ763).

Ruta spre Ghetarul de la Scarisoara:
Sudrigiu - Stei (DN76 / E79) - drum in lucru, cu semafoare
Stei - Nucet - Arieseni - Girda de Sus  (DN75) - drum bun, de munte, cu serpentine, urcare

Am tras peste noapte la un loc cu istorie in spate: la mama Uța. A doua zi am pornit pe biciclete catre Ghetarul de la Scarisoara (DJ750).

Pe finalul urcarii spre Ghetarul de la Scarisoara

 Drumul spre Ghetarul de la Scarisoara (DJ750) este un drum asfaltat in stare excelenta cu urcari de 15%, cu o singura banda pe ambele sensuri, insa cu refugii suficiente pentru depasiri sau intalniri. Dupa o urcare cu 15%, ajungem in golul alpin (daca ii pot spune asa), acolo de fapt sunt casele oamenilor, oameni deosebiti care traiesc in ritmul naturii si pretuiesc ce le-a dat Dumnezeu.

Ghetarul de la Scarisoara

 Ajungem si la Ghetarul de la Scarisoara, o masa de gheata prinsa intr-un aven extrem de larg. Masa asta de gheata tine racoare, asa ca e bine sa va luati țoale cu mineca lunga daca vreti sa stati mai mult acolo sa vedeti gheata. Sunt si multe trepte de urcat, deci rabdare, veti descoperi un loc interesant. N.B.: inainte vreme, pe cand nu era frigider, oamenii "culegeau" gheata iarna, o pastrau in locuri ferite de caldura, cu paie etc, iar vara se vindea. Locul asta pastreaza gheata, si de aceea se cheama ghetar, nu este un ghetar ca cel din munti, care curge, erodeaza si face un relief specific.

Oameni fericiti

Biserica de la Ocoale

Mincam aici niste placinte cu brinza si cu afine, bem un sirop de papadie si pornim mai departe spre Ocoale, o urcare normala, drumul e betonat si in stare buna (oarecum speram sa fie un drum nemodernizat, bun pentru MTB, dar m-am bucurat sa stiu ca oamenii locului au acolo un drum bun). 

Vine ploaia?

Ne-a prins ploaia

Dupa urcusul de la Ocoale, la intersectia spre Calineasa, coborim mult si bine prin Cheile Ordincusei pina in Garda de Sus, tot pe beton.

Pe partea cealalta a dealului nu a plouat. Inca.

Casa locala

Cheile Ordincusei - a inceput sa ploua si aici

  Trecem pe la Pestera Poarta lui Ionele cu portalul sau imens, mai facem o poza, ne mai adapostim de ploaia care ne-a prin la inceputul coboririi.

Ploua torential, dar suntem deja la masina :)



Ajunsi la mama Uța, mincam un prinz copios si pornim inapoi spre casa.



Ruta spre Timisoara:
Garda de Sus - Albac - Vadu Motilor - Campeni (DN75)
Campeni - Abrud (DN74A)
Abrud - Brad (DN74)
Brad - spre Deva (DN76 / E79) - pina la intersectia cu DJ706A aici faceti dreapta spre Branisca si treceti barajul peste Mures - in felul asta ocoliti aglomeratia si ajungeti la DN7 / E68
DN7 / E68 la dreapta spre Arad - pina in Sacamas
Sacamas (la stinga pe DN68A / E673) - Faget - autostrada A1 / A6 pina la Lugoj (ca sa nu spuneti ca nu ati mers) - Lugoj - Timisora (DN6 / E70)  

Locuri faine, oameni faini, daca aveti ocazia sa faceti o vizita aici, faceti vizita ca merita.
(intrebari personale:
*de ce la noi in Banat vacile sunt asa de murdare (pe crupa au un fel de crusta de la balega)?! Vacile de aici erau curate, pieptanate parca. Dar cum spunea cineva, uita-te la oameni cum sunt ei, cum te astepti sa isi tina animalele curate?!
*de ce la noi in Banat la casa unde are loc o nunta NU se mai pune placa cu "Bine ati venit!"?! Aici inca se pune; oare nu mai e la moda sa fii primitor in Banat?! Prea multa fala desarta, prea multa...  )