2013-01-09

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).


2013-01-08

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.

2013-01-06

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

2013-01-04

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.

2013-01-02

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"