View source for VSCode Python RasberryPI

[[Category:Guide]]
[[Category:Visual Studio Code]]
[[Category:Python]]
[[Category:Web]]
[[Category:RaspberryPI]]
= RasberryPI + Visual Studio Code + Python + Flask =

Oggi vedremo come sviluppare remotamente in Python su RaspberryPI.

Come tutti coloro che si interessano di informatica sanno RaspberryPI è un Single Board Computer che dispone di un modulo di interfaccia hardware che può essere usata per pilotare sensori elettronici. Molti anche sanno che il Sistema Operativo preferenziale è una versione di Debian chiamata raspbian e che promuove l'utilizzo del linguaggio di programmazione Python.

Se vogliamo programmare in python per pilotare sensori, siamo obbligati a lavorare direttamente sulla macchina, non possiamo siluppare su un sistema diverso e poi portare i sorgenti per il semplice fatto che abbiamo la necessità di testare i sensori che sono fisicamente presenti.

Programmare in Python su RaspberryPI può essere complicato perché senza disporre di una IDE di programmazione è difficile fare il debug delle applicazioni. Quindi abbiamo 3 alternative:

# Scrivere i programmi Python con un semplice editor di testo.
# Installare PyCharm community edition
# Utilizzare Visual Studio Code per il debug remoto via SSH

La soluzione n. 1 non consente il debug interattivo e quindi rende difficoltoso lo sviluppo di soluzioni complesse e la consiglio solo per fare piccoli test.

La soluzione n. 2 è ottima e probabilmente è più facile da implementare della soluzione 3 anche se presenta qualche difficoltà.

Infine la soluzione n. 3 forse è più complessa, ma ha alcuni vantaggi:

* Non ho la necessità di collegare il RPI a tastiera, mouse e video, ma posso lavorare in remoto.
* Posso applicare la tecnica imparata per usarla con altri Single Board Computer oppure con macchine remote VPS o anche con container Docker.
* Visual Studio Code conosce molti linguaggi perciò posso usare un unico strumento per progetti diversi.

Ci sono alcune avvertenza. Siccome il metodo descritto deve installare alcune cose nella macchina remota, è necessario che la piattaforma hardware remota si supportata da vscode. Al momento oltre alla piattaforma Intel è supportato Arm7 che è quella su cui è basato RPI. Su altre architetture basate ad esempio su Arm8 il sistema non funzionarà.

La nostra guida utilizza come computer host una una macchina Ubuntu ma con qualche passaggio riusciremo a fare la stessa cosa anche con Windows o Mac.

Nel momento in cui io scrivo, ho già fatto funzionare la ricetta, perciò non sono sicuro di elencare con precisione tutti i passi necessari, ma sicuramente darò una indicazione precisa del percorso necessario per portare a buon fine il lavoro.

== RaspberryPI ==

Diamo per scontato di aver installato raspbian sul nostro RPI e di non aver modificato le impostazioni predefinite. Lo possiamo collegare alla nostra rete domestica tramite wifi, oppure tramite cavo di rete. Per questo tutorial non serve collegare video, mouse e tastiera, perché tutto il lavoro sarà fatto da remoto.

Se abbiamo la configurazione standard di RPI, la macchina ha abilitato il DHCP e può essere raggiunta da remoto tramite il comando ssh. Qundi se la colleghiamo alla nostra rete la prima cosa da fare è individuare il suo indirizzo IP, dalla nostra macchina host la possiamo cercare usando un programma che fa la scansione della rete ad esempio: [https://angryip.org/ Angry IP Scanner] dopo aver indivuduato l'indirizzo (ad esempio 192.168.1.25) possiamo provere se funziona ssh.

<pre>ssh pi@192.168.1.25</pre>
ci chiede la password e digitiamo

<pre>raspberry</pre>
Se funziona tutto possiamo proseguire. Una cosa che possiamo fare e che è consigliata, anche se non obbligatoria è quella di usare una chiave RSA per accedere al RPI senza digitare la password. Se non lo abbiamo ancora fatto, creiamo una chiave sul nostro computer host con

<pre>ssh-keygen</pre>
e copiamo la parte pubblica della chiave sul RPI con:

<pre>ssh-copy-id pi@192.168.1.25</pre>
ci viene chiesta la password e dopo averla digitata entriamo nuovamente con ssh:

<pre>ssh pi@192.168.1.25</pre>
Da questa volta in poi non ci viene più chiesta la password.

Dato che ci siamo variamo un parametro di configurazione che ci tornerà buono in seguito. Con il comando:

<pre>sudo nano /etc/sysctl.conf</pre>
modifichiamo il file ed alla fine del testo aggiungiamo la riga:

<pre>fs.inotify.max_user_watches=524288</pre>
poi riavviamo la configurazione con:

<pre>sudo sysctl -p</pre>
Questo ci permette di aprire molti files da remoto quando accederemo con vscode. Ora installiamo anche tutto quello che ci serve di python con:

<pre>sudo apt install python3 python3-pip python3-venv</pre>
== Ubuntu (host) ==

Come sul Raspberry PI, anche sulla macchina host ci dobbiamo accertare di disporre di una installazione completa di python, consigliamo di usare python3 dato che il supporto per python2 sta per finire. Installiamo quindi:

<pre>sudo apt install python3 python3-pip python3-venv
python3 -m pip install -U pip --user</pre>
== Visual Studio Code ==

Come abbiamo già avuto modo di dire, Visual Studio Code è una ottima IDE per programmatori. È leggera ma molto potente ed ha il vantaggio indubbio di supportare molti linguaggi di programmazione. La installeremo sul computer host e ci permetterà di lavorare remotamente sul nostro RPI. Per installarla su un sistema ubuntu consiglio di usare l'utility ubuntu-make che permette di tenere aggiornato il programma ed anche di installare altri tools per sviluppatori.

<pre>sudo apt install ubuntu-make
umake ide visual-studio-cpde</pre>
Per trovare il programma nel menù della applicazioni di Ubuntu, dovete terminare la sessione e rifare il login per dare modo al sistema di riconoscere che è stato installato un programma nuovo, oppure potete lanciare il programma direttamente da riga di comando con:

<pre>~/.local/share/umake/ide/visual-studio-code/bin/code</pre>
consigliamo di aggiungere il percorso del programma al nostro file .bashrc in modo da lanciarlo semplicemente digitando:

<pre>code</pre>
=== Configurazione di vscode (Python debugger) ===

Prima di tutto dobbiamo installare l'estensione python per vscode, apriamo il tool delle estensioni di vscode facendo click sulla icona a sinistra con i quadratini, oppure digitando Ctrl+Shift+X , sopra scriviamo python ed installano il modulo Microsoft per Python.

Possiamo provare subito a vedere se funziona, da terminale digitiamo:

<pre>cd ~
mkdir python_test
touch python_test/test.py</pre>
quindi andiamo su vscode ed apriamo la cartella da menu oppure digitando Ctrl+K Ctrl+O . Appena apriamo il nostro file <code>test.py</code>, vscode ci chiede di installare alcune cose di python che gli servono per la ricerca intelligente. Ora scriviamo il nostro programma di test:

<pre>import sys

print(sys.path)</pre>
per provere il programma lanciamo il debugger facendo click sulla icona a sinistra con l'insetto oppure digitando Ctrl+Shif+D . La prima volta il programma chiede la configurazione di debug che desideriamo. Scagliamo Python File ed il programma scrive un file di configurazione di nome launch.json nella cartella .vscode sotto la cartella corrente.

A questo punto possiamo andare sul nostro file test.py, mettere un punto di interruzione in corrispondenza della istruzione print, ed avviare il debugger scegliendo &quot;Python: Current File&quot; nella finestrella di debug che compare in alto.

Se abbiamo fatto tutto bene, il programma si avvia e si arresta nel punto prescelto, e proseguendo stampa il nostro sys.path

=== Configurazione di vscode (remote - SSH) ===

Per sviluppare sulla RPI remota dal nostro vscode, dobbiamo installare il modulo remote - SSH, Premiamo Ctrl+Shift+X e cerchiamo Remote -SSH, installiamo il modulo e comparirà una nuova icona sulla sinistra che raffigura uno schermo con un cerchietto che indica la connessione. Facciamo click sull'icona e sulla sezione &quot;SSH TARGETS&quot; facciamo click sulla icona con l'ingranaggio. Scegliamo il primo file proposto e scriviamo:

<pre>Host RaspberryPI
    HostName 192.168.1.25
    User pi</pre>
Salviamo e sulla sinistra sotto SSH TARGET dovrebbe comparire la nostra configurazione. Se facciamo click slla icona con la cartellina sulla riga della nostra configurazione vscode dovrebbe aprire un'altra finestra con la connessione al nostro RPI.

Nella nuova finestra, nella parte bassa a sinistra si dovrebbe vedere lo stato della connessione, alla fine dovrebbe comparire &quot;SSH: RaspberryPI&quot; che indica che la connessione è andata a buon file.

Ora sulla nuova finestra facciamo click sulla incona in alto a sinistra con la icona con i due fogli che permette di aprire una cartella. Compare la sessione &quot;Open Folder&quot; che permette di scegliere la cartella e noi scegliamo /home/pi.

== Debug remoto di applicazioni Python ==

Finalmente siamo pronti!

=== Configurazione RPI ===

Andiamo della finestra di ssh con:

<pre>ssh pi@192.168.1.25</pre>
e prepariamo un po' di cose per python. Purtroppo non sono riuscito a fare il debug con un virtualenv nella macchina remota, percio installeremo tutte le cose ce servono per python nella cartella utente di pi. Di solito questo può andare bene, perché probabilmente non si faranno girare molte applicazione nel nostro RPI.

Quindi digitiamo:

<pre>python3 -m pip install -U pip --user
python3 -m pip install flask --user
mkdir ~/python
touch ~/python/hello.py
touch ~/python/flaskapp.py
mkdir ~/.vscode</pre>
Per il nostro test, proveremo uno script semplice python ed un &quot;Hello World!&quot; con il server web Flask. Per ora i files sono vuoti, ma poi potremo inserire i nostri sorgenti.

Io non conosco niente di sensori ed elettronica perciò faccio un applicativo web che mi permette di testare un po' di cose, ma chi si interessa di elettronica potrà fare applicativi specifici usando le molte librerie e la molta documentazione che si trova. E se desidera visto che c'è può approntare una interfaccia web.

Ora per risparmiare tempo prepariamo già i files di configurazione per vscode che funzionano in modo corretto:

<pre>nano ~/.vscode/launch.json</pre>
e scriviamo il testo:

<pre>{
    &quot;version&quot;: &quot;0.2.0&quot;,
    &quot;configurations&quot;: [
        {
            &quot;name&quot;: &quot;Python: Current Falsk&quot;,
            &quot;type&quot;: &quot;python&quot;,
            &quot;request&quot;: &quot;launch&quot;,
            &quot;module&quot;: &quot;flask&quot;,
            &quot;cwd&quot;: &quot;${fileDirname}&quot;,
            &quot;env&quot;: {
                &quot;FLASK_APP&quot;: &quot;${file}&quot;,
                &quot;FLASK_ENV&quot;: &quot;development&quot;,
                &quot;FLASK_SETTINGS&quot;: &quot;settings.cfg&quot;
            },
            &quot;args&quot;: [
                &quot;run&quot;,
                &quot;--no-debugger&quot;,
                &quot;--no-reload&quot;,
                &quot;--host=0.0.0.0&quot;,
                &quot;--port=5050&quot;
            ],
            &quot;jinja&quot;: true
        },
        {
            &quot;name&quot;: &quot;Python: Current File&quot;,
            &quot;type&quot;: &quot;python&quot;,
            &quot;request&quot;: &quot;launch&quot;,
            &quot;program&quot;: &quot;${file}&quot;,
            &quot;console&quot;: &quot;integratedTerminal&quot;
        }
    ]
}</pre>
Questa configurazione prepara un ambiente flask funzionante, con due particolarità. il parametro &quot;--host=0.0.0.0&quot; consente di accedere al server flask da qualsiasi indirizzo IP ed il parametro &quot;--port=5050&quot; cambia la porta di default del server web che di solito in flask è 5000, naturalmente si può cambiare con qualsiasi porta comresa la porta 80 che è quella di default per il web.

poi con

<pre>nano ~/.vscode/settings.json</pre>
scriviamo il testo:

<pre>{
    &quot;python.pythonPath&quot;: &quot;/usr/bin/python3&quot;
}</pre>
Che istruisce vscode che desideriamo utiizzare l'interprete python3

=== Avvio del debugger vscode ===

In vscode nella nostra pagina con la configurazione remota, dobbiamo installare in remoto l'estensione di Python, come al solito premiamo Ctrl+Shift+X ed installiamo l'estensione, ci mette un po' di tempo, alla fine ricarichiamo la pagina e siamo pronti.

Facciamo click sul nostro file <code>~/python/flaskapp.py</code> ed il sistema riconosce che si tratta di un file python, ci chiede di installare un po' di cose e forse va in errore su qualcosa, ma dovrebbe funzionare ugualmente.

Il testo da scrivere è:

<pre>from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return '&lt;h1&gt;Hello, World!&lt;/h1&gt;'</pre>
Mentre invece nel file file <code>~/python/hello.py</code> scriviamo il nostro solito:

<pre>import sys

print(sys.path)</pre>
Abbiamo quasi finito, non resta che avviare il debugger. Come abbiamo fatto in precedenza per fare il test locale premiamo Ctrl+Shift+X per avviare il debugger, forse in questo momento vscode installerà ancora qualcosa nel RPI remoto.

Fortunatamente avevamo già preparato la configurazione per il debugger e quindi scegliamo il file <code>~/python/hello.py</code> e lanciamo la configurazione di debug di nome &quot;Python: Current File&quot; e nel terminale dovrebbe comparire la lista dei percorsi della path di python.

Infine scegiamo il file <code>~/python/flaskapp.py</code>, avviamo il debugger e scegliamo la configurazione &quot;Python: Current Falsk&quot;.

Se siamo stati bravi (ed anche un po' fortunati) nel terminale dovrebbe comparire qualcosa simile a:

<pre> * Serving Flask app &quot;/home/pi/python/flaskapp.py&quot;
 * Environment: development
 * Debug mode: on
 * Running on http://0.0.0.0:5050/ (Press CTRL+C to quit)</pre>
'''HURRA!!!'''

Abbiamo un server web.

Non ci resta che andare nel nostro browser e nella riga degli indirizzi digirare:

<pre>http://192.168.1.25:5050</pre>
e nella nostra pagina comparirà il mitico

'''Hello, World!'''

== Mettiamolo in produzione ==

Ora avete un sistema efficiente che vi permetterà di risparmiare molto tempo in fase di sviluppo. Ed alla fine riuscirete senzaltro a realizzare il vostro magnifico applicativo.

È giunto perciò il momento di mettere in funzione il nostro RPI per lo scopo a cui è stato destinato. Questo significa che senza alcun intervento da parte dell'operatore, quando si dà l'alimentazione il sistema deve partire ed avviare tutto ciò che serve. Dobbiamo fare due cose.

=== Avvio automatico del server web ===

Nel nostro caso vogliamo che quando accendiamo il RPI parta automaticamente il server web, ma potrebbe essere anche un altro applicativo.

Entriamo nel RPI con ssh

<pre>ssh pi@192.168.1.25</pre>
e per prima cosa scriviamo uno script bash per avviare il nostro server web con il comando:

<pre>nano ~/python/startapp.sh</pre>
e scriviamo il testo:

<pre>#!/bin/bash

cd /home/pi/python

export PYTHONUNBUFFERED=1
export FLASK_APP=flaskapp.py

python3 -m flask run --host=0.0.0.0 --port=5050 &amp;</pre>
da notare il carattere &quot;&amp;&quot; alla fine del comando che fa partire il server, la sua presenza indica al sistema operativo di avviare il programma in background e di terminare lo script.

ora lo dobbiamo renderlo avviabile e lo dobbiamo provare con:

<pre>chmod +x ~/python/startapp.sh
~/python/startapp.sh</pre>
Dovrebbe partire il server web.

Ora dobbiamo fare in modo che il programma parta alla accensione del RPI. Ci sono tanti modi per farlo. Se avete installato RPI con la configurazione di default che fa il login automatico con l'utente 'pi', il sistema più semplice modificare il file <code>/home/pi/.bashrc</code> che verrà avviato automaticamente con il login di 'pi'. Quindi scriviamo:

<pre>nano /home/pi/.bashrc</pre>
ed alla fine del testo aggiungiamo la riga:

<pre>/home/pi/python/startapp.sh 
</pre>
salviamo e facciamo il reboot con:

<pre>sudo reboot</pre>
Il nostro RPI si riavvia ci mette alcuni secondi. Quando il led verde che indica l'attività del disco smette di lampeggiare, possiamo provare a vedere se funziona aprendo il browser e digitando l'indirizzo:

<pre>http://192.168.1.25:5050</pre>
bene, ora il server parte alla accensione del RPI. Se torniamo ad entrare con SSH, alla fine del login comparirà un messaggio d'errore nella cui ultima riga c'è scritto:

<pre>OSError: [Errno 98] Address already in use</pre>
questo è normale, perché all'avvio della macchina il server è già partito e facendo un nuovo login lui tenta di riavviarlo, ma la porta è già impegnata.

Se vogliamo fermare il server possiamo digitare:

<pre>ps -e | grep python3</pre>
che ci comunica il numero di processo che fa girare il server, ad esempio

<pre>  709 tty1     00:00:02 python3</pre>
poi con il comando

<pre>kill 709</pre>
fermiamo lo script e siamo pronti per fare ulteriori modifiche

=== IP statico ===

Ora il nostro server web parte all'avvio del RPI, però l'indirizzo IP della macchina su cui gira è stato assegnato del server DHCP che di solito sta nel nostro router. Normalmente i server DHCP ricordano gli indirizzi assegnati alle periferiche collegate, ma se non usiamo una periferica per un certo periodo, oppure se per qualsiasi motivo la memoria DHCP viene resettata, è molto probabile che il nostro RPI prenda un indirizzo IP diverso, perciò è opportuno assegnargliene uno statico.

Anche in questo caso su internet si trovano molti tutorial che spiegano in dettaglio come fare. Qui noi semplifichiamo un po' indicando solo le fasi essenziali.

I vari modelli di Raspberry PI, possono avere la scheda ethernet per il collegamento via cavo o anche la connessione wifi integrata, quando è possibile è meglio usare la connessione cablata, ma se è complicato tirare i cavi, si può usare anche quella wifi.

prima di tutto configuriamo il wifi. per individuare le reti wifi disponibili possiamo dare il comando:

<pre>sudo iwlist wlan0 scan | grep ESSID</pre>
e possiamo inserire la nostra rete prescelta tra quelle che vengono avviate automaticamente modificando il file:

<pre>sudo nano /etc/wpa_supplicant/wpa_supplicant.conf</pre>
Se non è già stato fatto, configuriamo la rete wifi dando i nostri parametri di configurazione con:

<pre>network={
        ssid=&quot;My WiFi connector&quot;
        psk=&quot;MySuperSecretPassword&quot;
        key_mgmt=WPA-PSK
}</pre>
Questo ci garantisce che alla accensione venga attivata automaticamente la rete WiFi prescelta.

Non ho provato, ma è molto probabile che se configuro più di un <code>network</code> vengano provati in sequenza e venga avviato il primo che fornisce la connessione.

Ora riavviamo il RPI

<pre>sudo reboot</pre>
Aspettiamo, rientriamo con SSH ed è giunto il momento di rendere statici i nostri indirizzi IP.

Se scriviamo:

<pre>ip r</pre>
otteniamo la lista delle connessioni attive. Dovremmo vedere qualcosa del tipo:

<pre>default via 192.168.1.1 dev eth0 src 192.168.1.25 metric 202 
default via 192.168.1.1 dev wlan0 proto dhcp src 192.168.1.97 metric 303 
192.168.1.0/24 dev eth0 proto dhcp scope link src 192.168.1.25 metric 202 
192.168.1.0/24 dev wlan0 proto dhcp scope link src 192.168.1.97 metric 303 </pre>
questo ci indica che la nostra rete cablata eth0 risponde all'indirizzo 192.168.1.25 e la rete wifi wlan0 risponde all'indirizzo 192.168.1.97, possiamo rendere statici entrambe le connessioni oppure solo una mdoficicando il file:

<pre>sudo nano /etc/resolv.conf</pre>
Alla fine del file aggiungiamo queste righe:

<pre># Static IP cable
interface eth0
static ip_address=192.168.1.25/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1 8.8.8.8

# Static IP wifi
interface wlan0
static ip_address=192.168.1.97
static routers=192.168.1.1
static domain_name_servers=192.168.1.1 8.8.8.8</pre>
D'ora in poi ogni volta che riavviamo il nostro RPI, verrà avviato il server web all'indirizzo <code>http://192.168.1.25:5050</code> semplicemente collegando il cavo di alimentazione.

== Conclusione ==

In questo tutorial abbiamo toccato molti argomenti, ognuno dei quali meriterebbe una trattazione molto più approfondita. Ma dovendo portare a termine il risultato abbiamo dovuto per forza essere un po' sbrigativi.

Vi invito percò ad approfondire tutti gli argomenti facendo ricerce specifiche su internet, così come ho fatto io per scrivere il tutorial e renderlo funzionante.

Mi chiamo Claudio Driussi, mi occupo da molti anni di sviluppo di software gestionale e di integrazione di sistemi.

Per commenti e suggerimenti mi potete mandare una mail a claudio.driussi@gmail.com