Serwer WWW Apache w praktyce. Część 3: odbieranie danych

[ethanak 1515]

Na początku jedna uwaga: ten cykl artykułów nie jest podręcznikiem Pythona ani nie rości sobie praw do bycia takim. Używam w przykładach Pythona jako najbardziej popularnego języka programowania na RPi - ale równie dobrze mógłbym użyć Perla, C++ czy nawet Basha, a cykl jest po prostu "boczną odnogą" napisanego wcześniej cyklu o protokole HTTP. Dlatego też wiele kwestii zostało pominiętych i użytkownik musi większość problemów rozwiązać we własnym zakresie (czyli najprawdopodobniej znaleźć właściwe rozwiązanie w innym artykule).

Ale przejdźmy do rzeczy.

W poprzednim odcinku dowiedzieliśmy się, jak uruchomić z poziomu serwera WWW skrypty pisane w dowolnym języku, i jak pozwolić im na komunikację z GPIO i magistralami SPI/I2C na przykładzie odczytu danych z czytnika RFID. Dzisiaj spróbujemy komunikacji w drugą stronę: z poziomu przeglądarki spróbujemy wysłać coś na magistralę.

Ale najpierw trochę teorii.

Z artykułu o protokole HTTP (jeśli ktoś go nie przeczytał, to teraz jest najwyższy czas) mogliśmy dowiedzieć się, jak jest zbudowany URL. Widzimy tam, że w najprostszej postaci URL wygląda tak:

http://<host><ścieżka>[?<zapytanie>]

Możemy się domyślać, że host informuje przeglądarkę (i serwer) z jakim serwerem i jaką stroną ma się połączyć, ścieżka wskazuje na plik który mamy z serwera odczytać (lub - w przypadku skryptu - serwer ma go wykonać i przekazać nam wyniki), ale czym jest to całe zapytanie?

Otóż są to dodatkowe dane przekazywane od klienta (czyli w naszym przypadku przeglądarki) do skryptu. Jak uprzednio wspominałem, format zapytania jest dowolny i zależy praktycznie od tego co potrafi klient i serwer, ale w praktyce używa się pewnej ustalonej składni:

nazwa=wartość

z możliwością przekazania większej ilości parametrów, oddzielając je znakami '&', czyli coś w rodzaju:

nazwa1=wartość1&nazwa2=wartość2&nazwa3=wartość3

Zarówno nazwa jak i wartość mają swoje ograniczenia - mogą zawierać wyłącznie drukowalne siedmiobitowe znaki ASCII bez spacji (czyli z zakresu od 0x21 do 0x7E włącznie) z wyłączeniem niektórych znaków zastrzeżonych (np. trudno by było zastosować nazwę zawierającą w sobie znak równości, czy też umieścić znak '&' wewnątrz wartości). Dlatego też opracowano pewien sposób kodowania (tzw. "urlencode"), pozwalający na przekazanie dowolnych danych. Sposób jest bardzo prosty:

• znak spacji zamieniamy na '+'
• znaki które nie kolidują ze składnią zapytania pozostawiamy bez zmian
• pozostałe znaki (oraz znak + występujący w wartości) zamieniamy na ciąg %XX, gdzie 'XX' to szesnastkowa reprezentacja znaku.

Tak więc np. ciąg znaków 'ala+ma kota' zostanie zakodowany jako:

ala%2Bma+kota

Oczywiście nie ma żadnych innych ograniczeń (poza oczywistymi, wynikającymi z maksymalnej długości URL-a którą może przyjąć serwer oraz takim, że nazwa nie może mieć aerowej długości). W szczególności przesłanie kilku wartości (np. informacji o zaznaczonych kilku możliwościach wyboru) nie wymaga jakichś specjalnych zabiegów, po prostu wystarczy zapytanie w stylu:

nazwa=wybór1&nazwa=wybór3&nazwa=wybór7

O, i tu słyszę głosy programistów PHP - jak to? Przecież aby przesłać kilka wartości nazwa musi kończyć się znakami '[]' wskazującymi na tablicę, a dopiero wtedy w tablicy $_GET w pozycji wskazywanej przez 'nazwa[]' znajdzie się nie pojedyncza wartość, a tablica wartości!

Niestety - dotyczy to wyłącznie PHP i jest to zaszłość historyczna (pochodzi z czasów, gdy nikt z twórców PHP nie wpadł na to że można przesyłać więcej niż jedną wartość; w związku z tym trzeba było dorobić na szybko jakąś protezę - i to taką, która nie wysadzi w kosmos wszystkich dotychczas napisanych skryptów w tym języku).

No - ale dość już teoretyzowania, przejdźmy do praktyki. Serwer mamy już skonfigurowany, spróbujmy na początek napisać prosty program, wpisujący otrzymane zapytanie do pliku/ Utwórzmy więc w katalogu html plik "napis.cgi" z następującą zawartością:

#!/usr/bin/env python3

import cgitb, os

print("Content-Type: text/plain; charset=UTF-8\n")
cgitb.enable(format="text")

napis=os.environ.get("QUERY_STRING")
if not napis:
    print ("A gdzie zapytanie?")
else:
    open("dane.txt","w").write(napis)
    print ("Zapisałem:", napis)

Po zmianie uprawnień na 0755 i wpisaniu w przeglądarkę np:

http://<ip_malinki>/napis.cgi?Hello

powinna ukazać się odpowiedź "Zapisane: Hello", a w pliku html/dane.txt znajdzie się otrzymany napis

Dobra - ale przecież wspominałem o jakichś nazwach, wartościach, urlencode... a tymczasem przy próbie wpisania:

http://<ip_malinki>/napis.cgi?Cześć, świecie

pokazuje się zakodowana treść zapytania, i taka też ląduje w pliku!

Powód jest prosty: Python - w przeciwieństwie do PHP - nie ma żadnych superglobali ani innych automagicznych zaklęć będących częścią języka i zajmujących się dekodowaniem tego, co przysłał serwer. To tego służy biblioteka o nazwie - jak łatwo zgadnąć - cgi.

Do pobierania i udostępniania w programie parametrów przesłanych do skryptu służy klasa FieldStorage. Zainteresowanych odsyłam do dokumentacji, nas będą interesować jedynie dwie metody: getlist(name) zwracająca listę wszystkich wartości związanych z daną nazwą oraz getfirst(name, default=None) zwracająca pierwszą napotkaną wartość związaną z daną nazwą lub wartość określoną przez parametr default (domyślnie None), jeśli dana nazwa nie wystąpiła w zapytaniu.

Przeróbmy nieco nasz skrypt - niech napisem będzie wartość skojarzona z nazwą "tresc":

#!/usr/bin/env python3

import cgitb, cgi

print("Content-Type: text/plain; charset=UTF-8\n")
cgitb.enable(format="text")

form = cgi.FieldStorage()
napis = form.getfirst("tresc", '').strip()

if not napis:
    print ("A gdzie treść?")
else:
    open("dane.txt","w").write(napis)
    print ("Zapisałem:", napis)

Teraz wysłanie zapytania typu:

http://<ip_malinki>/napis.cgi?tresc=Cześć, świecie

spowoduje pojawienie się prawidłowej odpowiedzi oraz zapisanie prawidłowego tekstu do pliku.

Ponieważ wpisywanie tego typu poleceń do pola adresu przeglądarki nie jest specjalnie wygodne, możemy zrobić prosty formularz, z którego dane będziemy przesyłać do naszego skryptu:

#!/usr/bin/env python3

import cgitb, cgi, html

print("Content-Type: text/html; charset=UTF-8\n")
cgitb.enable(format="html")

form = cgi.FieldStorage()
napis = form.getfirst("tresc", '').strip()

wynik="""<!DOCTYPE html>
<html>
<head>
<title>Prosty formularz</title>
</head>
<body>
%s
<form method="post">
<input type="text" name="tresc" value="%s">
<input type="submit">
</form>
</body>
</html>
"""


if not napis:
    komunikat = "A gdzie treść?"
else:
    open("dane.txt","w").write(napis)
    komunikat = "Zapisałem: "+ napis
    
print(wynik % (html.escape(komunikat), html.escape(napis, True)))

Teraz mamy już prawdziwy formularz. Spróbujmy więc przekazać dane do jakiegoś urządzenia podłączonego do naszej malinki. Jako przykład wybrałem popularny wyświetlacz tekstowy LCD 16x2 z interfejsem I2C.

Połączenie jest w tym przypadku dużo prostsze, niż było to przy czytniku RFID. Interfejs I2C wymaga podłączenia tylko dwóch przewodów poza zasilaniem. Pamiętać należy, że wyświetlacz wymaga zasilania 5V! A więc układ połączeń jest taki:

• Pin 2 (+5V) do VCC wyświetlacza
• Pin 6 (GND) do GND wyświetlacza
• Pin 3 (SDA1) do SDA wyświetlacza
• pin 5 (SCL1) do SCL wyświetlacza

 

Spróbujmy najpierw uruchomić wyświetlacz. Ciekawy artykuł na ten temat można znaleźć w serwisie Circuit Basics, ale dla niecierpliwych przygotowałem krótki sposób uruchomienia.

Przede wszystkim potrzebny będzie moduł obsługi szyny I2C:

sudo apt install python3-smbus

Niestety - programu obsługi wyświetlacza w repozytorium nie ma. Na szczęście wspomniany artykuł pokazuje prosty, niewielki moduł który to umożliwia. Moduł wraz z programem demonstracyjnym można ściągnąć z githuba, na wszelki wypadek sam plik RPi_I2C_driver.py dodałem do załącznika. Plik ten należy umieścić w naszym katalogu html wraz z programem.

Sprawdźmy najpierw, czy nasz wyświetlacz działa. Napiszemy krótki program (umieśćmy go przykładowo w pliku nasz_program.py):

#!/usr/bin/env python3

import RPi_I2C_driver

lcd=RPi_I2C_driver.lcd()
lcd.lcd_clear()
lcd.lcd_display_string_pos("Witaj swiecie!!!",1,0)

Po uruchomieniu poleceniem:

python3 nasz_program.py

wyświetlacz powinien wyświetlić tekst "Witaj swiecie!!!".

Co się jednak stanie, jeśli wyświetlacz nie będzie potrafił wyświetlić zadanego napisu?

Przeróbmy nieco nasz program, aby można było podawać mu bezpośrednio napis:

#!/usr/bin/env python3

import RPi_I2C_driver, sys

lcd=RPi_I2C_driver.lcd()
lcd.lcd_clear()
napis = ' '.join(sys.argv[1:])
lcd.lcd_display_string_pos(napis,1,0)

Jeśli teraz wywołamy go z parametrem:

python3 nasz_program.py żółć

zobaczymy na wyświetlaczu coś, co w żadnym przypadku z żółcią nie ma nic wspólnego...

Jak to rozwiązać?

Można oczywiście stworzyć własne znaczki i je wyświetlać w miejsce brakujących. Jest to jednak nieco żmudne, poza tym w języku polskim występuje 18 dodatkowych liter, a mamy do dyspozycji tylko 8 możliwości. Najprostszym rozwiązaniem będzie takie przekształcenie tekstu, aby mógł być bez problemu pokazany nawet na wyświetlaczach nie pozwalających na wprowadzanie dodatkowych znaków. Do tego posłuży nam moduł unidecode.

Zaczynamy od instalacji, czyli:

sudo apt install python3-unidecode

Moduł zawiera jedną tylko interesującą nas funkcję unidecode, tak więc nasz program będzie teraz wyglądać następująco:

#!/usr/bin/env python3

import RPi_I2C_driver, sys
from unidecode import unidecode

lcd=RPi_I2C_driver.lcd()
lcd.lcd_clear()
napis = unidecode(' '.join(sys.argv[1:]))
lcd.lcd_display_string_pos(napis,1,0)

Po uruchomieniu możemy zobaczyć, że program tym razem zamiast krzaków wyświetla po prostu literki pozbawione znaków diakrytycznych.

Teraz możemy już przerobić nasz skrypt tak, aby wpisywane wartości zamiast do pliku wypisywane były na wyświetlaczu:

#!/usr/bin/env python3

import cgitb, cgi, html, RPi_I2C_driver
from unidecode import unidecode

print("Content-Type: text/html; charset=UTF-8\n")
cgitb.enable(format="html")

form = cgi.FieldStorage()
napis = form.getfirst("tresc", '').strip()

wynik="""<!DOCTYPE html>
<html>
<head>
<title>Prosty formularz</title>
</head>
<body>
%s
<form method="post">
<input type="text" name="tresc" value="%s">
<input type="submit">
</form>
</body>
</html>
"""


if not napis:
    komunikat = "A gdzie treść?"
else:
    napis2 = unidecode(napis)
    lcd=RPi_I2C_driver.lcd()
    lcd.lcd_clear()
    lcd.lcd_display_string_pos(napis2,1,0)
    komunikat = "Wyświetlam: "+ napis2
    
print(wynik % (html.escape(komunikat), html.escape(napis, True)))

Jak widać, nasz skrypt radzi sobie bez problemu nawet z takimi alfabetami jak chiński czy koreański!

Tyle na dziś - następnym razem postaram się pokazać kilka przydatnych (szczególnie dla początkujących) dyrektyw konfiguracyjnych Apacza i spróbuję rozwiązać problem jednoczesnego dostępu do GPIO.

W załączniku driver wyświetlacza: driver.tgz

[Treker 2108]

@ethanak bardzo fajna seria artykułów Gratuluję pomysłu i dziękuję za przygotowanie ciekawych poradników!