Installare Apache, PHP, MySQL sul Raspberry PI

Come installare il server Java Wildfly
sul Raspberry PI
In questo articolo vedremo come installare sul Raspberry PI il server Java
Wildfly, un ottimo strumento per aumentare le funzionalità del nostro PC.
Nello scorso articolo abbiamo spiegato come installare sul piccolo PC il
server Apache con PHP, con i quali è possibile sviluppare progetti che
richiedono l’invio di dati tra diversi nodi e il salvataggio di tali
informazioni all’interno di un DB MySQL. Wildfly è “concorrente” di di PHP,
in quanto è una tecnologia lato server, con la quale è possibile trasformare
il Raspberry PI in un dispositivo in grado di ricevere ed effettuare
richieste, salvare dati etc…
Grazie all’utilizzo di strumenti come Hibernate, JSON etc… sarà davvero
semplice gestire grosse quantità di informazioni.
Rispetto al PHP, il server Wildfly è uno strumento più potente che richiede
più risorse, in quanto dietro c’è sempre la Java Virtual Machine, mentre la
prima tecnologia è spesso impiegata all’inizio di un progetto, in quanto
richiede poco tempo sviluppare un prototipo.
Giusto per descrivere correttamente Widfly, ecco la definizione tratta da
Wikipedia:
WildFly, precedentemente noto come JBoss AS o semplicemente JBoss, è un
application server open source che implementa le specifiche Java EE. WildFly
è un sistema multipiattaforma, interamente realizzato in Java.
Il sistema è stato originariamente creato dalla società “JBoss Inc.“; nel
2006 è stato acquistato da Red Hat per 420 milioni di dollari. Viene gestito
come progetto open source ed è sostenuto da una enorme rete di sviluppatori.
A WildFly sono associati una quantità di altri prodotti, incluso Hibernate,
Tomcat, JBoss ESB, jBPM, JBoss Rules (ex Drools), JBoss Cache, JGroups, JBoss
Portal, SEAM, JBoss Transaction, e JBoss Messaging.
Nei prossimi articoli, verranno mostrati un po’ di progetti basati sulla
tecnologia Wildfly, che metteranno in luce le enormi funzionalità di questo
strumento. Uno tra tutti è la creazione di un server con REST API, pattern
ormai famosissimo nel mondo dell’informatica.
Installazione
L’installazione del server Wildfly è un’operazione non semplicissima, che
però verrà semplificata grazie all’utilizzo di un script, in quanto sarebbe
richiesti diversi comandi, da inviare attraverso il terminale. Inoltre,
grazie a questo script, Wildfly verrà impostato come servizio e questo
significa che partirà all’invio del sistema operativo, proprio come Apache.
Il primo passaggio è quello di caricare sul Raspberry PI questo script:
#!/bin/bash
#title
#description
#more
#author
#date
#usage
#tested-version
#tested-distros
:wildfly-install.sh
:The script to install Wildfly 10.x
:http://sukharevd.net/wildfly-8-installation.html
:Dmitriy Sukharev
:2015-10-24T17:14-0700
:/bin/bash wildfly-install.sh
:10.0.0.CR3
:Debian 7,8; Ubuntu 15.10; CentOS 7; Fedora 22
WILDFLY_VERSION=10.0.4.Final
WILDFLY_FILENAME=wildfly-$WILDFLY_VERSION
WILDFLY_ARCHIVE_NAME=$WILDFLY_FILENAME.tar.gz
WILDFLY_DOWNLOAD_ADDRESS=http://download.jboss.org/wildfly/$WILDFLY_VERSION/$
WILDFLY_ARCHIVE_NAME
INSTALL_DIR=/opt
WILDFLY_FULL_DIR=$INSTALL_DIR/$WILDFLY_FILENAME
WILDFLY_DIR=$INSTALL_DIR/wildfly
WILDFLY_USER="wildfly"
WILDFLY_SERVICE="wildfly"
WILDFLY_MODE="standalone"
WILDFLY_STARTUP_TIMEOUT=240
WILDFLY_SHUTDOWN_TIMEOUT=30
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
if [[ $EUID -ne 0 ]]; then
echo "This script must be run as root."
exit 1
fi
echo "Downloading: $WILDFLY_DOWNLOAD_ADDRESS..."
[ -e "$WILDFLY_ARCHIVE_NAME" ] && echo 'Wildfly archive already exists.'
if [ ! -e "$WILDFLY_ARCHIVE_NAME" ]; then
wget -q $WILDFLY_DOWNLOAD_ADDRESS
if [ $? -ne 0 ]; then
echo "Not possible to download Wildfly."
exit 1
fi
fi
echo "Cleaning up..."
rm -f "$WILDFLY_DIR"
rm -rf "$WILDFLY_FULL_DIR"
rm -rf "/var/run/$WILDFLY_SERVICE/"
rm -f "/etc/init.d/$WILDFLY_SERVICE"
echo "Installation..."
mkdir $WILDFLY_FULL_DIR
tar -xzf $WILDFLY_ARCHIVE_NAME -C $INSTALL_DIR
ln -s $WILDFLY_FULL_DIR/ $WILDFLY_DIR
useradd -s /sbin/nologin $WILDFLY_USER
chown -R $WILDFLY_USER:$WILDFLY_USER $WILDFLY_DIR
chown -R $WILDFLY_USER:$WILDFLY_USER $WILDFLY_DIR/
#mkdir -p /var/log/$WILDFLY_SERVICE
echo "Registrating Wildfly as service..."
# if should use systemd
if [ -x /bin/systemctl ]; then
# Script from $WILDFLY_DIR/docs/contrib/scripts/systemd/launch.sh didn't
work for me
cat > $WILDFLY_DIR/bin/launch.sh << "EOF"
#!/bin/sh
if [ "x$WILDFLY_HOME" = "x" ]; then
WILDFLY_HOME="/opt/wildfly"
fi
if [ "x$1" = "xdomain" ]; then
echo 'Starting Wildfly in domain mode.'
$WILDFLY_HOME/bin/domain.sh -c $2 -b $3
#>> /var/log/$WILDFLY_SERVICE/server-`date +%Y-%m-%d`.log
else
echo 'Starting Wildfly in standalone mode.'
$WILDFLY_HOME/bin/standalone.sh -c $2 -b $3
#>> /var/log/$WILDFLY_SERVICE/server-`date +%Y-%m-%d`.log
fi
EOF
# $WILDFLY_HOME is not visible here
sed -i -e 's,WILDFLY_HOME=.*,WILDFLY_HOME='$WILDFLY_DIR',g'
$WILDFLY_DIR/bin/launch.sh
#sed -i -e 's,$WILDFLY_SERVICE,'$WILDFLY_SERVICE',g'
$WILDFLY_DIR/bin/launch.sh
chmod +x $WILDFLY_DIR/bin/launch.sh
cp $WILDFLY_DIR/docs/contrib/scripts/systemd/wildfly.service
/etc/systemd/system/$WILDFLY_SERVICE.service
WILDFLY_SERVICE_CONF=/etc/default/$WILDFLY_SERVICE
# To install multiple instances of Wildfly replace all hardcoding in
systemd file
sed -i -e
's,EnvironmentFile=.*,EnvironmentFile='$WILDFLY_SERVICE_CONF',g'
/etc/systemd/system/$WILDFLY_SERVICE.service
sed -i -e 's,User=.*,User='$WILDFLY_USER',g'
/etc/systemd/system/$WILDFLY_SERVICE.service
sed -i -e
's,PIDFile=.*,PIDFile=/var/run/wildfly/'$WILDFLY_SERVICE'.pid,g'
/etc/systemd/system/$WILDFLY_SERVICE.service
sed -i -e 's,ExecStart=.*,ExecStart='$WILDFLY_DIR'/bin/launch.sh
$WILDFLY_MODE $WILDFLY_CONFIG $WILDFLY_BIND,g'
/etc/systemd/system/$WILDFLY_SERVICE.service
systemctl daemon-reload
#systemctl enable $WILDFLY_SERVICE.service
fi
# if non-systemd Debian-like distribution
if [ ! -x /bin/systemctl -a -r /lib/lsb/init-functions ]; then
cp $WILDFLY_DIR/docs/contrib/scripts/init.d/wildfly-init-debian.sh
/etc/init.d/$WILDFLY_SERVICE
sed -i -e 's,NAME=wildfly,NAME='$WILDFLY_SERVICE',g'
/etc/init.d/$WILDFLY_SERVICE
WILDFLY_SERVICE_CONF=/etc/default/$WILDFLY_SERVICE
fi
# if non-systemd RHEL-like distribution
if [ ! -x /bin/systemctl -a -r /etc/init.d/functions ]; then
cp $WILDFLY_DIR/docs/contrib/scripts/init.d/wildfly-init-redhat.sh
/etc/init.d/$WILDFLY_SERVICE
WILDFLY_SERVICE_CONF=/etc/default/wildfly.conf
chmod 755 /etc/init.d/$WILDFLY_SERVICE
fi
# if neither Debian nor RHEL like distribution
if [ ! -x /bin/systemctl -a ! -r /lib/lsb/init-functions -a ! -r
/etc/init.d/functions ]; then
cat > /etc/init.d/$WILDFLY_SERVICE << "EOF"
#!/bin/sh
### BEGIN INIT INFO
# Provides:
${WILDFLY_SERVICE}
# Required-Start:
$local_fs $remote_fs $network $syslog
# Required-Stop:
$local_fs $remote_fs $network $syslog
# Default-Start:
2 3 4 5
# Default-Stop:
0 1 6
# Short-Description: Start/Stop ${WILDFLY_FILENAME}
### END INIT INFO
WILDFLY_USER=${WILDFLY_USER}
WILDFLY_DIR=${WILDFLY_DIR}
case "$1" in
start)
echo "Starting ${WILDFLY_FILENAME}..."
start-stop-daemon --start --background --chuid $WILDFLY_USER --exec
$WILDFLY_DIR/bin/standalone.sh
exit $?
;;
stop)
echo "Stopping ${WILDFLY_FILENAME}..."
start-stop-daemon --start --quiet --background --chuid $WILDFLY_USER --exec
$WILDFLY_DIR/bin/jboss-cli.sh -- --connect command=:shutdown
exit $?
;;
log)
echo "Showing server.log..."
tail -500f $WILDFLY_DIR/standalone/log/server.log
;;
*)
echo "Usage: /etc/init.d/wildfly {start|stop}"
exit 1
;;
esac
exit 0
EOF
sed -i -e 's,${WILDFLY_USER},'$WILDFLY_USER',g;
s,${WILDFLY_FILENAME},'$WILDFLY_FILENAME',g;
s,${WILDFLY_SERVICE},'$WILDFLY_SERVICE',g; s,${WILDFLY_DIR},'$WILDFLY_DIR',g'
/etc/init.d/$WILDFLY_SERVICE
chmod 755 /etc/init.d/$WILDFLY_SERVICE
fi
if [ ! -z "$WILDFLY_SERVICE_CONF" ]; then
echo "Configuring service..."
echo JBOSS_HOME=\"$WILDFLY_DIR\" > $WILDFLY_SERVICE_CONF
echo JBOSS_USER=$WILDFLY_USER >> $WILDFLY_SERVICE_CONF
echo WILDFLY_HOME=\"$WILDFLY_DIR\" > $WILDFLY_SERVICE_CONF
echo WILDFLY_USER=\"$WILDFLY_USER\" > $WILDFLY_SERVICE_CONF
echo STARTUP_WAIT=$WILDFLY_STARTUP_TIMEOUT >> $WILDFLY_SERVICE_CONF
echo SHUTDOWN_WAIT=$WILDFLY_SHUTDOWN_TIMEOUT >> $WILDFLY_SERVICE_CONF
echo WILDFLY_CONFIG=$WILDFLY_MODE.xml >> $WILDFLY_SERVICE_CONF
echo WILDFLY_MODE=$WILDFLY_MODE >> $WILDFLY_SERVICE_CONF
echo WILDFLY_BIND=0.0.0.0 >> $WILDFLY_SERVICE_CONF
fi
echo "Configuring application server..."
sed -i -e 's,<deployment-scanner path="deployments" relativeto="jboss.server.base.dir" scan-interval="5000",<deployment-scanner
path="deployments" relative-to="jboss.server.base.dir" scan-interval="5000"
deployment-timeout="'$WILDFLY_STARTUP_TIMEOUT'",g'
$WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<inet-address value="${jboss.bind.address:127.0.0.1}"/>,<anyaddress/>,g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="ajp"
port="${jboss.ajp.port:8009}"/>,<socket-binding name="ajp"
port="${jboss.ajp.port:28009}"/>,g'
$WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="http"
port="${jboss.http.port:8080}"/>,<socket-binding name="http"
port="${jboss.http.port:28080}"/>,g'
$WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="https"
port="${jboss.https.port:8443}"/>,<socket-binding name="https"
port="${jboss.https.port:28443}"/>,g'
$WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
sed -i -e 's,<socket-binding name="osgi-http" interface="management"
port="8090"/>,<socket-binding name="osgi-http" interface="management"
port="28090"/>,g' $WILDFLY_DIR/$WILDFLY_MODE/configuration/$WILDFLY_MODE.xml
[ -x /bin/systemctl ] && systemctl start $WILDFLY_SERVICE || service
$WILDFLY_SERVICE start
echo "Done."
Una volta completata tale operazione, apriamo il terminale e ci spostiamo
nella cartella dove è stato caricato tale file, che è stato chiamato wildflyinstall.sh. Successivamente digitiamo:
bash wildfly-install.sh
L’operazione richiederà qualche minuto, in quanto verranno scaricate diversi
pacchetti dalla rete.
Una volta completata la proceduta d’installazione, per verificare se tutto è
stato installato correttamente digitiamo i seguenti comandi:
sudo systemctl enable wildfly
sudo systemctl status wildfly
Se tutto è andato bene, dovremmo ottenere una risposta del genere:
Qualora ci fosse qualche scritta in rossa, che è dovuto ad un problema
esistente con la versione di Java; per poter sistemare tale situazione
dovremmo procedere nel seguente modo. Apriamo il terminale e digitiamo il
seguente comando, che permette di aprire un file di configurazione:
nano /opt/wildfly/bin/standalone.sh
Una volta inviato tale comando, comparirà una schermata simile alla seguente:
Per poter sistemare il problema è necessario cancellare le seguenti due
righe, presente in tale file:
else
PREPEND_JAVA_OPTS=“$PREPEND_JAVA_OPTS -server”
Ora premiamo CTRL+X e successivamente Y, per confermare le modifiche e
salvarle.
Ora digitando i seguenti i comandi da terminale, dovremmo aver risolto il
problema relativo alla Java Virtual Machine:
sudo systemctl enable wildfly
sudo systemctl status wildfly
Ora rimangono ancora due operazioni da fare, che permettono di poter
utilizzare correttamente il server Wildfly; la prima operazione è quella di
autorizzare altri PC a collegarsi alla pagina di controllo, poter gestire
correttamente il server e la seconda riguarda la creazione di credenziali
d’accesso al server.
Accesso da esterno alla pagina di controllo
Per poter autorizzare PC ad accedere alla pagina di controllo da remoto, è
necessario modificare il file standalone.xml, che si trova nella cartella
/opt/wildfly/standalone/configuration/ ; tale file è molto importante, in
quanto contiene diverse impostazioni che permettono al server di girare
correttamente sul Raspberry PI. Quindi apriamo il terminale e digitiamo il
seguente comando:
sudo nano /opt/wildfly/standalone/configuration/standalone.xml
Le righe da modificar sono:
<interfaces>
<interface name="management">
<loopback-address value="${env.OPENSHIFT_WILDFLY_IP}"/>
</interface>
<interface name="public">
<any-address/>
</interface>
che diventano:
<interfaces>
<interface name="management">
<any-address/>
</interface>
<interface name="public">
<any-address/>
</interface>
</interfaces>
Aggiunta utente
L’ultimo passaggio è la creazione delle credenziali d’accesso per poter
accedere alla pagina di controllo del server Wildfly. Esiste uno script molto
semplice e guidato, che permette di effettuare tale operazione. Per avviare
la procedura è necessario digitare da terminale:
sudo bash /opt/wildfly/bin/add-user.sh
La procedura è guidata, sarà necessario inserire il nome utente, la password
e altre informazioni riguardo al tipo di account.
Ora che abbiamo completato questa procedura, riavviamo il nostro Raspberry PI
e apriamo il browser da remoto, digitando l’indirizzo IP del dispositivo e
come porta la 9990:
http://$IP_RASPBERRY:9990
Conclusione
L’installazione richiede diverse procedura che permettono di aver un server
completamente funzionante anche da remoto. Wildfly è uno strumento molto
potente, che permette di sfruttare al massimo le funzionalità di JavaEE per
lo sviluppo di progetti non sono IoT. Nei prossimi articoli vedremo un po’
d’esempi di utilizzo di tale tecnologia.
Installare Apache, PHP, MySQL sul
Raspberry PI Zero
In questo articolo vedremo come installare sul Raspberry PI Zero i principali
programmi che vengono usati nei progetti domotici e non solo. Ecco la lista
dei software:
Apache
PHP
MySQL
Raspberry PI Zero
A differenza di altri micro-controllori come Arduino, Photon, ESP8266 etc…,
il Raspberry PI Zero permette l’esecuzione di un sistema operativo Linux, il
quale apre le porte alla possibilità di installare software molti utili, come
i 3 che sono stati citati in precedenza. In questo modo è possibile
trasformare il piccolo PC da 4£ in un vero e proprio web server, con il quale
inviare e ricevere dati, che a loro volta possono essere salvati in modo
persistente all’interno di un database MySQL.
Passi preliminari
Come detto in precedenza, il Raspberry PI Zero è in grado di supportare un
sistema operativo Linux come Raspbian. Per questo motivo, è necessario
installare su tale dispositivo un versione del OS. Dal momento che è la
stessa versione del sistema operativo che gira sulla versione 3, possiamo
seguire la medesima guida che è presente sul mio blog.
In alternativa, esistono le pagine ufficiali che spiegano le procedure
dettagliate, per poter installare sul proprio Raspberry PI Zero il sistema
operativo Raspbian su una micro-SD.
Guida ufficiale
Installazione Apache
Apache un software scritto in C, che permette di trasformare il Raspberry PI
Zero in un vero e proprio webserver, in grado quindi di ricevere ed elaborare
richieste HTTP(s), per poter mostrare pagine web, ad esempio una pagina html.
Uno dei rivali di Apache è NGIX; entrambi sono software gratuiti le loro
differenze riguardano le performance per diversi tipi di siti web.
Tipicamente NGIX risulta essere più veloce a caricare pagine dinamiche, (ad
esempio un blog WordPress), mentre Apache è più performante con pagine web
statiche.
Vediamo quali passaggi dobbiamo effettuare per poter installare Apache sul
nostro Raspberry PI Zero.
Apriamo il terminale del nostro PC e digitiamo il seguente comando:
sudo apt-get install apache2 -y
Una volta premuto invio, il nostro dispositivo incomincerà a scaricare un po’
di pacchetti utili all’installazione, che richiederà qualche decina di
secondi. Una volta completata, per verificare che funzioni tutti
correttamente, basterà aprire il browser e digitare sulla barra degli
indirizzi http://127.0.0.0.1. Se l’installazione è stata completata
correttamente, comparirà una pagina web simile a questa:
Ora potremo caricarci i nostri file html all’interno della cartella
/var/www/. Ovviamente sono disponibile tantissime configurazioni, che
permettono di gestire diversi siti web contemporaneamente, cambiare la porta
d’utilizzo e introdurre il protocollo SSL.
Installazione PHP
PHP è un linguaggio di programmazione lato server, che permette di introdurre
una logica per la gestione di dati, che vengono inviati al server. Ad esempio
possiamo validare l’invio di un form di registrazione e gestire i vari casi.
Inoltre PHP è un linguaggio di programmazione che permette facilmente di
poter leggere e scrivere dati all’interno di un database MySQL. Sicuramente
PHP è un linguaggio non recentissimo, che però permette di creare in poco
tempo buoni infrastrutture server; basti pensare che Facebook all’inizio era
scritto in PHP. La versione più recente è la 7, ma nella repo ufficiale del
Raspberry PI è presente ancora la versione 5.6, che ormai è molto stabile e
consolidata. Occorre notare che PHP è molto severo nei metodi deprecati e
quando ci sono nuovi aggiornamenti, è possibile che del codice che prima
funzionava, adesso non funzioni più Per questo motivo, prima di effettuare
qualsiasi aggiornamento, è sempre meglio verificare la lista dei metodi che
non sono più validi.
Ora vediamo come installare PHP sul nostro Raspberry PI zero.
Il primo passaggio è quello di aprire il terminale e digitare il seguente
comando:
sudo apt-get install libapache2-mod-php5 php5 php-pear php5-xcache php5-mysql
php5-curl php5-gd
Se ci dovessero essere dei problemi, molto probabilmente è dovuto al fatto
che mancano dei pacchetti aggiornati del sistema operativo. In questo caso
sarà necessario inviare i seguenti comandi:
sudo apt-get update
e successivamente:
sudo apt-get upgrade
Per verificare che tutto funzioni correttamente, è necessario creare un
piccolo file PHP di nome info.php, all’interno della cartella Apache, come il
seguente:
<?php phpinfo(); ?>
Occorre ricordare che per poter accedere alla cartella di Apache è necessario
accedere con i privilegi da root. Ora che abbiamo caricato la pagina PHP,
possiamo testare il funzionamento aprendo il browser e digitando nella barra
degli indirizzi:
http://127.0.0.1/info.php
Se tutto funziona correttamente, dovremo vedere una pagina web simile alla
seguente:
Installare MySQL
L’ultimo programma molto utile che verrà descritto in questo articolo è
MySQL. Tale software è molto utile per quanto riguarda il salvataggio dei
dati, che vengono generati a run-time dai nostri programmi/sensori collegati
al nostro Raspberry PI. Per poter leggere e scrivere successivamente tali
dati, sarà necessario effettuare delle query, che utilizzano il linguaggio
SQL. Tale linguaggio non è complicato e sul web è possibile trovare tante
guide e tanti esempi a riguardo. Un tutorial molto utile/interessante è il
seguente.
Per poter utilizzare il sistema di persistenza dei dati in un DB è necessario
disporre di un MySQL server e dei driver per potersi collegare a tale
dispositivo. Esiste un client molto utile, che si chiama MySQL Workbench, che
permette di fare manutenzione sul server ed effettuare le query al DB.
Vediamo un po’ come installare il MySQL server. Il primo passaggio è quello
di aprire il terminale e digitare il seguente comando:
sudo apt-get install mysql-server
Una volta premuto y, verrà chiesta la password dell’account root. Per motivi
di sicurezza, si consiglia di crearne una abbastanza robusta, in quanto tale
password permette di dare praticamente di tutto all’interno del DB.
Successivamente comparirà una pagina, in cui dovremmo confermare la password,
che abbiamo digitato in precedenza.
Dopo qualche istante l’installazione del MySQL server dovrebbe essere stata
completata correttamente.
Di default, per motivi di sicurezza, il server non è accessibile da remoto.
Per ovviare a tale limitazione, sebbene riduca il livello di sicurezza,
possiamo modificare il file di configurazione.
Per farlo digitiamo da terminale il seguente comando:
nano /etc/mysql/my.cnf
La riga da modificare è:
bind-address = 127.0.0.1
che diventa:
bind-address = 0.0.0.0
Ora è necessario riavviare il servizio MySQL:
sudo /etc/init.d/mysql restart
Ora dovremmo essere riusciti ad aver installato Apache, PHP e MySQL server
sul nostro Raspberry PI zero.
Per poter acquistare il Raspberry PI zero, oppure il Raspberry PI model B e
tanti altri accessori, potete farlo sul sito http://www.kubii.it/.
Come accedere in SSH con l'account
root al Raspberry PI
Il Raspberry PI è un dispositivo molto versatile, in quanto può essere
utilizzato in diversi ambiti informatici, come ad esempio web server, NAS,
IoT etc…
Grazie alla porta HDMI è possibile collegarlo ad un monitor ed effettuare le
diversi impostazioni necessari. Tuttavia, per comodò d’utilizzo, è
conveniente accedervi da remoto, sfruttando la rete e il protocollo SSH.
In informatica e telecomunicazioni SSH (Secure SHell, shell sicura) è un
protocollo che permette di stabilire una sessione remota cifrata tramite
interfaccia a riga di comando con un altro host di una rete informatica. È il
protocollo che ha sostituito l’analogo, ma insicuro, Telnet. (tratto da
Wikipedia)
Dunque questo protocollo permette di comandare il Raspberry PI da remoto,
sfruttando un semplice programma client come Putty per Windows, oppure il
terminale in ambiente Unix.
La sintassi per poter accedere in ambiente Unix è la seguente:
ssh $user@$ip
Ad esempio:
ssh [email protected]
Successivamente verrà chiesta la password, che nel caso di Raspbian, il
sistema operativo ufficiale per il Raspberry PI è raspberry.
Dal momento che c’è uno scambio di chiave per crittografare i pacchetti
inviati, sarà necessario confermare tale operazione.
Per poter accedere da remoto con l’account root con programmi come Cyberduck,
Winscp etc…, che permettono di trasferire facilmente file, è necessario
effettuare le seguenti operazioni.
La prima consiste nell’impostare la password dell’account root. Per farlo ci
colleghiamo in SSH con l’account PI:
ssh pi@$ip
Successivamente richiediamo di impostare la password:
sudo passwd root
Dove aver premuto invio, dovremmo inserire la nuova password e confermarla.
Ora abbiamo impostato le credenziali d’accesso per l’account root. Tuttavia,
per motivi di sicurezza, di default non è possibile accedere da remoto in
ssh. Per tanto dovremmo effettuare le seguenti operazioni da terminale:
nano /etc/ssh/sshd_config
Una volta premuto invio, comparirà una sorta di editor di testo, nel quale
dovremmo andare a fare la seguente la modifica; le righe da cambiare sono le
seguenti:
Prima
# Authentication:
LoginGraceTime 120
#PermitRootLogin without-password
PermitRootLogin yes
StrictModes yes
Dopo
# Authentication:
LoginGraceTime 120
#PermitRootLogin without-password
PermitRootLogin yes
StrictModes yes
Ora ci basterà riavviare il servizio e potremmo accedere con l’account root
in SSH da remoto:
service sshd restart
Per maggiori informazioni, ecco due link utili: #1, #2.
Unboxing Raspberry PI 3 Model B
In questo articolo vedremo da vicino il nuovo Raspberry PI 3 Model B, il
nuovo prodotto della fondazione Inglese.
Il prodotto è acquistabile sul sito kubii.it al prezzo di 45 Euro nella sua
versione base, oppure è possibile acquistarlo nei vari kit disponibili.
Una volta completato l’ordine, il pacco arriverà a casa in pochi giorni con
corriere espresso SDA.
Caratteristiche del Raspberry PI 3
Il nuovo Raspberry PI 3 include diverse migliori; tra tutte spiccano i moduli
wireless presenti nativamente, come il WiFi e il Bluetooth, oltre che ad un
processore a 64 bit a 1 Gb di RAM. Ecco la lista completa:
A 1.2GHz 64-bit quad-core ARMv8 CPU
802.11n Wireless LAN
Bluetooth 4.1
Bluetooth Low Energy (BLE)
1GB RAM
4 USB ports
40 GPIO pins
Full HDMI port
Ethernet port
Combined 3.5mm audio jack and composite video
Camera interface (CSI)
Display interface (DSI)
Micro SD card slot (now push-pull rather than push-push)
VideoCore IV 3D graphics core
Il nuovo modello diventa sempre più potente, ma le sue dimensioni rimangono
uguali e per tanto sarà possibile usare lo stesso case della versione 2.
Cosa serve per usarlo?
Sul piccolo PC Linux è disponibile uno slot per Micro SD, dove potremmo
inserire la nostra scheda di memoria, dove verrà installato il sistema
operativo e tutti i dati. Per un corretto utilizzo consiglio di usare una
scheda da 16 GB, in modo da poter installare programmi aggiuntivi, senza aver
problemi di memoria.
L’installazione è davvero semplice, in quanto basta scaricare dal sito
ufficiale l’auto-installare NOOBS da questo link e copiare il contenuto della
file .zip, nella memoria Micro SD, che è stata precedentemente formattata.
Ecco il video che mostra l’installazione in modo dettagliato:
Per le istruzioni testuali ufficiali, è possibile trovarle facilmente in
questo pagina web.
Cosa posso fare con il Raspberry PI 3?
Il piccolo PC Linux low cost da 35$, permette di utilizzarlo in diversi
ambiti.
Web Server
Ad esempio possiamo trasformarlo in un Webserver, grazie all’utilizzo di
Apache oppure NGINX. In questo modo potremmo caricarci sopra il proprio sito
web personale, oppure servizi locali.
Cloud storage
Un altro interessante utilizzo è quello del cloud storage. Infatti,
attraverso software open source come ownCloud possiamo crearci un servizio
simili a Dropbox, accessibile anche da remoto, attraverso le applicazioni
disponibili.
Media Center
Per quanto riguarda l’intrattenimento domestico, attraverso file
multimediali, come audio, video, foto etc.., il Raspberry PI è un ottimo
alleato. Infatti esiste una sistema operativo appositamente creato per
questo: il suo nome è XBMC. Esiste una nuova del sistema operativo, che
prende il nome di Kodi.
PC da casa
Grazie al sistema operativo Linux Raspbian, è possibile installare i
principali software, che permettono di trasformare il Raspberry PI in un
verso e proprio PC da casa. Sarà possibile realizzare e stampare documento,
navigare nel web, inviare messaggi di posta elettronica e tanto altro. Le
performance non saranno quelle di un supercomputer, ma per operazioni
domestiche, va più che bene.
Progetti di domotica
Il Raspberry PI dispone di un GPIO, con il quale è possibile interfacciarsi
con dispositivi hardware, come ad esempio relè, sensori di temperatura etc…
In questo modo sarà possibile realizzare diversi progetti IoT, come ad
esempio controllare il garage di casa proprio da smartphone. Interessante
vero?
Conclusioni
Il Raspberry Pi 3 è un diventato ormai un PC molto popolare grazie al suo
prezzo davvero ridotto, che però non impatta sulle prestazioni del
dispositivo.
Con questo piccolo PC Linux è possibile fare praticamente di tutto; dal Media
center di casa, al piccolo server di un’azienda.
Insomma per chi vuole divertirsi in tantissimi progetti IoT, sicuramente con
il Raspberry PI 3 troverà un buon amico!
Ecco il nuovo Raspberry PI 3, ancora
più potente
La scorsa settimana è stato lanciata sul mercato la terza versione del
Raspberry PI, il famoso PC low-cost tanto amato dagli smanettoni di tutto il
mondo.
Ecco i nuovi componenti hardware del Raspberry PI 3:
A 1.2GHz 64-bit quad-core ARMv8 CPU
802.11n Wireless LAN
Bluetooth 4.1
Bluetooth Low Energy (BLE)
La nuova versione del piccolo PC low-cost introduce un processore più potente
e con un’architettura a 64 bit. Altre caratteristiche davvero importanti e
molto desiderate dagli utenti sono le schede di connettività wireless già
presenti nel dispositivo nativamente; infatti il Raspberry PI 3 dispone di
una scheda WiFI e delle più recenti versioni del bluetooth, che permettono di
potersi connettere ai tantissimi dispositivi IoT che si basano sul BLE.
Le caratteristiche del suo predecessore, sono sempre presenti:
4 USB ports
40 GPIO pins
Full HDMI port
Ethernet port
Combined 3.5mm audio jack and composite video
Camera interface (CSI)
Display interface (DSI)
Micro SD card slot (now push-pull rather than push-push)
VideoCore IV 3D graphics core
Nuovo aggiornamento prezzo aumentato? No. Infatti il Raspberry PI 3 ha lo
stesso costo del suo predecessore, cioè 35 Euro. Tuttavia è doveroso
sottolineare che il costo compendo la sola scheda e quindi è necessario
aggiungere le spese di spedizione ed eventuali case/accessori opzionali, che
tipicamente fanno lievitare il costo fino a 50 Euro. Tuttavia per chi vuole
un piccolo web server per la casa, con funzionalità di media center, NAS
etc…, il Raspberry PI 3 è sempre un ottima scelta.
Come realizzare un server web per
visualizzare i dati di una stazione
meteo
Come realizzare un server web per visualizzare i dati di una
stazione meteo
Grazie all’avvento di Internet, è diventato ormai semplice poter visualizzare
le previsioni meteo e l’attuale situazione meteorologica. Nella rete sono
presenti tanti siti web che permettono di visualizzare tali valori e la
maggior parte di essere risulta essere attendibile e semplice da usare.
Previsioni meteo, tratti dal sito ilmeteo.it
Tuttavia il detto “chi fa da se fa per tre” mi ha portato a realizzare un
servizio web, per trasformare alcuni dispositivi in una stazione meteo
professionale. Alla fine dell’installazione di tutti i componenti sarà
possibile accedere ad una pagina web, nella quale saranno presenti i valori
di temperatura e umidità attuali, giornalieri e alcuni statistiche, come ad
esempio la temperatura massima e minima registrata nei vari giorni.
Requisiti per il progetto
Hardware
2 Arduino UNO
1 x kit di sensori Wireless 433 Mhz
1 x DHT22
2 x Breadboard per installare i dispositivi
Un po’ di cavi flessibili
1 x PC come basi di dati e server (consiglio caldamente di utilizzare un
Raspberry PI, oppure un UDOO)
Software
I miei codici, disponibili nella repo di Github
Queste librerie per Arduino DHT22, MYSQL, VirtualWire, SendData
MySQL Workbench
Tasksel (software che includi ottimi servizi lato server, come
PHPMyAdmin, Apache e tanto altro)
Sommario del progetto
Ora vedremo in dettaglio tutti i componenti che sono utilizzati in questo
progetto.
Come viene letta la temperatura
Uno dei principali componenti per realizzare una qualsiasi stazione meteo è
un trasduttore in grado di leggere la temperatura e l’umidità.
Un trasduttore/sensore non è altro che un dispositivo elettrico in grado di
trasformare una grandezza fisica quale la temperatura, in una grandezza
elettrica, cioè un valore di tensione, oppure di corrente. La grandezza
elettrica, verrà tratta successivamente a seconda che l’uscita del sensore
sia analogica, oppure digitale, cioè una corrispondenza di 0 e 1. Facciamo un
piccolo esempio;
Dati Numero di bit = 10; Vcc = 5 V GND = 0 V
Se il numero di bit è pari a 10, è possibile rappresentare valori che vanno
da 0 a 2^10-1, cioè fino a 1023. Qualora venga letto un valore, per esempio
con Arduino, pari a 512, per calcolare la tensione effettiva che riceve il
microcontrollore, occorre fare il seguente calcolo:
V_IN = 512/1024 * 5 [V] = 2.5 [V]
Se per esempio, il nostro trasduttore è stato modellizzato in modo tale da
fornire un valore di tensione proporzionale alla temperatura, come ad esempio
V_OUT = 0.1* temperatura, se ci sono 25 gradi, l’uscita sarà pari a 0.1*25 =
2.5 V e quindi Arduino avrà un valore in lettura pari proprio a 512.
Ovviamente questo esempio semplifica abbastanza le dinamiche di funzionamento
di un trasduttore per temperature. Tale trattazione non è troppo importante a
fini di realizzare il progetto; serve solo come conoscenza personale.
Come già utilizzato nei progetti precedenti, anche in questo caso verrà
utilizzato un trasduttore di temperatura e umidità molto semplice, quale il
DHT22. Esso è facilmente acquistabile su Ebay, al costo di qualche Euro.
La modellizzazione del dispositivo è già stata fatta e quindi per poterlo
usare all’interno dei nostri codici, è necessario solamente scaricare la
relativa libreria.
Come indicato all’interno della documentazione, per poter leggere un valore
di temperatura corretto è necessario inserire una resistenza da 10 KOhm in
pull up tra l’alimentazione Vcc e il pin di uscita, come riportato il figura.
Come ogni componente presente in un progetto, conviene testare la lettura
della temperatura, attraverso questo semplice codice:
// Programma che permette di leggere la temperatura, attraverso un sensore
#include "DHT.h"
#define DHTPIN 2
// Il pin a cui è collegato il sensore
// Togli il commmento al sensore che vuoi usare
//#define DHTTYPE DHT11
#define DHTTYPE DHT22
// DHT 11
// DHT 22
//#define DHTTYPE DHT21
(AM2302)
// DHT 21 (AM2301)
// Connettere il pin 1 (a sinistra) a +5V
// Connettere il pin 2 del sensore alla porta 2
// Connettere il pin 4 (a destra) del sensore
a GROUND
// Connettere una resistenza da 10K tra il pin 2 (data) e il pin 1 (power)
del sensore
DHT dht(DHTPIN, DHTTYPE);
voidsetup() {
Serial.begin(9600);
Serial.println("DHTxx test!");
dht.begin();
}
voidloop() {
// Legge la temperatura e l'umidità ogni 250 millisecondi!
// Vengono inizializzate le variabili in cui vengono scritti i valori letti
floath = dht.readHumidity();
floatt = dht.readTemperature();
// Controlla se la lettura è andata a buon fine
if(isnan(t) || isnan(h)) {
Serial.println("Failed to read from DHT");
} else{
Serial.print("Humidity: ");
Serial.print(h); // Stampa nel seriale la percentuale dell'umidità
Serial.print(" %t");
Serial.print("Temperature: ");
Serial.print(t); // Stampa nel seriale il valore della temperatura
Serial.println(" *C");
}
}
Come vengono inviati i valori di temperatura e umidità tra i dispositivi
L’altro aspetto sempre legato alla temperatura, è l’invio dei dati tra
l’Arduino che viene collegato all’interno dell’abitazione e quello posto
all’esterno. Il fatto di dover utilizzare due dispositivi, è dovuto al
semplice fatto che tipicamente non si dispone di una prese Ethernet esterna e
una scheda Wireless ha un costo abbastanza elevato. Per questo motivo
conviene utilizzare i due dispositivi e farli comunicare tra di loro
attraverso un kit wireless, che funziona sulla frequenza 433 Mhz. Tali
dispositivi sono già stati trattati in passato e per ulteriori informazioni,
vi invito a guardare questo articolo, presente sul mio blog.
Il collegamento dei PIN dei dispositivi wireless è riportato in figura.
Se abbiamo correttamente collegato tutti i dispositivi, potremmo inviare i
valori di temperatura e umidità tra l’Arduino posto fuori casa e quello che è
presente in casa, nel quale sarà presente una scheda Ethernet Shield, che gli
permetterà di collegarsi ad Internet ed inviare i dati letti.
Il programma da caricare sull’Arduino client è:
#include "DataCoder.h"
#include "VirtualWire.h"
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT22
int transmit_pin = 12;
int led_pin = 13;
int baudRate = 800;
int delayTime = 30000;
DHT dht(DHTPIN, DHTTYPE);
void setup()
{
pinMode(led_pin,OUTPUT);
Serial.begin(9600);
SetupRFDataTxnLink(transmit_pin, baudRate);
dht.begin();
}
void loop()
{
float outArray[2];
float h = dht.readHumidity();
float t = dht.readTemperature();
outArray[0] = t;
outArray[1] = h;
union RFData outDataSeq;
EncodeRFData(outArray, outDataSeq);
TransmitRFData(outDataSeq);
delay(delayTime);
}
In questo codice è possibile modificare il tempo che trascorre tra l’invio di
dati.
Il programma da caricare sull’Arduino server è:
/*
This code allow Arduino to send the value of temperature and humidity to a
DB, everty portion of time, setted by the user.
The data of temperature come from an Arduino via wireless, so one Arduino can
stay outside, and the other
one can stay in the home
Version 1.0
Author Giacomo Bellazzi
Copyright (C) 2014 Giacomo Bellazzi (http://ismanettoneblog.altervista.org/)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <SPI.h>
#include <Ethernet.h>
#include <sha1.h>
#include <mysql.h>
#include <avr/dtostrf.h>
#include <DataCoder.h>
#include <VirtualWire.h>
const int rx_pin = 11; // the Pin of the RX
const int baudRate = 800;
byte mac_addr[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress server_addr(192,168,1,20); // MySQL Server IP
char user[] = "username";
char password[] = "password";
Connector my_conn; // The Connector/Arduino reference
const char INSERT_DATA[] = "INSERT INTO WeatherStation.Data VALUES
(1,%s,%s,CURRENT_DATE,CURRENT_TIME)";
void setup(){
Ethernet.begin(mac_addr);
//Serial.begin(9600); for DEBUG
Serial.println("Connecting...");
SetupRFDataRxnLink(rx_pin, baudRate);
if (my_conn.mysql_connect(server_addr, 3306, user, password)) {
delay(1000);
}
else
Serial.println("Connection failed.");
}
void loop(){
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
union RFData inDataSeq;//To store incoming data
float inArray[2];//To store decoded information
if(RFLinkDataAvailable(buf, &buflen))
{
for(int i =0; i< buflen; i++)
{
inDataSeq.s[i] = buf[i];
}
DecodeRFData(inArray, inDataSeq);
float temperature = inArray[0];
float humidity = inArray[1];
//DEBUG
//Serial.println("Temperature: ");
//Serial.print(temperature);
//Serial.print(" ° Humidity: ");
//Serial.println(humidity);
sendToDB(inArray[0],inArray[1]);
}
}
// This code send the values of the temperature and humidity to the DB
void sendToDB(float temperature,float humidity){
char query[64];
char t[6];
char h[6];
dtostrf(temperature, 1, 2, t);
dtostrf(humidity, 1, 2, h);
sprintf(query, INSERT_DATA, t,h);
my_conn.cmd_query(query);
}
Sarà necessario inserire/modificare i dati, quali IP, username e password
della propria base di dati (vedi pagine successive).
Come vengono salvati i valori registrati
Un aspetto importare in questo progetto è il salvataggio dei dati che vengono
letti dall’Arduino, sfruttando il sensore di temperatura DHT22. Infatti, se
non fosse presente un dispositivo in grado di poter salvare i dati, non
sarebbe possibile recuperare tali valori in futuro.
Per questo motivo, in questo progetto, viene utilizzata come base di dati un
server MySQL. Il motivo di utilizzare questo sistema è che esso è
relativamente facile da usare ed ad installare.
Facciamo una breve introduzione a MySQL; esso un sistema basato sull’Algebra
relazionale, che non è altro che un insieme di regole, che permettono di
mettere in relazione tra di loro dati.
Facciamo un breve esempio; per una persona è normale ipotizzare, come dati,
il suo nome, cognome, codice fiscale, città di nascita. Quindi si potrebbe
rappresentare in questa tabella i dati:
Codice Fiscale
Nome
Cognome
Città di Nascita
ABCDEFG
Paolo
Rossi
Milano
Si potrebbe approssimare, per semplicità, che è possibile creare uno schema
della propria base di dati, sfruttando questa tabella, mantenendo come
attributi, i valori in grassetto. Occorre notare che, per come è stato
realizzato il codice fiscale, esso viene definito una chiave primaria nella
relazione Persona, dal momento che non esistono due persone diverse, con lo
stesso codice fiscale.
Per una trattazione più ampia di MySQL e dell’Algebra relazione, è possibile
leggere il seguente articolo.
Come poter visualizzare i dati salvati ed effettuare richieste
Il passo successivo è quello di creare uno schema corretto per il nostro
progetto. Questa operazione, richiede di tradurre le notazioni riguardo alla
temperatura, in Algebra relazione. Per esempio, quali sono gli attributi
relativi alla misura di una temperatura ? Per esempio potrebbero essere il
valore della temperatura, dell’umidità, l’ora e la data di registrazione. Se
però avessimo più dispositivi, sparsi per esempio in varie città d’Italia,
come possiamo fare ? La soluzione più semplice è quella di usare un ID, che
identifica ogni stazione meteo.
Ricapitolando avremmo questa relazione, che ho chiamata Data, all’interno
dello schema WeatherStation:
ID
Temperature
Humidity
Date
Time
Ogni stazione meteo, ha però altre informazioni, più statiche, come ad
esempio il luogo in cui è installata. Per questo motivo è necessario creare
una seconda relazione, che contiene quelle informazioni.
Per poter creare una base di dati è necessario installare il pacchetto MySQL
server su un PC (meglio su UDOO oppure Raspberry ) e un programma client,
chiamato MySQL Workbench, poter effettuare query ed impostare lo schema della
base di dati.
idDevice
Town
Location
Installazione Tasksel
Spesso si pensa che dover installare programmi specifici su piattaforme Linux
sia difficile; in realtà non c’è cosa più semplice !!! Infatti per poter
installare il server MySQL, il server Apache server lanciare da terminare, la
seguente linea di comando:
sudo apt-get install tasksel
Ora basterà seguire l’installazione guidata, premendo invio quando richiesto.
L’installazione completa è quella del Lamp server, che consiglio di fare. Per
trovare la procedura di installazione completa, basta dare un’occhiata alla
pagina ufficiale di UDOO
http://www.udoo.org/ProjectsAndTutorials/udoo-web-server/
Una volta completa la procedura, è necessario installare il client di MySQL;
esso è disponibile nelle principali piattaforme ed è possibile scaricarle dal
seguente link http://www.mysql.it/products/workbench/
Realizzazione basi di dati
Come discusso in precedenza, per salvare i dati è necessario/conveniente
usare un DB MySQL. Nel passo precedente è stato installato il server MySQL,
sfruttando l’installazione automatica con tasksel. Durante tale installazione
è stata impostata una password di root per gestire il DB.
Per poter accedere anche da remoto al server, è necessario effettuare una
piccola modifica al file /etc/mysql/my.cnf, in particolare alla riga relativa
a bind-address:
bind-address = 0.0.0.0
In questo modo sarà possibile accedere alla base di dati anche da remoto,
effettuando il port-forwarding delle porta 3306 sul proprio router.
Per creare lo schema della stazione meteo, come indicato precedente, occorre
selezionare la voce
“Create new schema” e chiamarlo con il nome WeatherStation. Da qui sarà
necessario creare due tabelle, una con il nome Data e una chiamata Device. La
prima e la seconda dovranno avere i seguente attributi, con i relativi tipi:
Ora che abbiamo creato il nostro schema, è possibile effettuare alcune query,
che non sono altro che interrogazioni, per visualizzare certi valori, come ad
esempio il valore massimo e minimo di temperatura in un certa giornata, i
valori di temperatura in certe ore etc…
Ecco alcuni esempi utili:
Ultimo aggiornamento
Select *
From Data
WHERE Hour(Time)=HOUR(Current_TIME) && Minute(Time)=MINUTE(Current_Time)-1
Dati della giornata
Select *
From WeatherStation.Data
Where Date = CURRENT_DATE && Minute(WeatherStation.Data.Time)=00
Order by Time
Valori Max e Min per giornata
Select Max(Temperature),Min(Temperature), Max(Humidity), Min(Humidity), Date
From Data
Group by date
Caricamento file PHP sul server
Ultimo passaggio che ci rimane è quello di creare una pagina web, dalla quale
sarà possibile visualizzare i valori valori raccolti e le relative
interrogazioni che desideriamo.
Per poter interrogare facilmente un DB da una pagina WEB, è necessario
utilizzare un linguaggio lato server che si chiama PHP. Esso un linguaggio
abbastanza standard da usare e comprendere; l’unica nota utile da fare è che
tutte le variabili in PHP sono indicate con $nome_variabile = .
Ho realizzato, per semplice comodità, alcune pagine PHP utili per la stazione
meteo.
Sono già pronte all’uso, a patto di modificare il file mysql.php, che
contiene i dati d’accesso al database. I file PHP sono reperibili all’interno
della cartella PHP, che è presente nella repo di Github.
Le operazioni da fare per il progetto sono:
Installare il codice di Arduino per il client, che contiene il DHT22
Installare il codice di Arduino per il server, a cui è connessa la
scheda Ethernet
Installare su PC/Raspberry/UDOO i componenti MySQL server, Apache etc…
Creare lo schema del DB
Caricare le pagine WEB PHP nella cartella WWW del server
Disponibile il libro Alla Scoperta del
Raspberry PI: il piccolo PC Linux da
35 $
Raspberry PI: il piccolo PC Linux da 35 $
Oggi è disponibile sul mio blog e quindi può essere scaricato il libro Alla
Scoperta di Raspberry PI. In questo libro, si parla delle prime operazioni da
fare con il PC targato Linux ed ulteriori operazioni da fare, per migliorare
l’esperienza complessiva. Questo libro è stato scritto da me, con l’intento
di promuovere il più possibile il progetto Inglese del Raspberry PI, anche
agli utenti italiani. Per questo motivo e per la stessa filosofia che
contraddistingue Linux, il libro è gratuito, e lo resterà anche nell’edizioni
future, nelle quali verrano introdotti capitoli riguardati la robotica e
possibili ulteriori utilizzi del Raspberry PI, oltre che eventuali
aggiornamenti del sistema operativo Debian. All’interno del libro, sarà
possibile trovare i passaggi essenziali per avviarlo, oltre che consigli per
come aumentare le prestazioni e la durate del Raspberry PI. Per avere news
sul mondo del piccolo PC, potete visitare il sito http://www.raspberrypi.org.
Ecco l’indice del libro:
1.
2.
3.
4.
5.
6.
7.
1
2
3
4
5
6
7
Il PC da 35 Euro 5
Come installare il sistema operativo su SD 13
Primo avvio del sistema operativo 17
E↵etuiamo l’overclock 21
Come installare il flash player 23
Come visualizzare filmati in HD a 1080p 25
Trasformare il Raspberry PI in un medicenter 27
1. 7.1 InstalliamoRaspbmc……………………. 27
2. 7.2 Installiamo l’add-on SportsDevil per guardare la TV . . . . .
. . 30
3. 7.3 Utilizzamol’iPhonecometelecomando . . . . . . . . . . . . . .
. 34
8. 8 Come trasformare il Raspberry PI in un server VPN PPTP 37
9. 9 Installare i principali programmi 43
10. 10 Ultime impostazioni, per migliorare l’esperienza con il Rasp- berry
PI
Per scaricare il libro in formato PDF, basterà aprire il link qui sotto.
Buona lettura a tutti e buon divertimento con il Raspberry PI !
Alla scoperta del Raspberry PI
Lista dei comandi del terminale per
Linux
Linux è sistema gratuita Open Source, cioè è gratuita e chiunque può
contribuire per renderlo un sistema migliore. Ecco una descrizione da
Wikipedia:
Linux (/ˈlinuks/[2], pronuncia inglese [ˈlɪnʊks][3]) è una famiglia di sistemi
operativi di tipo Unix-like, rilasciati sotto varie possibili distribuzioni,
aventi la caratteristica comune di utilizzare come nucleo il kernel Linux.
Molte importanti società come: IBM, Sun Microsystems, Hewlett-Packard, Red
Hat, Canonical e Novell hanno infatti sviluppato e rilasciato, e continuano a
farlo, sistemi Linux. Grazie alla portabilità del kernel Linux sono stati
sviluppati sistemi operativi Linux per un’ampia gamma di computer,
dai personal computer, ai cellulari, dai tablet computer e console,
ai mainframe e ai supercomputer ed esistono sistemi Linux installabili anche
come server[4][5][6][7].
Le piattaforme più famose sono Ubuntu, Debian, Fedora e Ovviamente Backtrack.
Alla base di Linux, c’è Unix, un sistema sicuro, su cui per prima Apple ha
progetto i suoi Mac. Per poter utilizzare al meglio Linux, sopratutto le
distro meno conosciute, è consigliabile avere una minima conoscenza dei
principali comandi da utilizzare da terminale, per eseguire le principali
operazioni. Ecco una breve, lista dei comandi da utilizzare in ambiente
linux.
Lista comandi Linux (file PDF)
6° Puntata Alla scoperta di Raspberry
PI: Come visualizzare filmati in HD a
1080P
In questa sesta puntata, parleremo di come sia possibile visualizzare filmati
in alta definizione, con il Raspberry PI. Una delle principali lacune è la
scheda grafica, che non è sicuramente una delle migliori. Tuttavia, ci sono
ottimi programmi che permettono di far girare tranquillamente filmati, grazie
a librerie “speciali”, che permettono di accellerare la scheda video. Dai
risultati, la CPU non viene utilizzata più di tanto, come si può vedere dal
grafico in basso a destra. Il migliore programma si chiama Omxplayer.
Per installare il programma apriamo il terminale e digitiamo:
sudo apt-get install omxplayer
Lo svantaggio di questo programma è quello di non essere in modalità GUI,
cioè non ha una grafica e va comandato da terminale. Per esempio per
visualizzare un filmato digitiamo la seguente sintassi:
omxplayer -o hdmi -p nomefile.mp4
Importanti sono i comandi -o hdmi e -p; questi permettono di trasferire anche
l’audio attraverso il cavo HDMI, importante feature del Raspberry PI.
Tuttavia, dipende molto dalla TV che utilizziamo. Qualora ci fossero
difficoltà, dobbiamo utilizzare il jack audio presente sulla scheda audio.
Per avere una completa lista dei comandi di questo importante programma basta
digitare da terminale:
omxplayer -h
Ci sono altri programmi che permettono di visualizzare video, come VLC, ma
purtroppo non dispone dell’accelerazione hardware di Omxplayer, dunque la
riproduzione dei filmati può risultare a scatti.
Durante l’esecuzione del filmato, è possibile utilizzare i seguenti comandi:
z
1
2
j
k
i
o
n
m
s
d
f
q
Space or p
+
Left Arrow
Right Arrow
Down Arrow
Up Arrow
Show Info
Increase Speed
Decrease Speed
Previous Audio stream
Next Audio stream
Previous Chapter
Next Chapter
Previous Subtitle stream
Next Subtitle stream
Toggle subtitles
Subtitle delay -250 ms
Subtitle delay +250 ms
Exit OMXPlayer
Pause/Resume
Decrease Volume
Increase Volume
Seek -30
Seek +30
Seek -600
Seek +600
5°Puntata Alla scoperta di Raspberry
PI: Come installare il flash player
In questa quinta puntata parleremo di come installare il flash player sul
Raspberry PI, in modo da poter visualizzare senza problemi i filmati sui vari
siti Internet, come Youtube. Adobe, famosa per questo “software” non supporta
correttamente tale dispositivo. Tuttavia, esiste un’ottima alternativa che si
chiama Gnash. Questo semplicissimo programma, permette di far visualizzare
senza problemi di compatibilità i filmati flash presenti sul WEB. In questo
modo, per esempio, è possibile visualizzare i principali eventi sportivi
trasmessi in streaming su Internet. Illegale, ma davvero carina come idea !
Come primo passo, apriamo il terminale e digitiamo:
sudo apt-get install gnash
Ora installiamo tale plugin per renderlo eseguibile dal browser Midori:
sudo apt-get install browser-plugin-gnash
Ora i video in f lash potranno essere visualizzati con il Raspberry. Bisogna
ricordare, che a causa della limitazione delle scheda video, i video potranno
essere riprodotti a scatti.
Un’ottima alternativa a questa soluzione è quella di utilizzare Chromium, la
versione di Chrome per Linux. Per installarla, dobbiamo semplicemente
digitare da terminale:
sudo apt-get install chromium-browser.