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"