Nowe technologie w fizyce biomedycznej/Raspberry Pi: Różnice pomiędzy wersjami
| Linia 645: | Linia 645: | ||
[[Plik:czujnik.png|600px|thumb|center|<figure id="fig:wbb"></figure>Schemat połączeń do testowania czujnika]] | [[Plik:czujnik.png|600px|thumb|center|<figure id="fig:wbb"></figure>Schemat połączeń do testowania czujnika]] | ||
| − | Podczas pracy z czujnikiem korzystać będziemy z biblioteki stworzonej przez Adafruit. Umożliwia ona komunikację z wbudowanym 8-bitowym | + | Podczas pracy z czujnikiem korzystać będziemy z biblioteki stworzonej przez Adafruit. Umożliwia ona komunikację z wbudowanym 8-bitowym mikro-kontrolerem, który wykonuje konwersję analogowo-cyfrową i przesyła dane w odpowiednim formacie. Dzięki temu sygnał wyjściowy z czujnika można przesyłać na dowolny pin GPIO. Aby pobrać odpowiednią bibliotekę należy wykonać następujące komendy: |
| + | <source lang="c"> | ||
| + | $ sudo apt-get install -y build-essential python-dev git | ||
| + | $ mkdir -p /home/pi/sources | ||
| + | $ cd /home/pi/sources | ||
| + | $ git clone https://github.com/adafruit/Adafruit_Python_DHT.git | ||
| + | $ cd Adafruit_Python_DHT | ||
| + | $ sudo python setup.py install | ||
| + | </source> | ||
| + | Po ich wykonaniu w lokalizacji <source lang="c">/home/pi/sources/Adafruit_Python_DHT/examples/</source> znajduje się przykładowy skrypt testowy <source lang="c">AdafruitDHT.py</source>, który można uruchomić z dwoma argumentami: | ||
| + | #typ czujnika ('2302') | ||
| + | #numer pinu GPIO, na który nadawany jest sygnał (4) | ||
== Halotron == | == Halotron == | ||
Wersja z 11:26, 22 mar 2017
Spis treści
- 1 Raspberry Pi
Raspberry Pi
Raspberry Pi
Raspberry Pi to mała (wymiary: 85.60 mm × 53.98 mm, przy wadze 45 gramów) platforma komputerowa stworzona przez brytyjską organizację charytatywną "Fundację Raspberry Pi" w celach edukacyjnych. Miała za zadanie ułatwić uczniom naukę programowania oraz sterowania zewnętrznymi urządzeniami.
Raspberry Pi zasilany jest napięciem 5V poprzez gniazdo microUSB. Niski pobór mocy jest jedną z przyczyn częstego wykorzystania Raspberry w robotyce. Komputer ten to w głównej mierze układ Broadcom:
- 512 MB RAMu
- procesor graficzny
- procesor taktowany zegarem 700MHz
Raspberry Pi nie posiada wbudowanego dysku twardego - korzysta z karty SD, którą wykorzystuje do załadowania systemu operacyjnego (Raspbian - specjalnie dedykowana wersja Debiana) i przechowywania danych. Do tego komputera można podłączyć urządzenia zewnętrzne poprzez łącza:
- HDMI - monitor
- ethernet - internet
- USB - klawiatura, myszka, itp.
Główną cechą Raspberry Pi jest zestaw połączeń GPIO (General Purpose Input Output), które pozwalają na wysyłanie i odbieranie sygnałów cyfrowych (z i do urządzeń zewnętrznych takich jak motorki, czujniki, diody, przełączniki itd.).
Gertboard
Gertboard jest to moduł rozszerzający możliwości komputera Raspberry Pi. Jego instrukcja obsługi znajduje się pod adresem: [1]. Płytka ta posiada m.in.:
- sterownik silnika prądu stałego
- 12 buforowanych portów wyjścia/ wejścia
- 3 przyciski typu tact-switch
- 6 wejść typu otwarty kolektor
- dwukanałowy 10 bitowy przetwornik analogowo-cyfrowy
- dwukanałowy 8, 10 lub 12 bitowy przetwornik cyfrowo-analogowy
Płytka ta podłączana jest bezpośrednio do pinów GPIO w Raspberry, skąd też pobiera zasilanie.
Aby zasilić płytkę Gertboard napięciem 3,3 V należy umieścić zworkę w pozycji pokazanej na poniższym rysunku (prawy dolny róg płytki).
Połączeń na płytce dokonywać będziemy korzystając ze zworek (małe czarne elementy 'zwierające' piny blisko siebie) oraz złączek (kabelki łączące piny leżące dalej od siebie).
Rząd pinów GPIO (oznaczonych czarną ramką) jest "łącznikiem" płytki Gaertboard z Raspberry Pi. Mamy zatem 17 pinów, które mogą spełniać funkcje wejścia lub wyjścia dla sygnału cyfrowego (w zależności od tego do czego je podłączymy). Przykładem może być podpięcie do nich buforowanych portów wejścia/wyjścia opisanych poniżej.
Buforowane porty I/O
Ramką nr 2 zaznaczono 12 portów wejścia/wyjścia (I/O), których sygnał po przejściu przez układ buforujący (ramki nr 3,4,5) można przekazać do/od Raspberry Pi poprzez połączenie odpowiadających im portów z obszaru ramki nr 1 z portami GPIO. Do każdego z portów I/O przypisana jest dioda (tuż pod portami w ramce nr 2), która wskazuje obecny stan logiczny danego portu.
Każdy z 12 portów I/O posiada swój obwód buforowy (schemat przedstawiono poniżej), który składa się z buforów przepuszczających prąd tylko w jednym kierunku, oporników, diody LED oraz miejsc łączeniowych. Jeśli połączymy obwód w miejscu 'in', sygnał będzie przekazywany tylko w kierunku od portów I/O do Raspberry Pi. Jeśli umieścimy zworkę w miejscu 'out', sygnał będzie przekazywany tylko w kierunku od Raspberry Pi do portów I/O.
Na płytce Gertboard porty wejścia/wyjścia o numerach od 1-4 mają swój obwód buforowy w chipie U3 oznaczonym ramką nr 3, porty 5-8 w chipie U4 zaznaczonym ramką nr 4, porty 9-12 w chipie U5 zaznaczonym ramką nr 5. Miejsca połączenia obwodu buforowego 'in' znajdują się w dolnej połowie chipa, natomiast miejsca połączenia obwodu buforowego 'out' w górnej połowie chipa. Poniższy obrazek prezentuje takie ustawienie zworek, dla którego porty 1,2,3 będą ustawione jako 'wyjście', natomiast porty 10,11 jako 'wejście'.
Po zapoznaniu się z powyższymi oznaczeniami studenci mają za zadanie wykonać połączenia na desce Gertboard tak aby:
- buforowany port BUF_3 był portem wyjścia, na który sygnał jest przekazywany przez port GP22
- buforowany port BUF_8 był portem wejścia, który przekazuje sygnał na port GP7
- buforowany port BUF_10 był portem wyjścia, na który sygnał jest przekazywany przez port GP10
- buforowany port BUF_11 był portem wejścia, który przekazuje sygnał na port GP25
Przyciski
Deska Gertboard posiada 3 przyciski, które są podłączone do portów B1, B2 oraz B3. Schemat obwodu elektrycznego został przedstawiony poniżej. Jak widać, podczas przyciśnięcia przycisku port wejściowy do Raspberry zostaje połączony poprzez opornik z uziemieniem, co skutkuje odczytaniem logicznej wartości zero. Aby na bieżąco kontrolować zmiany spowodowane przyciskiem, można wpiąć zworkę w pozycji 'out' co sprawi, że stan logiczny przycisku będzie odzwierciedlany przez diodę LED (konkretną dla danego przycisku). Podczas korzystania z przycisku jako wejścia nie wpinamy zworki w miejscu 'in', ponieważ bufor wejściowy będzie zakłócał działanie przycisku.
!Uwaga: przyciski można połączyć z dowolnymi portami GPIO, oprócz GP0 oraz GP1 (porty te mają dodatkowo wbudowane oporniki 1,8 kΩ)
Test przycisków. Wpinamy zworki oraz złączki w sposób przedstawiony na schemacie poniżej. Następnie uruchamiamy program 'buttons-rg.py'. Program ten będzie wyświetlał w terminalu stan trzech przycisków (gdzie 1 odpowiada wciśniętemu przyciskowi) za każdym razem gdy ulegnie on zmianie (po 19 zmianach stanów przycisków program zakończy działanie).
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM) # initialise RPi.GPIO
for i in range(23,26): # set up ports 23-25
GPIO.setup(i, GPIO.IN, pull_up_down=GPIO.PUD_UP) # as inputs pull-ups high
# (if pin is not connected - input is pulled-up high as 1)
# Print Instructions appropriate for the board
print "These are the connections for the Gertboard buttons test:"
print "GP25 in J2 --- B1 in J3"
print "GP24 in J2 --- B2 in J3"
print "GP23 in J2 --- B3 in J3"
print "Optionally, if you want the LEDs to reflect button state do the following:"
print "jumper on U3-out-B1"
print "jumper on U3-out-B2"
print "jumper on U3-out-B3"
raw_input("When ready hit enter.\n")
button_press = 0 # set intial values for variables
previous_status = ''
try:
while button_press < 20: # read inputs until 19 changes are made
status_list = [GPIO.input(25), GPIO.input(24), GPIO.input(23)]
for i in range(0,3):
if status_list[i]:
status_list[i] = "1"
else:
status_list[i] = "0"
# dump current status values in a variable
current_status = ''.join((status_list[0],status_list[1],status_list[2]))
if current_status != previous_status: # if that variable not same as last time
print current_status # print the results
previous_status = current_status # update status variable for next comparison
button_press += 1 # increment button_press counter
except KeyboardInterrupt: # trap a CTRL+C keyboard interrupt
GPIO.cleanup() # resets all GPIO ports used by this program
GPIO.cleanup() # on exit, reset all GPIO ports
Po zapoznaniu się z implementacją powyższego przykładu studenci mają za zadanie tak zmodyfikować program aby:
- po naciśnięciu jednocześnie trzech przycisków w terminalu zamiast trzech jedynek pojawiała się linia wykrzykników
- po naciśnięciu jednocześnie dwóch przycisków w terminalu zamiast dwóch jedynek i zera pojawiała się linia znaków zapytania
Diody
Aby przetestować działanie diod skorzystamy z programu 'leds_rg.py'. Najpierw łączymy odpowiednie porty tak jak pokazano na poniższym schemacie, następnie uruchamiamy program. W zależności od wybranej procedury sterowania diodami będą się one zapalać/gasić w prawo/w lewo. Studenci mają za zadanie zapoznać się z implementacją.
!Uwaga: porty GP14 i GP15 pozostają bez połączenia, ponieważ są one pierwotnie ustawione przez system operacyjny na mod UART i lepiej ich nie przestawiać na mod OUTPUT
import RPi.GPIO as GPIO
from time import sleep
if GPIO.RPI_REVISION == 1: # check Pi Revision to set port 21/27 correctly
# define ports list for Revision 1 Pi
ports = [25, 24, 23, 22, 21, 18, 17, 11, 10, 9, 8, 7]
else:
# define ports list all others
ports = [25, 24, 23, 22, 27, 18, 17, 11, 10, 9, 8, 7]
ports_rev = ports[:] # make a copy of ports list
ports_rev.reverse() # and reverse it as we need both
GPIO.setmode(GPIO.BCM) # initialise RPi.GPIO
for port_num in ports:
GPIO.setup(port_num, GPIO.OUT) # set up ports for output
def led_drive(reps, multiple, direction): # define led_function:
for i in range(reps): # (repetitions, single/multiple, direction)
for port_num in direction:
GPIO.output(port_num, 1) # switch on an led
sleep(0.11) # wait for ~0.11 seconds
if not multiple: # if we're not leaving it on
GPIO.output(port_num, 0) # switch it off again
# Print Wiring Instructions appropriate to the board
print "These are the connections for the Gertboard LEDs test:"
print "jumpers in every out location (U3-out-B1, U3-out-B2, etc)"
print "GP25 in J2 --- B1 in J3 \nGP24 in J2 --- B2 in J3"
print "GP23 in J2 --- B3 in J3 \nGP22 in J2 --- B4 in J3"
print "GP21 in J2 --- B5 in J3 \nGP18 in J2 --- B6 in J3"
print "GP17 in J2 --- B7 in J3 \nGP11 in J2 --- B8 in J3"
print "GP10 in J2 --- B9 in J3 \nGP9 in J2 --- B10 in J3"
print "GP8 in J2 --- B11 in J3 \nGP7 in J2 --- B12 in J3"
raw_input("When ready hit enter.\n")
try:
# one repetition, switching off led before next one comes on, direction: forwards
led_drive(1, 0, ports)
# one repetition, switching off led before next one comes on, direction: backwards
led_drive(1, 0, ports_rev)
# one repetition, leaving each led on, direction: forwards
led_drive(1, 1, ports)
# one repetition, leaving each led on, direction: backwards
led_drive(1, 0, ports)
except KeyboardInterrupt: # trap a CTRL+C keyboard interrupt
GPIO.cleanup() # clean up GPIO ports on CTRL+C
GPIO.cleanup() # clean up GPIO ports on normal exit
Następnie studenci mają za zadanie tak zmodyfikować program aby sterować diodami w następujący sposób:
- wszystkie diody są zgaszone
- kolejno w prawą stronę zapalają się parzyste numery diod (i gasną tuż przed zapaleniem następnej)
- kolejno w lewą stronę zapalają się nieparzyste numery diod (i gasną tuż przed zapaleniem następnej)
- kolejno w prawą stronę zapalają się parzyste numery diod (i pozostają zapalone)
- kolejno w lewą stronę zapalają się nieparzyste numery diod (i pozostają zapalone)
- wszystkie diody są zgaszone
Diody + Przyciski
Aby sprawdzić dotychczasowe zrozumienie materiału, kolejne zadanie polega na połączeniu wiedzy na temat działania przycisków oraz diod. Docelowo chcemy aby naciskanie 3 przycisku powodowało zapalanie 6 diody, puszczanie 3 przycisku powodowało gaszenie 6 diody. Każda zmiana statusu przycisku oraz diody ma być wypisana w terminalu.
Jak pamiętamy z rozdziału o przyciskach, aby sygnał z guzika był wejściem do Raspberry, nie wpinamy zworki w miejscu 'in'. Sygnał z przycisku 3 jest automatycznie przekazywany do portu B3, który z kolei został połączony z portem GP23 w Raspberry za pomocą złączki. Zatem port GP23 dostaje informację o zmianie stanu przycisku.
Następnie chcemy aby ta zmiana stanu wartości logicznej przycisku była widoczna jako zapalanie/gaszenie diody. Najprostszą sytuacją jest wyświetlanie stanu 3 przycisku na 3 diodzie (zgodnie z poprzednim rozdziałem wystarczyłoby ustawić zworkę w miejscu 'out' portu B3). Jednak sprawa się nieco komplikuje, gdy stan przycisku ma być odzwierciedlony na 6 diodzie. Trzeba zatem sygnał wyjściowy ('out' B3) przekierować na port BUF_6. Wtedy dioda 6 będzie pokazywać stan logiczny portu 6.
Jednak to jeszcze nie koniec utrudnień. Dodatkowo chcemy aby stan diody 6 był sczytywany przez Raspberry Pi. Zatem musimy wskazać, że port BUF_6 jest sygnałem wejściowym do Raspberry (zworka 'in' na B6), który zostanie przesłany na port GP22 (złączka między B6 a GP22).
Gdy schemat połączeń jest jasny można go zrealizować, a następnie uruchamić program 'butled_rg.py'.
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM) # initialise RPi.GPIO
GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_UP) # set up port 23 for INPUT pulled-up high
GPIO.setup(22, GPIO.IN) # set up port 22 for normal INPUT no pullup
print "These are the connections you must make on the Gertboard for this test:"
print "GP23 in J2 --- B3 in J3"
print "GP22 in J2 --- B6 in J3"
print "U3-out-B3 pin 1 --- BUF6 in top header"
print "jumper on U4-in-B6"
raw_input("When ready hit enter.\n")
button_press = 0 # set intial values for variables
previous_status = ''
try:
while button_press < 20: # read inputs constantly until 19 changes are made
status_list = [GPIO.input(23), GPIO.input(22)] # put input values in a list variable
for i in range(0,2):
if status_list[i]:
status_list[i] = "1"
else:
status_list[i] = "0"
current_status = ''.join((status_list[0],status_list[1])) # dump current status values in a variable
if current_status != previous_status: # if that variable not same as last time
print current_status # print the results
previous_status = current_status # update status variable for next comparison
button_press += 1 # increment button_press counter
except KeyboardInterrupt: # trap a CTRL+C keyboard interrupt
GPIO.cleanup() # resets all GPIO ports
GPIO.cleanup() # on exit, reset GPIO ports used by program
Płytka uniwersalna
Płytka uniwersalna to narzędzie ułatwiające samodzielne i szybkie tworzenie obwodów elektronicznych. Jej angielska nazwa breadboard wskazuje na historyczne korzenie tego narzędzia. Oryginalnie (lata 20-te XX wieku) były to dosłownie deski do krojenia chleba, do których amatorzy wczesnej elektroniki (np. radia) przymocowywali przewody i inne elementy elektroniczne za pomocą gwoździ. Współcześnie, jednym z rodzajów płytek uniwersalnych jest płytka stykowa, która nie wymaga przylutowywania elementów, a jedynie umieszczenia ich w odpowiednich otworach. Oznaczone linie czerwone i niebieskie, to rzędy otworów połączonych ze sobą. Dodatkowo kolumny otworów wzdłuż krótszego boku płytki również są ze sobą połączone.
Zadanie 1
Korzystając z płytki uniwersalnej należy zbudować obwód przedstawiony na schemacie. Diodę czerwoną wpinamy dłuższą nóżką w stronę +, krótszą w stronę -, natomiast opornik wybieramy o oporności 0,6 kΩ. Docelowo, dioda na płytce uniwersalnej ma być sterowana sygnałem pochodzącym z portu BUF_1 (czyli sygnałem generowanym przez Raspberry Pi podawanym na port GP25):
- dioda ma zostać zapalona na czas 5 sekund
- następnie zgaszona na 5 sekund
- na koniec ma być zapalana i wygaszana co 1 sekundę (10-cio krotnie).
Zadanie 2
Korzystając z płytki uniwersalnej należy zbudować układ przedstawiony na schemacie. Opornik dobieramy o oporności 1 kΩ. Docelowo chcemy sczytywać (i wyświetlać w terminalu) stan portu BUF_1, który to będzie regulowany poprzez zbudowany przez nas przełącznik.
Otwarty Kolektor
Do tej pory, za pomocą Raspberry Pi, sterowaliśmy zewnętrznymi "urządzeniami" takimi jak diody. W tym celu wystarczało dostępne w małym komputerze napięcie 3,3 V. Jednak aby sterować zewnętrznymi urządzeniami, które korzystają z wyższego napięcia niż dostępne w Raspberry Pi, niezbędne jest wyjście typu otwarty kolektor (schemat układu, który kryje się pod tym wyjściem został przedstawiony poniżej).
Takich układów otwartego kolektora na desce Gertboard jest 6 (od RLY1 do RLY6), znajdują się one w obszarze oznaczonym żółtą ramką i każdy z nich działa przy napięciach do 50 V i prądach do 500 mA.
Zasadniczo rola tego obwodu sprowadza się do kontroli połączenia uziemienia zewnętrznego obwodu elektrycznego z uziemieniem deski Gertboard, co pozwala na "zamknięcie" obwodu i popłynięcie prądu. Wyjście może przyjmować dwa stany:
- wysokiej impedancji (jakby do niczego nie było podłączone)
- zwarcia z masą (obwód jest "zamknięty" i płynie przez niego prąd)
Zatem aby móc decydować o włączeniu/wyłączeniu zewnętrznego urządzenia należy podłączyć dodatni biegun zasilania zewnętrznego do wejścia 'common' (czyli RPWR na desce Gertboard), ujemny biegun zasilania zewnętrznego do uziemienia deski, oraz koniec obwodu do wyjścia 'out' (np. RLY1). W ten sposób, gdy połączymy również wyjście z Raspberry np. GP4 z portem RLY1 ('Raspi'), będziemy mogli za pomocą sygnału z Raspberry decydować o tym czy przez zewnętrzny układ popłynie prąd.
Aby zapoznać się z działaniem przykładowego wyjścia typu otwarty kolektor, studenci mają za zadanie odtworzyć połączenia przedstawione na poniższym schemacie oraz zbudować zewnętrzny obwód składający się z dwóch diod (czerwonej, zielonej), opornika (o oporze 0,6 kΩ) i źródła zasilania (bateria 9V). Następnie należy zapoznać się z implementacją programu sterującego zasilaniem diod.
import RPi.GPIO as GPIO
from time import sleep
chan_num = 6 # available channel number
channel = 0 # set channel to 0 initially so
# it will ask for user input
def which_channel():
print "Which driver do you want to test?"
chan = raw_input("Type a number between 1 and %d\n" % chan_num) # User inputs channel number
while not chan.isdigit(): # Check valid user input
chan = raw_input("Try again-just numbers 1-%d !\n" % chan_num) # Make them do it again if wrong
return chan
while not 0 < chan < (chan_num + 1): # ask for a channel number
chan = int(which_channel()) # once proper answer given, carry on
print "These are the connections for the open collector test:"
print "GP4 in J2 --- RLY%d in J4" % channel
print "+ of external power source --- RPWR in J6"
print "ground of external power source --- GND (any)"
print "ground side of your circuit --- RLY%d in J%d" % (channel, channel+11)
print "+ of your circuit --- RPWR (any)"
raw_input("When ready hit enter.\n")
GPIO.setmode(GPIO.BCM) # initialise RPi.GPIO
GPIO.setup(4, GPIO.OUT) # set up port 4 for output
try:
for i in range(10): # do this 10 times
GPIO.output(4, 1) # switch port 4 on
sleep(0.4) # wait 0.4 seconds
GPIO.output(4, 0) # switch port 4 off
sleep(0.4)
except KeyboardInterrupt: # trap a CTRL+C keyboard interrupt
GPIO.cleanup() # resets all GPIO ports
GPIO.cleanup() # on finishing,reset all GPIO ports used by this program
Po wykonaniu zadania testowego należy zmodyfikować program sterujący i okablowanie tak, aby diody zapalały się 10-cio krotnie na 2 sekundy z przerwą trwającą 1 sekundę oraz sterowanie odbywało się przez wyjście RLY3.
Sterownik silnika prądu stałego
Sterownik silnika prądu stałego wbudowany w deskę Gertboard może przyjąć maksymalne napięcie 18 V i natężenie 2A. Wymaga on dwóch logicznych sygnałów wejściowych A i B (na desce są one oznaczone MOTOA i MOTOB). Zachowanie silnika w zależności od stanu logicznego sygnałów A i B zostało zobrazowane w tabeli poniżej.
O typie ruchu silnika (lub jego braku) decyduje stan logiczny sygnałów. Natomiast gdy chcemy kontrolować jego prędkość musimy kontrolować stosunek pojawiania się 1 i 0 w sygnale. W tym celu stosuje się modulację szerokości impulsów. Przykładowe sygnały logiczne z zastosowaną modulacją szerokości impulsów zostały zaprezentowane na obrazku poniżej.
Znając podstawy sterowania silniczkiem można przejść do wykonywania połączeń, których schemat został przedstawiony poniżej. Docelowo chcemy aby wysłany przez Raspberry sygnał logiczny z portu GP18 był sygnałem MOTOA, natomiast sygnał z portu GP17 był przekazany dalej jako MOTOB. Po wykonaniu połączeń należy zapoznać się ze sterującym programem komputerowym i uruchomić go.
from __future__ import print_function
import RPi.GPIO as GPIO
from time import sleep
GPIO.setmode(GPIO.BCM)
ports = [18,17] # define which ports to be pulsed (using a list)
Reps = 400 # 2000 Hz cycle time, so Reps=400 is 0.2s for each percentage ON
Hertz = 2000 # Cycle time. You can tweak this, Max 3000
Freq = (1 / float(Hertz)) - 0.0003 # run_motor loop code takes 0.0003s
for port_num in ports: # set the ports up for output
GPIO.setup(port_num, GPIO.OUT) # set up GPIO output channel
print ("setting up GPIO port:", port_num)
GPIO.output(port_num, False) # set both ports to OFF
def run_motor(Reps, pulse_width, port_num, time_period):
try: # try: except:, traps errors
for i in range(0, Reps):
GPIO.output(port_num, True) # switch port on
sleep(pulse_width) # make sure pulse stays on for correct time
GPIO.output(port_num, False) # switch port off
sleep(time_period) # time_period for port OFF defined in run_loop
except KeyboardInterrupt: # reset all ports used by this program if CTRL-C pressed
GPIO.cleanup()
def run_loop(startloop, endloop, step, port_num, printchar):
for pulse_width_percent in range(startloop, endloop, step):
print (printchar, sep='', end='')
sys.stdout.flush()
pulse_width = pulse_width_percent / float(100) * Freq # define exact pulse width
time_period = Freq - (Freq * pulse_width_percent / float(100)) # sleep period needed to get required Hz
run_motor(Reps, pulse_width, port_num, time_period)
print("") # print line break between runs
print ("\nThese are the connections for the Gertboard motor test:")
print ("GP17 in J2 --- MOTB (just above GP1)")
print ("GP18 in J2 --- MOTA (just above GP4)")
print ("+ of external power source --- MOT+ in J19")
print ("ground of external power source --- GND (any)")
print ("one wire for your motor in MOTA in J19")
print ("the other wire for your motor in MOTB in J19")
command = raw_input("When ready hit enter.\n>")
print (">>>", sep='', end='')
run_loop(5, 95, 1, 18,'+') # (startloop, endloop, step, port_num, printchar, loopnum)
run_loop(95, 5, -1, 18,'-') # if you go all the way to 100% it seems out of control at the changeover
sleep(0.2) # a slight pause before change direction stops sudden motor jerking
print ("<<<", sep='', end='')
run_loop(5, 95, 1, 17,'+')
run_loop(95, 5, -1, 17,'-')
GPIO.output(port_num, False) # Finish up: set both ports to off
GPIO.cleanup() # reset all ports used by this program
Następnie student ma za zadanie tak zmodyfikować program aby wykonywał:
- obrót silniczka o około 180 stopni w prawo
- przerwa trwająca 1 sekundę
- powtórzenie poprzednich 2 podpunktów 5 razy
- obrót silniczka o około 180 stopni w lewo
- przerwa trwająca 1 sekundę
- powtórzenie poprzednich 2 podpunktów 5 razy
Komunikacja przez SPI
SPI (ang. "Serial Peripheral Interface") to szeregowy interfejs urządzeń peryferyjnych, pozwalający na komunikację głównego mikroprocesora (ang. "Master") z przetwornikiem analogowo-cyfrowym i cyfrowo-analogowym (lub innym urządzeniem peryferyjnym, ang. "Slave"). Składa się on z 3 linii komunikacyjnych działających równocześnie:
- SCLK (ang. "Serial CLocK") - sygnał zegarowy/taktujący przesyłany od "Master" do "Slave"
- MOSI (ang. "Master Output Slave Input") - sygnał od "Master" do "Slave"
- MISO (ang. "Master Input Slave Output") - sygnał od "Slave" do "Master"
Przetworniki wbudowane w deskę Gertboard znajdują się w obszarze zaznaczonym pomarańczową ramką. Jak widać każdy z przetworników ma dostępne po dwa kanały: analogowo-cyfrowy AD0, AD1 oraz cyfrowo-analogowy DA0, DA1. Wyboru używanego przetwornika dokonuje się poprzez nadanie logicznej wartości 0 na jednym z portów: CSnA w przypadku przetwornika analogowo-cyfrowego, lub CSnB w przypadku przetwornika cyfrowo-analogowego.
Przetwornik cyfrowo-analogowy
Przetwornik cyfrowo-analogowy wbudowany w deskę Gertboard jest 8-bitowy, z maksymalnym napięciem 2,04 V. Napięcie wytworzone na wyjściu (pin DA0 lub DA1) [math]V_{out}[/math] opisane jest wzorem:
[math]V_{out}=\frac{D_{in}}{256} \cdot {2,048 V}[/math]
gdzie [math]D_{in}[/math] to liczba 8-bitowa z zakresu od 0 do 256, którą użytkownik może dowolnie wybrać w zależności od oczekiwanego rezultatu (napięcia na wyjściu). Ta liczba, wraz z innymi niezbędnymi informacjami, musi zostać przekazana do przetwornika poprzez protokół SPI w postaci 2 bajtów (2 liczb 8-bajtowych) czyli 16 bitów:
- 16-13 bit: różne informacje:
- 16: numer kanału (0 lub 1)
- 15: bez znaczenia (0)
- 14: gain (mnożnik x 1 - 0 lub mnożnik x 2 - 1)
- 13: shutdown mode (off-0, on-1 dla oszczędności energii)
- 12-5 bit: liczba [math]D_{in}[/math]
- 4-1 bit: nieznaczące zera
Zatem, chcąc uzyskać na wyjściu przykładowe napięcie [math]V_{out}[/math] 1,5 V najpierw z powyższego wzoru obliczamy liczbę [math]D_{in}[/math], która wyniesie 188. Następnie zawieramy informacje w poszczególnych bitach:
- 16-13 bit: kanał-1, bez znaczenia-0, gain-1, shutdown mode-1 ; 0011
- 12-5 bit: liczba 188 to 10111100
- 4-1 bit: 0000
których ciąg: 0011101111000000 tworzy dwie liczby 8-bitowe: 00111011 (liczba 59) 11000000 (liczba 192). Te dwie liczby podajemy przy użyciu komunikacji SPI.
Aby zapoznać się z działaniem przetwornika DA studenci mają za zadanie wykonać połączenia przedstawione na poniższym schemacie oraz zapoznać się z przykładowym programem. Do mierzenia wygenerowanego napięcia należy skorzystać z uniwersalnego multimetru.
import spidev
import subprocess
from time import sleep
def which_channel():
channel = raw_input("Which channel do you want to test? Type 0 or 1.\n") # User inputs channel number
while not channel.isdigit(): # Check valid user input
channel = raw_input("Try again - just numbers 0 or 1 please!\n") # Make them do it again if wrong
return channel
# reload spi drivers to prevent spi failures
unload_spi = subprocess.Popen('sudo rmmod spi_bcm2708', shell=True, stdout=subprocess.PIPE)
start_spi = subprocess.Popen('sudo modprobe spi_bcm2708', shell=True, stdout=subprocess.PIPE)
sleep(3)
spi = spidev.SpiDev()
spi.open(0,1) # The Gertboard DAC is on SPI channel 1 (GPIO7)
# ADC is on SPI channel 0 (GPIO8)
channel = 3 # set initial random value to force user selection
voltages = [0.0,0.5,1.02,1.36,2.04] # voltages for display
common = [0,0,0,160,240] # 2nd byte common to both channels
while not (channel == 1 or channel == 0): # channel is set by user input
channel = int(which_channel()) # continue asking until answer 0 or 1 given
if channel == 1:
num_list = [176,180,184,186,191] # 1st byte list (channel-dependent)
else:
num_list = [48,52,56,58,63] # 1st byte list (channel-dependent)
print "These are the connections for the digital to analogue test:"
print "jumper connecting GP11 to SCLK"
print "jumper connecting GP10 to MOSI"
print "jumper connecting GP9 to MISO"
print "jumper connecting GP7 to CSnB"
print "Multimeter connections (set your meter to read V DC):"
print " connect black probe to GND"
print " connect red probe to DA%d on J29" % channel
raw_input("When ready hit enter.\n")
for i in range(5):
r = spi.xfer2([num_list[i],common[i]]) #send 1st and 2nd byte through SPI
print "Your multimeter should read about %.2fV" % voltages[i]
raw_input("When ready hit enter.\n")
r = spi.xfer2([16,0]) # clear channel 0 -> set 0 V -> 1st byte 00010000 [16], 2nd byte 00000000 [0]
r = spi.xfer2([144,0]) # clear channel 1 -> set 0 V -> 1st byte 10010000 [144], 2nd byte 00000000 [0]
Następnie studenci mają za zadanie tak zmodyfikować program aby uzyskać na wyjściu napięcia: 0,44 V, 0,88 V, 1,22 V.
Przetwornik analogowo-cyfrowy
Przetwornik analogowo-cyfrowy wbudowany w deskę Gertboard jest 10-bitowy, z częstością próbkowania 72kHz. Przetwornik zwraca przez SPI 3 bajty danych [XXXX XXXX][XXXX DDDD][DDDD DDXX]. Bity od 12 do 3 tworzą 10-cio bitową liczbę z zakresu 0-1023, co odpowiada wartościom napięcia z zakresu 0-3.3 V.
Zadanie testowe będzie wymagało wykorzystania źródła zmiennego sygnału analogowego. W tym celu użyty zostanie potencjometr - regulowany dzielnik napięcia. Napięcie wyjściowe [math]U_{wy}[/math] na potencjometrze opisuje równanie:
[math]U_{wy} = \frac{U_{we}}{R+R_1} \cdot R_1[/math]
gdzie [math]U_{we}[/math] to napięcie wejściowe, R to stały opór potencjometru, natomiast [math]R_{1}[/math] to zmienny opór (regulowany pokrętłem).
W zadaniu testowym podłączamy jedną nóżkę potencjometru do zasilania z Raspbery (3,3 V), drugą do uziemienia, a trzecią jako wejście analogowe do przetwornika analogowo-cyfrowego na kanale AD0. Wykonujemy resztę połączeń niezbędnych do komunikacji przy użyciu SPI. Następnie, należy zapoznać się z programem zamieszczonym poniżej i uruchomić go.
from __future__ import print_function
from time import sleep
import subprocess
import spidev
import sys
def which_channel():
channel = raw_input("Which channel do you want to test? Type 0 or 1.\n") # User inputs channel number
while not channel.isdigit(): # Check valid user input
channel = raw_input("Try again - just numbers 0 or 1 please!\n") # Make them do it again if wrong
return channel
def get_adc(channel): # read SPI data from MCP3002 chip
if ((channel > 1) or (channel < 0)): # Only 2 channels 0 and 1 else return -1
return -1
r = spi.xfer2([1,(2+channel)<<6,0]) # these two lines are explained in more detail at the bottom
ret = ((r[1]&31) << 6) + (r[2] >> 2)
return ret
def display(char, reps, adc_value, spaces): # function handles the display of #####
print ('\r',"{0:04d}".format(adc_value), ' ', char * reps, ' ' * spaces,'\r', sep='', end='')
sys.stdout.flush()
# reload spi drivers to prevent spi failures
unload_spi = subprocess.Popen('sudo rmmod spi_bcm2708', shell=True, stdout=subprocess.PIPE)
start_spi = subprocess.Popen('sudo modprobe spi_bcm2708', shell=True, stdout=subprocess.PIPE)
sleep(3)
channel = 3 # set channel to 3 initially so it will ask for user input (must be 0 or 1)
while not (channel == 1 or channel == 0): # continue asking until answer 0 or 1 given
channel = int(which_channel()) # once proper answer given, carry on
print ("These are the connections for the analogue to digital test:")
print ("jumper connecting GP11 to SCLK")
print ("jumper connecting GP10 to MOSI")
print ("jumper connecting GP9 to MISO")
print ("jumper connecting GP8 to CSnA")
print ("Potentiometer connections:")
print (" (call 1 and 3 the ends of the resistor and 2 the wiper)")
print (" connect 3 to 3V3")
print (" connect 2 to AD%d" % channel);
print (" connect 1 to GND")
raw_input("When ready hit enter.\n")
spi = spidev.SpiDev()
spi.open(0,0) # The Gertboard ADC is on SPI channel 0 (GPIO8)
char = '#' # define the bar chart character
iterations = 0 # initial value for iteration counter
while iterations < 600:
adc_value = (get_adc(channel))
reps = adc_value / 16
spaces = 64 - reps
display(char, reps, adc_value, spaces)
sleep(0.05) # need a delay so people using ssh don't get slow response
iterations += 1 # limits length of program running to 30s [600 * 0.05]
# EXPLANATION of
# r = spi.xfer2([1,(2+channel)<<6,0])
# x << 6 (it returns x with the bits shifted to the right by 6 places)
# Send 3 bytes: [sgl/diff] [odd/sign] [MSBF]
# sgl/diff = 1; odd/sign = channel; MSBF = 0
# channel = 0 sends [0000 0001] [1000 0000] [0000 0000]
# channel = 1 sends [0000 0001] [1100 0000] [0000 0000]
# EXPLANATION of
# ret = ((r[1]&31) << 6) + (r[2] >> 2)
# spi.xfer2 returns three 8-bit bytes. We must then parse out the correct
# 10-bit byte from the 24 bits returned. The following line discards all bits but
# the 10 data bits from the center of the last 2 bytes: XXXX XXXX - XXXX DDDD - DDDD DDXX
Przetwornik analogowo-cyfrowy + Silnik
Zadanie to łączy w sobie wiedzę na temat przetwornika analogowo-cyfrowego i sterownika silnika prądu stałego. Sygnał analogowy pochodzący z potencjometru ma zostać odczytany przez Raspberry Pi, a następnie zamieniony na sygnał logiczny o odpowiedniej szerokości impulsów będący wejściem do sterownika silnika. W ten sposób, kontrolując wskazania potencjometru (za pomocą śrubokrętu) można jednocześnie sterować prędkością i kierunkiem obrotów silnika. Docelowo chcemy, aby maksymalne napięcie na potencjometrze odpowiadało maksymalnej prędkości w jednym kierunku, zerowe napięcie maksymalnej prędkości w drugim kierunku, natomiast środkowe napięcie braku ruchu silniczka. Poniżej zamieszczono schemat połączeń niezbędnych do tego zadania.
Tranzystor
Czujnik temperatury i wilgotności powietrza
Na zajęciach używać będziemy czujnika temperatury i wilgotności powietrza DHT22. Jest on zasilany napięciem 3,3-6 V. Zakres pomiarowy wynosi 0-100 % RH oraz -40 °C do +80 °C, gdzie RH to wilgotność względna wyrażana w procentach. Jest to stosunek rzeczywistej wilgoci w powietrzu do maksymalnej jej ilości, którą może utrzymać powietrze w danej temperaturze. Sygnał cyfrowy jest 8-bitowy, rozdzielczość pomiaru temperatury wynosi 0,1 °C, natomiast wilgotności powietrza ± 0,1 % RH. Jednak jego szacowana dokładność to ± 0,5 °C oraz ± 2 % RH.
Kolejne nóżki czujnika (od lewej do prawej) to:
- zasilanie
- sygnał
- nic
- uziemienie
Aby przetestować działanie czujnika, budujemy obwód elektryczny zgodnie ze schematem przedstawionym poniżej (użyty opornik 5kΩ ma spełniać funkcję pull-up).
Podczas pracy z czujnikiem korzystać będziemy z biblioteki stworzonej przez Adafruit. Umożliwia ona komunikację z wbudowanym 8-bitowym mikro-kontrolerem, który wykonuje konwersję analogowo-cyfrową i przesyła dane w odpowiednim formacie. Dzięki temu sygnał wyjściowy z czujnika można przesyłać na dowolny pin GPIO. Aby pobrać odpowiednią bibliotekę należy wykonać następujące komendy:
$ sudo apt-get install -y build-essential python-dev git
$ mkdir -p /home/pi/sources
$ cd /home/pi/sources
$ git clone https://github.com/adafruit/Adafruit_Python_DHT.git
$ cd Adafruit_Python_DHT
$ sudo python setup.py install
Po ich wykonaniu w lokalizacji
/home/pi/sources/Adafruit_Python_DHT/examples/
znajduje się przykładowy skrypt testowy
AdafruitDHT.py
, który można uruchomić z dwoma argumentami:
- typ czujnika ('2302')
- numer pinu GPIO, na który nadawany jest sygnał (4)
