Sygnały analogowe/cyfrowe. Potencjometr.

Sygnały analogowe i cyfrowe.

W świecie elektroniki powszechnie mamy do czynienia z sygnałami analogowymi i cyfrowymi. W internecie oczywiście możemy znaleźć masę informacji na ten temat. Ja tylko napiszę pokrótce, że sygnał cyfrowy przyjmuje wartość typu HIGH lub LOW, 1 lub 0, włączony lub wyłączony - czyli są 2 rodzaje wartości i nic pomiędzy nimi. Natomiast analogowe sygnały mogą przyjmować dowolną wartość w wybranym zakresie.
Przykładem (cyfrowym) jest tu np włącznik światła (który jest włączony lub wyłączony), czy np pokrętło głośności w radio (analogowy). Dobry do wyjaśnień jest również wspomniany już tu kiedyś kontroler PS3, który ma przyciski działające z sygnałem cyfrowym (wciśnięty, niewciśnięty), czy też analogową gałkę - mogącą przyjąć różne wartości.

Które są lepsze/bardziej przydatne? Oczywiście zależy od zastosowań.

Dlaczego o tym wspominam?

Do tej pory mieliśmy tu do czynienia z elementami cyfrowymi. I było to stosunkowo proste. Raspberry Pi samodzielnie nie potrafi jednak w żaden sposób "zrozumieć" sygnałów analogowych.  A co - jeśli będziemy chcieli (musieli) wykorzystać "coś" analogowego? (a nie chcemy korzystać np. z Arduino)

Wtedy przyda się nam dekoder analogowo - cyfrowy i właśnie tym się zajmiemy w tym poście.

Ja zakupiłem model PCF8591P. Koszt to niecałe 12zł.

Dane techniczne.

PCF8591P - Przetwornik A/C i C/A 8-bit DIP16

•  Zasilanie: 2.5V - 6V
•  Interfejs: I2C
•  Obudowa: DIP16

Dokładniejsza dokumentacja TUTAJ

Opis slotów:

Przetwornik jest 8-bitowy, więc maksymalna wartość to 255. 

Zakupiłem też potencjometr obrotowy, który jest dobrym generatorem sygnałów analogowych :) Wraz z nakładką kosztował niecałe 2 zł. 

Dane techniczne.

Potencjometr obrotowy 10K:

• Długość osi: 15mm
• Średnica osi: 6mm
• Kąt obrotu: 300°
• charakterystyka: liniowa
• tolerancja: +/- 20%
• moc: 0,125W
• temp. pracy: -10°C ÷ +70°C

Układ

potencjometr:

środkowy pin to OUT - czyli podłączamy do dekodera (tu mała uwaga - niektóre potencjometry mają dwie nóżki po jednej stronie i jedną nóżkę po drugiej stronie - wtedy "samotna" to OUT)

lewy pin do GND

prawy pin do 5V

dekoder:

AIN1 - analog input 1 - tu podłączamy środkowy pin potencjometru

AIN2 , 3, 4 - możemy podłączyć inne analogowe urządzenia - teraz nieużywane, więc do GND

A0-A2 - hardware address - też GND

VSS - negative supply - czyli też GND

Vdd - +5V

Aout - nie używany (nie podłączamy nigdzie)

Vref - + 5V

Agnd - analog ground - oczywiście GND

EXT - GND

OSC - nie używany (nie podłączamy nigdzie)

SCL - clock line - pin 5 w RPI GPIO 1 (I2C SCL)

SDA - data line - pin 3 w RPI GPIO 0 (I2C SDA)

Następnie musimy załadować odpowiednie moduły. W standardzie Raspbiana potrzebne nam moduły są "banowane", czyli nie można ich załadować. Tak więc edytujemy plik:

/etc/modprobe.d/raspi-blacklist.conf

i hashujemy:

#blacklist spi-bcm2708
#blacklist i2c-bcm2708

Następnie ładujemy moduły:

sudo modprobe spi-bcm2708
sudo modprobe i2c-bcm2708
sudo modprobe i2c-dev

W dmesg powinno pojawić się coś w tym stylu:

[270822.607823] bcm2708_spi bcm2708_spi.0: SPI Controller at 0x20204000 (irq 80)
[270828.657896] bcm2708_i2c bcm2708_i2c.0: BSC0 Controller at 0x20205000 (irq 79) (baudrate 100k)
[270828.658130] bcm2708_i2c bcm2708_i2c.1: BSC1 Controller at 0x20804000 (irq 79) (baudrate 100k)
[270875.242767] i2c /dev entries driver

Powinny pojawić się też 2 nowe urządzenia:

crw------- 1 root root 89, 0 Jan 14 23:32 /dev/i2c-0
crw------- 1 root root 89, 1 Jan 14 23:32 /dev/i2c-1

Kolejnym krokiem jest instalacja pakietów:

apt-get install python-smbus i2c-tools

I możemy przetestować czy wszystko jest w porządku. Sprawdzanie wykrycia urządzenia:

# i2cdetect -y 1
     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: -- -- -- -- -- -- -- --

czy też sprawdzenie aktualnej wartości (na potencjometrze)

# i2cget -y 1 0x48
0x4c

Kod

Tu skorzystałem z zasobów forum LINK i pracy Grumpy Mike-a. Pozdrowienia :) Jako że dekoder pracuje przez interfejs i2c - kod wygląda nieco inaczej niż w poprzednich przypadkach.

#Read a value from analogue input 0
#in A/D in the PCF8591P @ address 0x48
from smbus import SMBus
import time

bus = SMBus(1)

print("Read the A/D")
print("Ctrl C to stop")
bus.write_byte(0x48, 0) # set control register to read channel 0
last_reading =-1

while(0 == 0): # do forever
   reading = bus.read_byte(0x48) # read A/D
   
   if(abs(last_reading - reading) > 2):
      print(last_reading - reading)
      last_reading = reading

Czujnik odległości

Kolejnym moim testem jest ultradźwiękowy czujnik odległości - model HC - SR04.

Dane techniczne:

• Zasilanie: DC 5 V
• Częstotliwość: 40Hz
• Max zasięg: 4m
• Min zasięg: 2cm
• Kąt działania: 15º 
• Wymiary: 45*20*15mm
• Waga: 90 gr

Dokumentacja TUTAJ, koszt takiego urządzenia to około 3 euro. Jak być może widać na rysunku czujnik posiada 4 piny: 5V, OUTPUT, TRIGGER, GND.

Sposób działania:

W stanie nieaktywnym na pinie OUTPUT jest zawsze 0V. Żeby aktywować czujnik (czyli, żeby wygenerowany został impuls ultradźwiękowy - a dokładniej 8 takich impulsów) wysyłany jest sygnał (co najmniej 10us) na port TRIGGER. Na porcie OUTPUT pojawia się wtedy stan wysoki (+5V) i pozostaje on w tym stanie dopóki sygnał ultradźwiękowy nie powróci do czujnika (czyli po odbiciu się od badanego obiektu). Żeby wyznaczyć odległość musimy zmierzyć ten czas, wziąść pod uwagę prędkość dźwięku i podzielić na 2 (bo droga jest do obiektu i z powrotem).
Tu niestety należy zwrócić uwagę na spore ograniczenie tego zestawu - czyli dużą niedokładność mierzenia czasu na RPI/Linuxie... Tak naprawdę powinniśmy zastosować dodatkowy hardware (albo wykorzystać np. Arduino), zapewniający nam dokładniejsze wyliczenia czasu. Dla zainteresowanych szczegółami proponuje poszukać zagadnienia "non realtime os".

OSTRZEŻENIE !

Przy podłączaniu wszelkich kabelków należy zachować ostrożność, gdyż może zakończyć się to uszkodzeniem sprzętu lub uszczerbkiem na zdrowiu. Robisz to na własną odpowiedzialność.

Układ:

Od razu zaznaczę, że tym razem znalazłem gotowe rozwiązanie i niezbyt wysilałem się intelektualnie. Za układ i kod możemy podziękować autorowi tej strony:

http://www.raspberrypi-spy.co.uk/2012/12/ultrasonic-distance-measurement-using-python-part-1/

Jak możemy wyczytać na powyższej stronce - problemem tego czujnika (w przypadku współpracy z Malinką) jest fakt, że pracuje z napięciem 5V. Jak już wiemy (np. STĄD) porty GPIO mogą pracować z napięciem 3.3V, więc musimy wykorzystać prostą sztuczkę z rezystorami.

tak więc układ:

+5V - pin 2 w RPI
GND -  pin 6 w RPI
Trigger - GPIO 23
Echo - rezystor 330 Ω (lub 1K) -> GPIO 24 -> rezystor 470 Ω (lub 1K5) -> GND

Źródło: raspberrypi-spy.co.uk

wartości rezystorów mogą być oczywiście inne - tak jak zaleca autor - muszą spełniać zależność :

R1 < R2 < 2*R1

Przydałoby się jednak kupić kolorowe kabelki ;)

Kod:

kod wrzucam również w oryginale (szacunek dla autora), mimo, że ja go nieco zmodyfikowałem (np. wrzuciłem pętle, żeby odległość sprawdzana była co parę sekund - w ten sposób wygodniej mi było testować ;) ).

#!/usr/bin/python
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#|R|a|s|p|b|e|r|r|y|P|i|-|S|p|y|.|c|o|.|u|k|
#+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
#
# ultrasonic_1.py
# Measure distance using an ultrasonic module
#
# Author : Matt Hawkins
# Date   : 09/01/2013

# Import required Python libraries
import time
import RPi.GPIO as GPIO

# Use BCM GPIO references
# instead of physical pin numbers
GPIO.setmode(GPIO.BCM)

# Define GPIO to use on Pi
GPIO_TRIGGER = 23
GPIO_ECHO = 24

print "Ultrasonic Measurement"

# Set pins as output and input
GPIO.setup(GPIO_TRIGGER,GPIO.OUT)  # Trigger
GPIO.setup(GPIO_ECHO,GPIO.IN)      # Echo

# Set trigger to False (Low)
GPIO.output(GPIO_TRIGGER, False)

# Allow module to settle
time.sleep(0.5)

# Send 10us pulse to trigger
GPIO.output(GPIO_TRIGGER, True)
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER, False)
start = time.time()

while GPIO.input(GPIO_ECHO)==0:
  start = time.time()

while GPIO.input(GPIO_ECHO)==1:
  stop = time.time()

# Calculate pulse length
elapsed = stop-start

# Distance pulse travelled in that time is time
# multiplied by the speed of sound (cm/s)
distance = elapsed * 34300

# That was the distance there and back so halve the value
distance = distance / 2

print "Distance : %.1f" % distance

# Reset GPIO settings
GPIO.cleanup()

A to mój profesjonalny zestaw do badań skuteczności czujnika ;) czyli pusta przestrzeń, miarka oraz ciemny przedmiot z prostym kształtem. 

Wg moich badań precyzja jest naprawdę dobra. Powtarzalność wyników jest bardzo dobra (nie skacze np o parę centymetrów), dokładność również całkiem niezła. Dla prostych zastosowań zdecydowanie wystarczająca.  

Zbadałem też układ z innymi przedmiotami i wyniki również są obiecujące. Ultradźwięk to jednak dobra opcja.

Podsumowując, mimo swoich ograniczeń czujnik + RPI to ciekawy zestaw. Jeśli w naszym projekcie niezbędna jest duża precyzja to zapewne warto poszukać innego rozwiązania, jeśli możemy przymknąć na to nieco oko - zdecydowanie polecam.

To już chyba mój ostatni czujnik na tą chwilę. Pora się zabrać za jakiś konkretny projekt. Mam pomysł (mam nadzieję, że starczy mi chęci i umiejętności) - ale do jego realizacji jeszcze dłuuuuga droga. W międzyczasie będę starał się wrzucać kolejne posty dotyczące RPI.    

Tunelowanie ssh

Ten post znów nie jest związany z Raspberry, traktuję to raczej jako notatkę.

Miałem ostatnio potrzebę zalogowania się do domowego routera z zewnątrz (z internetu). Ze względów bezpieczeństwa zablokowałem taką możliwość na routerze (możliwy jest dostęp tylko z sieci wewnętrznej).
Co więc mogę zrobić? 

Jak już wspomniałem TUTAJ mam możliwość dostania się bezpośrednio do mojej Malinki w sieci domowej. Tak więc postanowiłem wykorzystać tunel ssh, żeby udostępnić sobie (szyfrowany) dostęp do domowego routera. 

Wykonujemy więc prostą komendę:

ssh -L 9999:192.168.1.1:80 pi@mojhost.no-ip.org

gdzie:

9999 - to dowolny port, który będziemy używać lokalnie (czyli na komputerze w sieci zewnętrznej)

192.168.1.1 - czyli adres routera domowego (widziany z sieci domowej)

80 - port na którym nasłuchuje router (może być 80, może być 443)

mojhost.no-ip.org - czyli publiczny adres naszego hosta, zamiast nazwy może być po prostu publiczny adres IP

Pozostaje nam wpisać w przeglądarce:

http://localhost:9999

i dostaliśmy się do domowego routera.

Przy okazji tylko wspomnę, że możemy ssh wykorzystać również jako proxy. Czyli łącząc się w ten sposób:

ssh ZDALNY_KOMPUTER -D 8080

mamy lokalne proxy na porcie 8080, które przedstawi nas w świecie IP z adresem publicznym naszego ZDALNEGO_KOMPUTERA zamiast z naszym. 

Czyli np ustawiamy w naszej ulubionej przeglądarce internetowej proxy na localhost:8080 w polu SOCKS Host i działa :)

Detektor ruchu/PIR

Następny na mojej liście testów jest detektor ruchu PIR (czyli Passive Infra-Red sensor).

Zakupiłem model  HC-SR501, kosztował niecałe 4euro.

Dane techniczne:

• Zasięg: 3 - 7 m
• Kąt: 110º
• Napięcie wyjścia: 3.3V
• Temperatura działania: -20℃ - +50℃
• Wymiary: 32*24 mm

Po wykryciu ruchu sensor podaje 3,3 V (idealnie dla RPI) na wyjściu. 
Posiada 2 potencjometry: SENSITIVE i TIME oraz jeden jumper.
TIME - czas "podawania" napięcia na wyjściu - definiowalny od 3 do 18 sekund.
SENSITIVE - dystans, na którym czujnik ma wykrywać ruch (3-7metrów)
JUMPER - stan H - po wykryciu ruchu działanie czujnika jest wstrzymane (na czas zdefiniowany przez TIME)
JUMPER - stan L - czujnik działa cały czas

OSTRZEŻENIE !

Przy podłączaniu wszelkich kabelków należy zachować ostrożność, gdyż może zakończyć się to uszkodzeniem sprzętu lub uszczerbkiem na zdrowiu. Robisz to na własną odpowiedzialność.

Układ:

pin 5V - do portu 2 w RPI
pin OUT - do GPIO 23 w RPI
pin GND - wiadomo
(podłączyłem to kabelkami męsko - żeńskimi, gdyż nie ma zbytnio opcji wpięcia bezpośrednio do płytki stykowej)
no i dodałem jeszcze diodę - podłączoną tak samo jak TUTAJ

Po podłączeniu napisałem prosty skrypt - który przy wykryciu napięcia na porcie OUT zapali diodę.

import RPi.GPIO as GPIO
 
PIR = 23
LED = 14
 
GPIO.setmode(GPIO.BCM)
GPIO.setup(PIR, GPIO.IN)
GPIO.setup(LED, GPIO.OUT)
 
while True:
    if GPIO.input(PIR):
        GPIO.output(LED, True)          
    else:
        GPIO.output(LED, False)         

no i działa.

Przemyślenia. 

Po testach stwierdzam, że czujnik jest dość precyzyjny, jego czas reakcji jest bardzo szybki, tylko nie do końca podoba mi się fakt, że minimalny czas podawania napięcia po wykryciu ruchu jest tak długi (3 sekundy - choć i tak dobrze, że jest sterowany), no ale można to było wyczytać w dokumentacji ;)

Zastosowanie.

Naprawdę przeróżne. Można stworzyć nawet automatycznie otwierane drzwi, czy system wykrywania obecności domowników + zapalanie światła albo np dla miłośników przyrody - system wykrywania obecności ptaków w karmniku + zrobienie zdjęcia przez kamerkę :)

Jako ciekawostkę wrzucam tu filmik dotyczący detekcji ruchu - żebyśmy bli przygotowani na różne możliwości;) (nie do końca ma to związek z "naszym" rodzajem detektora ruchu ale ten program zawsze warto obejrzeć ;) )

Odbiornik podczerwieni/LIRC

Kolejnym moim testem jest podłączenie odbiornika podczerwieni.

Zakupiłem odbiornik IR typu TSOP4838.

Źródło: vishay.com

Nie mam dokładnej dokumentacji, ale z tego co wyczytałem pracuje na częstotliwości 38kHz, ma duży zasięg (niby do 35m), odbiór sygnału pod kątem do 45° i co najważniejsze dobrze pracuje na 3.3V. Można go dostać dość łatwo, mnie kosztował ~3 zł. 

UPDATE: dokumentacja TUTAJ

OSTRZEŻENIE !

Przy podłączaniu wszelkich kabelków należy zachować ostrożność, gdyż może zakończyć się to uszkodzeniem sprzętu lub uszczerbkiem na zdrowiu. Robisz to na własną odpowiedzialność.

UKŁAD

Podłączenie jest banalne, pierwszy pin do GPIO18 (6 z prawej), drugi pin to GND, trzeci pin to 3.3V.  

Instalujemy:

apt-get install lirc

Ładujemy moduł:

modprobe lirc_rpi

w syslogu powinno pojawić się

Dec 31 16:29:04 raspberrypi kernel: [11871.816457] lirc_rpi: auto-detected active low receiver on GPIO pin 18

powinno pojawić się też urzadzenie

# ls -la /dev/lirc0
crw-rw---T 1 root video 250, 0 Dec 31 16:29 /dev/lirc0

następnie

mode2 -d /dev/lirc0

bierzemy pilota (dowolnego - może być od telewizora) i każde wciśnięcie klawisza powinno generować komunikaty pulse space z numerkami...

Coś w tym stylu:

space 17826
pulse 129
space 803
pulse 174
space 790
pulse 100
space 18114
pulse 183
space 806
pulse 205
space 775
pulse 157
space 18484
pulse 222
space 1516

Są to "kody", które odpowiadają wciśnięciu poszczególnych klawiszy. Zamysł jest więc taki, żeby wychwycić taki kod i po jego wystąpieniu wywołać konkretne zdarzenie.

Skorzystamy więc z demona lirc.
LIRC to bardzo ciekawy projekt. Wiele mówiący skrót  Linux Infrared remote control. Polecam poczytanie dokumentacji i możliwości.
Projekt oferuje masę gotowych konfigów - lista supportowanych pilotów:
http://lirc.sourceforge.net/remotes/

Ja gdzieś wygrzebałem bardzo stary pilot, więc wygeneruję sobie plik konfiguracyjny sam.
Najpierw przyda się znajomość dostępnych nazw poszczególnych klawiszy.

irrecord --list-namespace

następnie odpalamy (tu zmiana (lircd.conf) dzięki komentarzom - dzięki:) )

irrecord -d /dev/lirc0 ~/lircd.conf

czyli generator konfiguracji. Każe nam powciskać różne klawisze, po czym mamy gotowy plik z kodami raw dla każdego klawisza pilota.
np dla klawisza 1 w moim pilocie raw_code wygląda tak:

          
name KEY_1

             9096    4465     621     515     619     520

              601     512     625     519     585     546

              600     517     620     517     616     521

              598     516     625    1649     600    1662

              610    1632     623    1653     599    1655

              616    1634     631    1646     597     517

              625     512     595    1659     620     517

              617     521     597     520     627     510

              616     522     594    1655     595    1658

              619     520     616    1633     632    1644

              599    1654     618    1636     620    1654

              600

Kopiujemy wygenerowany plik do /etc/lirc. Następnie musimy przygotować kolejny plik:

# cat /etc/lirc/hardware.conf

# Arguments which will be used when launching lircd
LIRCD_ARGS="--uinput"

#Don't start lircmd even if there seems to be a good config file
#START_LIRCMD=false

#Don't start irexec, even if a good config file seems to exist.
#START_IREXEC=false

#Try to load appropriate kernel modules
LOAD_MODULES=true

# Run "lircd --driver=help" for a list of supported drivers.
DRIVER="default"

# usually /dev/lirc0 is the correct setting for systems using udev
DEVICE="/dev/lirc0"
MODULES="lirc_rpi"

# Default configuration files for your hardware if any
LIRCD_CONF=""
LIRCMD_CONF=""

i możemy wystartować demon

/etc/init.d/lirc start

Weryfikujemy działanie przez komendę:

irw

przy wciśnięciu każdego zdefiniowanego klawisza powinna pojawić się jego nazwa:

0000000000000001 00 KEY_1 pilotMOJ
0000000000000002 00 KEY_2 pilotMOJ
0000000000000003 00 KEY_3 pilotMOJ
000000000000000b 00 KEY_OK pilotMOJ

Tak więc teraz możemy zmapować przycisk do dowolnej komendy. Tworzymy w katalogu domowym plik .lircrc i umieszczamy w nim definicję:

# cat ~/.lircrc
begin
 prog = irexec
 button = KEY_1
 config = echo "Klawisz '1' wcisniety!"
end

uruchamiamy 

irexec

i wciskamy na pilocie przycisk 1, powinno się pojawić

Klawisz '1' wcisniety!

Inna opcja. Tworzymy skrypt, upewniamy się, że jest uruchamialny lub korzystamy z już utworzonego. Ja np po wciśnięciu OK chce mieć wyświetloną temperaturę na dworzu. Korzystam ze skryptu opisanego TUTAJ i dodaję:

begin
 prog = irexec
 button = KEY_OK
 config = echo "Temperatura w tym momencie:"; /projekty/temperatura/getTemp.sh
end

Możemy uruchomić irexec jako demon poprzez:

irexec -d

i aplikacja będzie działać na stałe w tle.

Dokumentacja z parametrami TUTAJ
Warto zwrócić uwagę na parametr repeat - czyli co się stanie jeśli drugi raz wciśniemy dany przycisk. Nieraz nie chcemy przecież, żeby dana aplikacja odpaliła się raz jeszcze, ale np chcemy żeby okno zrobiło się aktywne (np. wyskoczyło okno wcześniej zminimalizowane). Ogólnie jest to dość potężny projekt, więc da się z nim dużo zrobić.

No to teraz ogranicza nas już tylko wyobraźnia. Możemy podpiąć dowolną aplikację pod dowolny przycisk w pilocie i sterować różnymi zdarzeniami (np. uruchomienie XBMC, przeglądarki, wyłączenie systemu, zapalenie diody itp).

Jeszcze tylko dodam, że istnieje projekt umożliwiający współpracę z python-em. Więcej szczegółów http://pylirc.mccabe.nu/

Jest nawet w repozytorium Raspbian-a, więc można go zainstalować:

apt-get install python-pylirc

Inne zastosowanie. 

Np jeśli mamy problemy z libcec, a chcemy korzystać z pilota w XBMC (wspomniane TUTAJ), możemy podpiąć odbiornik i korzystać z dobrodziejstw pilota (jako, że sposób podłączenia jest banalny możemy to zrobić nawet bez płytki stykowej). Oczywiście nie musimy ograniczać się do XBMC - możemy wykorzystać pilota do innych aplikacji. Masa aplikacji multimedialnych ma gotowe konfigi dla pilotów.

Poza tym możemy podpiąć się do wielu domowych urządzeń (np. lampka nocna), czy całe systemy "home automation" i sterować nimi za pomocą zwykłego pilota. Tu prawie nie ma ograniczeń (aczkolwiek zazwyczaj przydaje się już nieco bardziej zaawansowana wiedza z zakresu elektroniki).

VNC server

Dziś znów na szybko.
VNC server, czyli jak się dostać do środowiska graficznego Malinki, gdy nie mamy podpiętego monitora lub gdy nie siedzimy bezpośrednio obok. Skorzystamy z TightVNC

Źródło: tightvnc.com

Instalacja:

sudo apt-get install tightvncserver

Następnie odpalamy:

tightvncserver

gdzie ustawiamy hasło

Po czym możemy już odpalić aplikację, np:

vncserver :0 -geometry 1024x768 -depth 24

żeby ją zatrzymać odpalamy:

vncserver -kill :0

I to tak naprawdę wszystko :D

Żeby się podłączyć zdalnie - uruchamiamy (z Linuxa) komendę z IP Malinki:

vncviewer 192.168.1.10:1

lub instalujemy jakiegoś klienta na windowsie i też łączymy się do w ten sam sposób (IP:1)

Żeby VNC odpalał się przy każdym starcie wrzucamy do /etc/rc.local lub tworzymy oddzielny serwis.

UPDATE.
Tylko dodam jedną, ale istotną rzecz. Jeśli korzystamy z vncviewer prędzej, czy później będziemy musieli wykorzystać sudo. No i w standardzie wyskoczą nam błędy. Najprostszym sposobem jest wtedy użycie komendy:

gksudo

i od tej pory będziemy mogli korzystać z aplikacji wymagających uprawnień root-a.

serwer poczty/relayhost gmail

Dziś na szybko. 

Od czasu do czasu brakuje mi możliwości szybkiego sprawdzenia statusu na Malince. Najprostszym sposobem jest wysłanie sobie emaila z wynikiem komendy itp. Tak więc postanowiłem zainstalować serwer poczty. Jednakże, należy pamiętać, że - przez wojnę ze spamem - u większości dostawców internetu nie da się takiego maila przesłać "w świat". Także postanowiłem skonfigurować postfix, w ten sposób aby maile wychodziły przez serwer gmail.

 

Instalacja/konfiguracja jest prosta:

Instalujemy pakiet:

apt-get install postfix

zostawiamy standardowe ustawienia i dodajemy

smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options = noanonymous
smtp_tls_security_level = secure
smtp_tls_mandatory_protocols = TLSv1
smtp_tls_mandatory_ciphers = high
smtp_tls_secure_cert_match = nexthop
smtp_tls_CAfile = /etc/ssl/certs/ca-certificates.crt
relayhost = smtp.gmail.com:587

następnie tworzymy plik /etc/postfix/sasl_passwd, gdzie wpisujemy swojego usera i hasło

smtp.gmail.com    login_gmail:hasło_gmail

żeby nie używać haseł w czystym tekście uruchamiamy:

postmap hash:/etc/postfix/sasl_passwd

utworzony zostanie plik /etc/postfix/sasl_passwd.db

plik /etc/postfix/sasl_passwd możemy już usunąć

startujemy postfix i gotowe !

Szybki test.

Instalujemy:

apt-get install mailutils 

wysyłamy maila:

 echo "Treść maila testowego" | mail -s "Temat maila" moj_adres@gmail.com

Sprawdzamy skrzynkę na gmailu.

Działa! :)

UPDATE
Żeby zmniejszyć ilość logów dorzuciłem jeszcze do main.cf

inet_protocols = ipv4

gdyż w syslog nieraz widać było komunikaty typu:

Jan  9 18:42:39 raspbian postfix/pickup[20553]: warning: inet_protocols: disabling IPv6 name/address support: Address family not supported by protocol

Backupy na RPI

Jest takie powiedzenie

"Prawdziwi twardziele nie robią backupów"

ja wolę twardzielem nie być i backup to jednak przydatna rzecz. 

Źródło: memegenerator.net

Jako, że na moim RPI coraz więcej kodu i to nie tylko ściąganego z internetu, lecz także "autorskiego" postanowiłem zająć się tym tematem. 

Moje założenia:

* darmowa przestrzeń w internecie 

* niezbyt skomplikowany sposób uploadu

* możliwość korzystania pod Raspbian
* małe zużycie zasobów

Wybór padł na Dropbox, który standardowo udostępnia 2GB, a jak się postaramy (niektóre kroki są naprawdę łatwe) nawet 18GB. Poza tym ma całkiem ciekawe możliwości.

Źródło: dropbox.com

Mi 2GB zupełnie wystarczą, jako że chcę backupować jedynie pliki tekstowe (skrypty, konfiguracja itp.).

Namierzyłem fajny skrypt, który umożliwia pełną obsługę pod RPI (napisany jest w bashu):
http://www.andreafabrizi.it/?dropbox_uploader

Ściągamy więc skrypt z repozytorium Andrei:

git clone https://github.com/andreafabrizi/Dropbox-Uploader.git ~/git_dropbox

Ja dodatkowo skopiowałem skrypt do /usr/bin, żeby uruchamiać go z dowolnego miejsca.

sudo cp ~/git_dropbox/dropbox_uploader.sh /usr/bin

Musimy się upewnić, że mamy zainstalowany pakiet curl:

sudo apt-get install curl

Uruchamiamy skrypt:

dropbox_uploader.sh

Przy pierwszym uruchomieniu nastąpi rejestracja w dropboxie, więc postępujemy zgodnie z instrukcjami (linki tworzące zasoby Apps możemy uruchamiać na dowolnym komputerze).
Skrypt poleci nam np. wejść na
https://www2.dropbox.com/developers/apps
gdzie należy stworzyć nową aplikację wg podanych informacji.

Mamy więc możliwość robienia backupów na Dropbox, bezpośrednio z konsoli.

Jakie są opcje skryptu:

# dropbox_uploader.sh

Dropbox Uploader v0.11.3

Andrea Fabrizi - andrea.fabrizi@gmail.com

Usage: /usr/bin/dropbox_uploader.sh COMMAND [PARAMETERS]...

Commands:

  upload   [LOCAL_FILE]  

  download [REMOTE_FILE] 

  delete   [REMOTE_FILE]

  list     

  info

  unlink

For more info and examples, please see the README file.

Sprawdzamy status

# dropbox_uploader.sh info
Dropbox Uploader v0.11.3
 > Getting info...
Name:   RB PL
UID:    XXXXXXXX
Email:  email@example.com
Quota:  2688 Mb
Used:   0 Mb
Free:   2687 Mb

Testowo backupujemy dowolny plik:

# dropbox_uploader.sh upload README
 > Uploading README to /README...
######################################################################## 100.0%
 > DONE

I sprawdzamy listę plików:

# dropbox_uploader.sh list
 > Listing "/"... DONE
 [F] README

Po testach stworzyłem prościutki skrypt backupujący moje pliki, tą stronkę oraz etc

# cat /projekty/makeBackup.sh
#!/bin/bash

DATA=`date +%Y%m%d`
PLIK_BKP="/tmp/$DATA.backup.tar.bz2"
DIRS="/projekty /etc /blog_backup"

/home/pi/blogspot_backup.sh

sudo tar cjf $PLIK_BKP $DIRS

dropbox_uploader.sh upload $PLIK_BKP

if [ $? = 0 ]
then
 rm -rf /blog_backup/*
 sudo rm -f $PLIK_BKP
fi

upewniłem się, że /etc/sudoers wygląda w porządku (tzn że komendę sudo możemy uruchomić bez pytania o hasło):

pi ALL=(ALL) NOPASSWD: ALL

lub bardziej bezpieczne (listing dozwolonych komend), np.

pi ALL=(ALL) NOPASSWD: /sbin/halt, /sbin/reboot, /projekty/makeBackup.sh

i wrzuciłem do crona

11 22 * * * pi /projekty/makeBackup.sh

czyli codziennie o 22:11 robiony będzie backup mojego katalogu oraz /etc i będzie wysyłany na Dropbox.
Przy okazji wspomnę, że dzięki Dropbox możemy pracować niejako w (popularnej ostatnio) chmurze. Ma on klienta dla Windowsa, MACa, Linuxa więc tak naprawdę możemy utworzyć sobie zasoby, które będą dostępne gdziekolwiek się ruszymy.

RPI + torrent (klient)

Od czasu do czasu przydaje nam się klient torrent-a - na przykład, żeby ściągnąć jakieś nowe ISO itp. Jako, że używamy raspberry z pewnymi ograniczeniami - dla mnie ważne jest żeby aplikacja zajmowała mało zasobów. Dlatego wybrałem rtorrent - czyli konsolowy klient. 

Instalujemy:

apt-get install rtorrent

Następnie warto go wstępnie skonfigurować. Przykładowy plik TUTAJ

Musi być w katalogu domowym pod nazwą .rtorrent.rc

Podstawowe komendy są w manualu. Wymienię więc tylko kilka z nich. 

Po menu poruszamy się strzałkami. Aktualny torrent zaznaczony jest gwiazdkami (zmieniamy strzałkami góra/dół), strzałka w prawo - detale torrenta.

wyjście

ctrl + q 

uruchomienie torrenta

ctrl + s 

reload - recheck hashu

ctrl + r

kombinacja ta często pomoga to przy błędzie:

Inactive: Hash check on download completion found bad chunks, consider using "safe_sync".

usunięcie pozycji z listy

ctrl + d 

widoki (podział na aktualnie ściągane, skończone, itp)

1-2-(..)-6

zmiana priorytetu

+/- 

Co ważne rtorrent obsługuje (oprócz tradycyjnych) linki magnet.

Do programu możemy dodać nowe torrenty poprzez uruchomienie go z linkiem jako parametrem, np

rtorrent "magnet:...."

lub w samym programie wklejamy link (najlepiej w cudzysłowiach) po enterze

Przy okazji - jeśli ktoś używa torrenta do ściągania filmów (legalnych jak rozumiem) - to może spróbować pobrać napisy za pomocą znanego i genialnego napiprojekt

Jakiś czas temu ktoś stworzył prosty ale świetny skrypcik korzystający z API napiprojekt... można go znaleźć wraz z opisem TUTAJ lub ściągnąc bezpośrednio stąd LINK

Należy pamiętać, że wymagany jest zainstalowany pakiet p7zip-full

Obsługa jest prosta:

napi.py NAZWA_FILMU

Jeśli skrypt się nie podoba albo chcemy mieć nieco więcej możliwości lub dostęp w środowisku graficznym to ewentualnie można też spróbować z qnapi lub gnapi...

Jeszcze na koniec zbadamy faktyczną wartość zużytych zasobów przez rtorrent:

około 1% procesora i pamięci, czyli ok 5MB fizycznej pamięci (RSS=5344), czyli całkiem nieźle.
To oczywiście dane odpalonego ale nieaktywnego program.
Podczas ściągania 1 torrenta u mnie zużycie procesora wynosi ok 2%, a pamięci 5-6% (czyli do ok 30MB), czyli w dalszym ciągu naprawdę niskie zużycie.

UPDATE
powyżej wspomniałem min. o projekcie qnapi...
jest on do ściągnięcia ze standardowych repozytoriów, czyli:

apt-get install qnapi

UPDATE #2
Popracowałem ostatnio trochę z linkami magnet i jako że nieraz bywa to trochę uciążliwe - postanowiłem udokumentować najprostsze rozwiązanie... (opis TUTAJ)

tworzymy skrypt (np rtorrent_magnet.sh):

cd ~/watch || exit    # set your watch directory here
[[ "$1" =~ xt=urn:btih:([^&/]+) ]] || exit
hashh=${BASH_REMATCH[1]}
if [[ "$1" =~ dn=([^&/]+) ]];then
  filename=${BASH_REMATCH[1]}
else
  filename=$hashh
fi
echo "d10:magnet-uri${#1}:${1}e" > "meta-$filename.torrent"

konfigurujemy katalog typu schedule dla rtorrent

schedule = watch_directory,5,5,load_start=/home/[user]/watch/*.torrent

i dodajemy nowe linki (nie tylko magnet) dodając pliki *.torrent do katalogu watch lub dodajemy linki magnet uruchamiając skrypt

./rtorrent_magnet.sh "MAGNET_LINK"

Zabawy z MOTD

Okres świąteczny więc nieco luźniejszy temat.

Ten post nie dotyczy tylko raspberry, ale ogólnie systemów linux/unix i przydatny jest raczej przy większej ilości serwerów/komputerów, ale kto nam zabroni trochę się pobawić;)

MOTD - czyli message of the day - w systemach Linux tekst wyświetlany po zalogowaniu się do systemu. W ten sposób zazwyczaj ostrzegamy, że nieautoryzowany dostęp do systemu jest karalny, a także możemy przekazywać różne informacje logującym się użytkownikom (którzy zazwyczaj tego nie czytają ;) ).

Ponadto może być wykorzystany do wyraźnego rozróżnienia systemów (przydatne jak ktoś pracuje późną nocą na dużej ilości serwerów).

No i przydatne żeby się nieco pobawić ;) 

Jest kilka pakietów, które mogą nam pomóc urozmaicić nieco nasze motd. 

figlet - "graficzne" przedstawienie tekstu 

figlet "M A L I N K A"

cowsay - (jakkolwiek dziwnie to brzmi) krowa lub inne zwierzę przekazuje nam jakąś treść

fortune-mod - jeśli ktoś chce jeszcze urozmaicić swój wpis o generowane cytaty lub słynne zdania...

przykładowe połączenie cowsay z fortune 

 /usr/games/fortune -s |  /usr/games/cowsay -f /usr/share/cowsay/cows/www.cow

Żeby sprawdzić wszystkie możliwości

for i in `ls /usr/share/cowsay/cows/`; do /usr/games/fortune -s | /usr/games/cowsay -f $i; done

Do wszystkich komend są dobre manuale, które polecam przejrzeć.

Ponadto możemy jeszcze dodać parę kolorków, np:

 echo  "$(tput setaf 1) `figlet R a s p b e r r y`"

Jak to wykorzystać? Możemy po prostu przekierować wynik do pliku /etc/motd lub stworzyć skrypt, który (jeśli chcemy mieć w jakiś sposób zmienną treść) będzie to robić przy każdym starcie systemu lub co jakiś czas (w cron-ie).

Przy okazji możemy edytować też plik /etc/issue - treść będzie widoczna lokalnie zanim się zalogujemy na konsoli.

A przy okazji - w związku z aktualną datą:

Czujnik temperatury

Kolejnym krokiem w moich testach jest czujnik temperatury. Zakupiłem bardzo typowy, łatwo dostępny w Polsce czujnik DS18B20, kosztuje niecałe 4zł.

Dane techniczne:

DS18B20 - Czujnik temperatury TO92

• Napięcie pracy: 3 - 5,5V
• Mierzona temperatura: -55°C - + 125°C
• Dokładność: 0,5°C
• Interfejs: 1-Wire
• Obudowa: TO92

Źródło: electropark.pl

Interfejs 1-wire powinien być możliwy do uruchomienia w każdym najnowszym jądrze...
Jeśli ktoś ma z problem z 1-wire polecam zajrzeć tutaj:

https://github.com/FrankBuss/linux-1/commit/71871509238d3e7bce4a74cdf616c3f12542acaa

albo użyć systemu Adafruit - Occidentials:

http://learn.adafruit.com/adafruit-raspberry-pi-educational-linux-distro/overview

W każdym razie na najnowszym Raspbianie również działa.

OSTRZEŻENIE !

Przy podłączaniu wszelkich kabelków należy zachować ostrożność, gdyż może zakończyć się to uszkodzeniem sprzętu lub uszczerbkiem na zdrowiu. Robisz to na własną odpowiedzialność.

UKŁAD

Tradycyjnie opis GPIO możemy znaleźć TUTAJ

Pierwszy pin czujnika to GND

Drugi pin do GPIO 4 (4 z lewej) oraz rezystor 4k7 do +

trzeci pin do +

no i + do 3.3V w RPI

Następnie ładujemy moduły (można je oczywiście dodać na stałe w /etc/modules)

sudo modprobe w1-gpio
sudo modprobe w1-therm

i weryfikujemy

cd  /sys/bus/w1/devices/

tu powinien być katalog zaczynający się na 28-...

# cat 28-000004458ce3/w1_slave 

3e 01 4b 46 7f ff 02 10 6c : crc=6c YES
3e 01 4b 46 7f ff 02 10 6c t=19875

czyli w moim przypadku temperatura to około 19,87 °C (wartość t= podzielona przez 1000)

MRTG
Jakiś czas temu napisałem krótkiego posta jak skonfigurować mrtg. Teraz jeden praktyczny pomysł jak to wykorzystać.
Podepniemy tu wyniki z czujnika, żeby rysowało nam wykresy.
Dodatkowo (dla większego bajeru;) ) jako porównanie dodamy drugą wartość - np temperaturę ze stolicy (to już oczywiście ściągane z internetu - np z www.wunderground.com)
Od razu zaznacze, że zapewne da się to zrobić inaczej/łatwiej, ale jako, że nie mam duszy programisty zrobiłem to właśnie tak.

Najpierw upewniamy się, że mamy zainstalowany pakiet links
Szukamy na www.wunderground.com miasta np Warszawa, klikamy na nazwie stacji pogodowej... na samym dole jest link do CDF (Comma Delimited File)
w przypadku Wawy ostateczny link to:
http://www.wunderground.com/history/airport/EPWA/2012/12/25/DailyHistory.html?format=1
ostatnia linia to najbardziej aktualny odczyt

W międzyczasie przypomniało mi się, że MRTG zaokrągla liczby (nie bierze pod uwagę wartości po przecinku, czyli 20,46°C to po prostu będzie 20). Dlatego postanowiłem zrobić małe obejście i pomnożyć każdy wynik * 10 - żeby mieć na wykresach nieco większą dokładność (czyli 20,46°C - to będzie 204 w moim przypadku). Tu tylko zaznaczę, że równie dobrze można wykorzystać czyste rrdtool, która ma dokładność do 3 miejsc po przecinku - ale szczerze mówiąc nie chciałem na to już zużywać zbyt dużo czasu.

Tak więc do /etc/mrtg.conf dodajemy

Title[temper]: Temperatura * 10
PageTop[temper]: Temperatura * 10
Target[temper]: `/projekty/temperatura/getTemp.sh`
MaxBytes[temper]: 500
Options[temper]: nopercent,growright,nobanner,nolegend,noinfo,gauge
ShortLegend[temper]: C
LegendI[temper]: Temperatura dom * 10
LegendO[temper]: Temperatura SF * 10
YLegend[temper]: Stopnie C

Tworzymy skrypt, który będzie weryfikował temperaturę lokalnie i z internetu.

#!/bin/bash

DATAdlaLINKSA=`date +%Y/%m/%d`
LINK_TEMP="http://www.wunderground.com/history/airport/EPWA/$DATAdlaLINKSA/DailyHistory.html?format=1"

# weryfikacja czy załadowany jest moduł
lsmod | grep w1_therm > /dev/null 2>/dev/null
if [ $? = 0 ]
then
        echo ok >/dev/null
else
        sudo modprobe w1_gpio
        sudo modprobe w1_therm
fi

TEMPczujnik=`cat "/sys/bus/w1/devices/28-000004458ce3/w1_slave"  | grep "t=" | cut -d "=" -f 2`
echo "scale=2;  $TEMPczujnik / 100" | bc

TEMPWAW=`links -width 150 -dump $LINK_TEMP | tail -1 | cut -d "," -f 2`
echo "scale=2; $TEMPWAW * 10" | bc

Przy zrzucie stronki przez links - ostatnia linia (zebrana przez tail -1) pokazuje standardowo tylko godzinę... pewnie jest na to inne rozwiązanie, ale nie chciałem za bardzo wnikać i poszerzyłem po prostu zakres dla linksa (-width 150).

Odpalamy jeszcze raz indexmaker i po jakimś czasie powinniśmy mieć wykresy.

Niebieska linia to wyniki z internetu, a zielone słupki to nasz czujnik.

Jeśli chodzi o już zupełnie praktyczne zastosowanie - myślę, że trochę tego jest - np. monitor temperatury w garażu, szklarni, pomieszczenia w którym szykujemy wino, serwerowni itp.
Można sięgnąć nieco (naprawdę tylko nieco) głębiej do kieszeni i zakupić wodoodporny czujnik i monitorować temperaturę płynów itp.

Pierwsze kroki z elektroniką

WSTĘP

Zamówione części elektroniczne dotarły w końcu na miejsce, więc nadeszła pora na pierwsze testy.

Na początek zamówiłem min. :

trochę diod LED, 

trochę kabelków połączeniowych (na początek póki nie wykorzystam Cobbler-a szczególnie przydadzą się kabelki męsko - żeńskie), 

zestaw rezystorów,

wyświetlacz,

potencjometry,

przyciski,

kilka czujników (między innymi czujnik temperatury).

Dostałem też w prezencie używaną płytkę stykową (na 830 pól). Delikatnie stopiony kawałek ale działa :)

Z czasem przedstawię tu więcej szczegółów.

Do takich zabaw z RPI bardzo przydatna jest znajomość python-a, której na tą chwilę nie posiadam (a raczej znam tylko zupełne podstawy), więc ostatnio wolne chwile spędzam na dokształcaniu się z tego języka programowania. W międzyczasie - krótko mówiąc - wykorzystałem gotowce z internetu.

OSTRZEŻENIE !

Przy podłączaniu wszelkich kabelków należy zachować ostrożność, gdyż może zakończyć się to uszkodzeniem sprzętu lub uszczerbkiem na zdrowiu. Robisz to na własną odpowiedzialność.

Na początek należy upewnić się, że mamy zainstalowane paczki:

python-rpi.gpio

python-dev

DIODA LED

Źródło: greenprophet.com

Dioda LED - czyli w tym przypadku odpowiednik "hello world" dla programistów. Niemal każdy zaczyna od właśnie tego kroku.

O czym należy pamiętać?

Anoda (negativ) - to ta krótsza nóżka - nieraz ma "flat spot" - czyli płaski bok.

Katoda (positiv) - ta dłuższa.

Diody pracują z odpowiednimi parametrami. W moim przypadku (dla diody zielonej) to 

Napięcie pracy: 2,3V
Prąd: 20mA

Jak wiemy porty GPIO w RPI działają z napięciem 3,3V. Gdybyśmy podłączyli bezpośrednio taką diodę do portu GPIO to najprawdopodobniej uległa by ona uszkodzeniu. Należy więc dobrać odpowiedni rezystor.

Wzór jest bardzo prosty: 

R=(V wyj - V led)/I led 

czyli w tym przypadku: 

R=(3,3-2,3)/0,02

0,02 - czyli 20mA

Wynik to 50 Ohm.

Najbliższa dostępna wartość (bezpiecznie trzeba brać wyższą) to 56Ohm i taki muszę dobrać rezystor.
Jeśli komuś niezbyt chc>e się liczyć może się posłużyć min. tym narzędziem: 

http://led.linear1.org/1led.wiz

Rezystory po przesyłce są oczywiście opisane, ale jak gdyby ktoś nie wiedział który ma wymaganą wartość możemy się posłużyć oznaczeniami. Zazwyczaj rezystory mają 4 kolorowe paski i na ich podstawie możemy oszacować wartość. 

Oznaczenie kolorów:
0 - czarny
1 - brązowy
2 - czerwony
3 - pomarańczowy
4 - żółty
5 - zielony
6 - niebieski
7 - fioletowy
8 - szary
9 - biały

Pierwsze 2 wstęgi to wartość, trzecia to mnożnik, a czwarta to tolerancja (w tym przypadku najczęściej spotykany jest kolor złoty, oznaczający +/- 5%).

Czyli np rezystor z paskami :

brąz czarny czerwony i złoty

Wyliczamy:

brąz (1), czarny (0)  - czyli 10 

czerwony to 2 - czyli mnożnik 100 (2 zera)

złoty +/- 5%

czyli rezystor może mieć wartości (10*100 +/- 5% ) - czyli 950 - 1050 Ohm, czyli ogólnie 1kOhm.

Oczywiście (znów) są narzędzia dla leniwych, np.

http://www.dannyg.com/examples/res2/resistor.htm

OK. Mamy diodę, rezystor i płytkę stykową z kabelkami.

Podłączamy - w jednym rzędzie anoda diody oraz rezystor podłączony do minusa. Minus płytki należy podłączyć do GND (ground) w RPI - np port 3 w prawym rzędzie.

Przypomnę tylko że opis GPIO jest TUTAJ 

Następnie katodę diody podłączamy np do portu GPIO 14 w RPI - czyli 4 w prawym rzędzie.

Następnie musimy utworzyć/skopiować skrypt obsługujący porty (może być w różnych językach, ja wybrałem python-a).
Najpierw należy upewnić się, że mamy zainstalowane potrzebne pakiety:

apt-get install python-rpi.gpio python-dev

Przykładowy skrypt:

import RPi.GPIO as gpio
import time

#set up pin 14 as an output
gpio.setmode(gpio.BCM)
gpio.setup(14, gpio.OUT)

gpio.output(14, gpio.HIGH)
time.sleep(3)
gpio.output(14, gpio.LOW)

Ewentualnie zamiast 3 ostatnich linii możemy spróbować pętle:

while True: 
           gpio.output(14, gpio.HIGH) 
           time.sleep(3) 
           gpio.output(14, gpio.LOW) 
           time.sleep(3)

i dioda będzie migać dopóki nie przerwiemy.

TACT SWITCH

Źródło: toscos.com

Dorzuciłem również "momentary button", czyli przycisk powodujący przekazanie sygnału tylko na czas wciśnięcia... Tu trzeba się upewnić, że każda (z 4) nóżka jest w osobnym rzędzie na płytce stykowej.

Układ:

nóżka pierwsza tact-a - do GPIO.17 w RPI (6 port z lewej), następnie poprzez rezystor 10k podłączamy do 3.3V, czyli 1port z lewej w RPI

druga nóżka tact-a do GND w RPI

Skrypt:

import RPi.GPIO as gpio

#set up pin 17 as an input
gpio.setmode(gpio.BCM)
gpio.setup(17, gpio.IN)

while True:
        input_value = gpio.input(17)
        if input_value == False:
                print('Przycisk wcisniety...')
                while input_value == False:
                        input_value = gpio.input(17)

Przy każdym wciśnięciu przycisku na konsoli pojawi się napis...
Przy okazji wspomnę, że w ten oto sposób możemy zrobić wyłącznik dla naszej Malinki. Czyli zamiast odcinać zasilanie przez wyciągnięcie kabla (co nie jest do końca przyjazne np dla karty SD), możemy zdefiniować czyste i bezpieczne wyłączenie systemu po wciśnięciu przycisku.

DIODA + TACT

czyli łączymy jedno z drugim...

zostawiamy układ tak jak powyżej (przy tact)

oraz znów anoda diody z rezystorem do innego portu GND

a katoda diody do portu GPIO 14 w RPI

Skrypt:

import RPi.GPIO as gpio
import time

#set up pin 14 as an output and 17 as input
gpio.setmode(gpio.BCM)
gpio.setup(14, gpio.OUT)
gpio.setup(17, gpio.IN)

while True:
        input_value = gpio.input(17)
        if input_value == False:
                gpio.output(14, gpio.HIGH)
                time.sleep(3)
                gpio.output(14, gpio.LOW)
                while input_value == False:
                        input_value = gpio.input(17)

spowoduje zapalenie diody na 3 sekundy po wciśnięciu guzika. 

Podstawy więc zaliczone. Łatwizna.