Configurazione Raspberri PI 2

Dopo qualche mese di smanettamento con il raspberry, mi appunto qui una serie di note che ho raccolto nel frattempo.

Scelta del sistema operativo

La prima cosa da fare è selezionare il sistema operativo che girerà sul raspberry. Il consiglio che do è quello di provarne due o tre in prima persona, in modo da capire quale è quello più adatto alle proprie esigenze in base alle funzionalità offerte, configurabilità, versatilità.

La mia scelta è ricaduta su una distribuzione linux (che conosco bene), magari debian based (adoro apt), con Kodi installato sopra (mi interessa che sia un media center). In base a questi criteri, ho selezionato queste:

• XBian
• OpenElec
• Osmc

XBian e Osmc sono piuttosto simili, tranne che la seconda di default ha una skin personalizzata per Kodi, mentre XBian usa quella predefinita; sono entrambe debian-based, mentre OpenElec è una distribuzione ad hoc non basata su nessuna distro preesistente.

A livello di velocità di avvio, la più veloce risulta essere OpenElec, seguita da Osmc e per ultima XBian.

OpenElec, per contro, monta una serie di cartelle (tra cui /etc) su partizione read-only, per cui ha un livello di configurabilità post-installazione molto basso.

Attualmente sto usando Osmc (con skin predefinita di Kodi!) e mi sto trovando bene.

Modifica del file /boot/config.txt

La prima modifica ha lo scopo di aumentare le prestazioni, ma una ricerca di "overclock rpi2" su google porta ad un mole di risultati in cui è difficile districarsi; ad esempio ho trovato alcuni risultati interessanti qui, qui e qui, dai quali ho estratto la seguente configurazione di partenza:

arm_freq=1000
sdram_freq=500
core_freq=500
over_voltage=2
gpu_men=320
temp_limit=75
boot_delay=0
disable_splash=1
initial_turbo=30

Un'ottima guida del significato di questi e altri parametri è quella ufficiale.

La seconda modifica ha l'obiettivo di evitare che all'avvio il raspberry prenda il controllo della TV (switching automatico); questo si ottiene aggiungendo al file config.txt la riga:

hdmi_ignore_cec_init=1

Inoltre, va modificato il comportamento di Kodi direttamente nel suo menù di configurazione, raggiungibile da  Kodi > Settings > System > Input Devices > Peripherals > CEC Adapter > Devices to power on during startup....

La terza modifica serve ad avviare l'HDMI per default: questo perchè è possibile accendere la TV in maniera del tutto asincrona rispetto al raspberry, per cui voglio trovare Kodi acceso senza dover effettuare un riavvio. Questa modifica prevede l'aggiunta di queste due righe:

hdmi_force_hotplug=1
hdmi_drive=2

secondo quanto descritto qui. Questa terza modifica la volevo rimuovere a vantaggio di uno script che controlla se la tv è accesa o no, lanciando automaticamente Kodi.

La quarta modifica serve a registrare il decoder MPEG-2, in caso lo si sia acquistato separatamente. E' possibile infatti acquistare separatamente il codice che attiva la decodifica hardware di un flusso MPEG-2; il costo è abbastanza contenuto e può essere effettuato presso questo sito. Dopo qualche giorno arriva per posta il codice da inserire mediante la riga:
  
    decode_MPG2=0xYYYYYYY

Il comando che verifica se la registrazione è andata a buon fine è

    vcgencmd codec_enabled MPG2

che restituisce disabled o enabled a seconda dei casi.

Configurazione della rete

Una cosa fondamentale è quella di impostare un indirizzo IP statico, tipicamente al di fuori dell'intervallo di indirizzi gestito in DHCP dal router di casa. La comodità di usare lo stesso indirizzo IP è quella di impostare sui vari desktop (qui a casa abbiamo di tutto, PC Windows, Linux, Mac, tablet Android...) l'accesso alla condivisa samba.

Un'altra funzionalità comoda è quella di  impostare il dns dinamico come già indicato qui.

Configurare Kodi

La prima cosa da fare è configurare la lingua italiana, poi verificare che funzioni la condivisione samba ed eventualmente attivare la condivisione DLNA (richiesta dalla mia smart TV).

Avviare kodi solo se la TV è accesa

Lascio sempre il mio raspberry acceso anche se alcuni periodi lo uso molto poco. Le assicurazioni riguardo al suo bassissimo consumo vanno però corroborate da esperienza diretta, per cui mi sono collegato al raspberry e ho dato un bel htop e, sorpresa! In idle completo ho notato la CPU al 10/15% ! Mi sarei aspettato dei valori 0 virgola, eppure non era così! Allora sono andato a vedere cosa consumava più CPU e ho notato il processo Kodi.Bin.

Una ricerca su internet mi ha confermato che Kodi in idle consuma, e dipende anche dalla skin selezionata (io uso quella di default), anche se non si usa da ore ed è da quasi sempre acceso lo screensaver (il dimming).

Per questo motivo mi è venuta l'idea di lanciare kodi solo se la TV è accesa, ed ho visto che anche qualcun altro ha avuto la mia stessa idea, per cui ho deciso di creare il mio script di verifica della TV, ottenendo il seguente:

#!/bin/bash

ping -c 1 -W 1 192.168.1.7 > /dev/null

if [ $? -eq 0 ]; then

        systemctl -q status mediacenter > /dev/null

        if [ $? -ne 0 ]; then
                sudo systemctl start mediacenter
        fi

else

        systemctl -q status mediacenter > /dev/null

        if [ $? -eq 0 ]; then
                sudo systemctl stop mediacenter
        fi

fi

exit 0 

Poi ho creato il file /etc/systemd/system/checkHdmi.service con il seguente contenuto:

[Unit]
Description=Pinga la TV

[Service]
Type=simple
ExecStart=/home/osmc/checkHdmi.sh

Ed il file /etc/systemd/system/checkHdmi.timer che lancia il servizio ogni minuto:

[Unit]
Description=Check if TV is on

[Timer]
OnBootSec=60
OnUnitActiveSec=60
Unit=checkHdmi.service

[Install]
WantedBy=timers.target

Ho abilitato ed avviato il servizio con i comandi: 

systemctl enable checkHdmi.timer   

systemctl start checkHdmi.timer




Telecomando WII per Kodi su Xbian (e forse anche per altre distribuzioni)

Per far funzionare il telecomando wii con Kodi ho dovuto effettuare i seguenti passaggi:

1. Recuperare un dongle bluetooth
2. Installare lo stack bluetooth di linux bluez con il comando apt-get install bluez
3. Lanciare il comando hcitool scan e premere contemporaneamente i tasti 1 e 2 del telecomando wii: i led del telecomando lampeggieranno per una ventina di secondi in attesa del comando di accoppiamento
4. Se il comando precedente non va a buon fine lanciare il comando hciconfig hci0 reset e riprovare con il comando al punto precedente
5. Installare i driver wiimote con il comando apt-get install python-cwiid xbmc-eventclients-common
6. Recuperare lo script xbmc-wiimote dalla pagina https://github.com/paulvt/xbmc-wiimote, renderlo eseguibile con il comando chmod -x e metterlo in una cartella del PATH (io l'ho messo in /usr/bin)
7. Lanciare lo script del punto precedente con il parametro -b , dove è il valore trovato con il comando del punto 3, nel formato di 6 numeri separati da ':'
8. In kodi il telecomando sarà riconosciuto e funzionante!
9. Per rendere le modifiche effettive ad ogni riavvio, copiare il comando al punto 7 nel file /etc/rc.local
10. al successivo riavvio, premere insieme i tasti 1 e 2 del telecomando wii per riattivarne il controllo

Aggiungere canali a TVHeadend

Ho scoperto con orrore che bisogna aggiungersi a mano quantomeno i MUX da cui il nostro dispositivo DVB-T si prende poi i canali.

Per avere la lista di mux ho dovuto cercare su internet; per Roma ad esempio ho trovato questa, ma probabilmente la lista ufficiale è disponibile da qualche altra parte.

Il pannello di configurazione dei mux in tvheadend si raggiunge dai seguenti menù:

Ciascun mux insiste su una frequenza, per cui si seleziona il tasto verde Aggiungi, e dopo aver selezionato la rete esce fuori una schermata con tanti parametri.

Fondamentale inserire la frequenza del mux e l'ampiezza di banda a 8MHz. Portando manualmente lo stato della scansione ad ATTIVO, si forza la scansione, per cui dopo un po' l'interfaccia riporta il numero di servizi trovati.

In caso di fallimento, ho immesso anche la costellazione a QAM/64, poi la modalità di trasmissione e così via. Per gli effettivi valori di FEC ho cercato su internet il nome del MUX (ad esempio per mux rete a 1 esce questo)

Se sparisce la sezione TV (Live) da Kodi

É perchè la stringa m3u del plug-in punta ad un link non funzionante...per risolvere bisogna cambiare la stringa.

Linux home server

Da diverso tempo volevo riprendere il progetto di un home server basato su linux; le motivazioni per mettere su un home sono ad esempio riportate qua, e le riassumo in questa lista:

Central Media Hub: possibilità di vedere in streaming i video presenti sull'home server da qualunque dispositivo in LAN;

Torrent Box dedicata: scaricare facilmente qualunque tipo di file, e registrarsi ai seed per recuperare automaticamente nuovi file;

File Server: rendere disponibile tutti i file (film, musica, foto, documenti) su tutti i dispositivi in LAN;

Web Server: in caso vogliamo tirare su un sito di prova, o qualcosa di più serio.

Configurazione Hardware

Avendo a disposizione una serie di computer vecchi donati dai parenti con la scusa "te lo butto io", ho messo su un PC frankenstein con le seguenti caratteristiche:

• CPU: AMD Athlon(TM) XP 2000+
• RAM: 512MB
• Hard Disk: 80GB

La capienza del disco fisso è un po' bassa, ma ne ho a disposizione altri di capacità simile per cui potrei montarne altri 2 in modalità slave (uno per ciascun cavo IDE) più un masterizzatore DVD (in modalità master sul secondo IDE) per avere una capienza di circa 200 GB più possibilità di masterizzare.

L'unico problema è che la funzione di media streaming in HD richiede almeno un processore a 2GHz, per cui potenze inferiori potrebbero portare ad una riproduzione dei video a scatti; ho provato con flussi video non HD e lo stream mediante samba shares non ha dato interruzioni di sorta (con torrent sotto attivo!)

Configurazione Software

Il server che mettiamo su è headless, per cui tutte le funzionalità che andiamo ad installare saranno configurabili solo in remoto mediante ssh o altre utilità.

Tra quelle che si possono installare c'è webmin, che fornisce una serie di comode funzioni attraverso un'interfaccia web tra cui:

• Apache Webserver
• CD Burner
• SVN Server
• DynDns service
• Fail2Ban Intrusion Detector
• File Manager
• Samba Windows File Sharing

Tra le altre informazioni recuperate mentre progettavo l'home server, ho notato il concetto di Seedbox cioè un server dedicato al filesharing bittorrent, ma mi sembra un po' esagerato e fuori dallo scopo di questo progetto.

Andando a scorrere il tag Media Center in Inforpazzo, sono usciti una serie di post che sono applicabili a questa installazione:

• Accesso automatico via ssh

• Condividere file tra pc linux e pc windows (da aggiornare)

• Apt/dpackage da linea di comando

• Configurazione di mldonkey

Accesso automatico via ssh

Questo breve post per indicare i passi per accedere automaticamente ad un server ssh senza dover inserire la password ogni volta:

1. generare una coppia di chiavi ssh mediante il comando:
   ssh-keygen
2. copiare la chiave pubblica sul server ssh con il comando:
   scp .ssh/id_rsa.pub utente@server:.ssh/authorized_keys
3. accedere al server con il comando:
   ssh utente@server

et voilà.

PS: attenzione al comando del passo 2: sovrascrive il file authorized_keys del server.

Il comando ssh-keygen lanciato da solo genera una coppia di file chiave nella cartella .ssh della propria home:

• .ssh/id_rsa
• .ssh/id_rsa.pub

Il primo file è la chiave privata, da conservare gelosamente, il secondo è la chiave pubblica, che abbiamo installato sul server di destinazione.
 
Se si usano più client che accedono allo stesso server, per poter avere il login automatico si può:
    o copiare il file .ssh/id_rsa nella home degli altri client;
    o generare una coppia di chiavi per ogni client, e poi appendere in coda al file .ssh/authorized_keys del server i vari file .ssh/id_rsa.pub così generati.

In questo secondo caso la sequenza delle operazioni per ciascun client è la seguente:

1. generare una coppia di chiavi ssh mediante il comando:
   ssh-keygen
2. copiare la chiave pubblica sul server ssh con il comando:
   scp .ssh/id_rsa.pub utente@server:
3. accedere al server con il comando (chiederà la password):
   ssh utente@server
4. appendere la chiave pubblica del client al file del server con il comando:
   cat id_rsa.pub >> .ssh/authorized_keys 
   
   

Condividere file tra pc linux e pc windows

Per poter condividere file contenuti in una macchina linux si può usare il protocollo samba.

Per configurare samba bisogna andare nella cartella /etc/samba e modificare il file smb.conf aggiungendo ad esempio le seguenti condivisioni:

[Video]
        comment = Video Musicali
        read only = no
        locking = no
        path = /data
        guest ok = yes

[logs]

        comment = Log di sistema

        read only = yes

        locking = no

        path = /var/log

        guest ok = no

Dopodichè si riavvia il servizio samba (ho provato con un /etc/init.d smbd restart, ma il sistema mi ha consigliato un più comodo restart smbd).

In questo modo, accedendo al server linux da un PC windows si avrà una schermata come in figura:

Nella cartella Video sarà possibile entrare senza digitare password (grazie all'opzione guest ok = yes), e sarà possibile anche scrivere dei file (opzione read only = no)

La cartella logs richiede user e password, per cui basta inserire le credenziali di un qualuque utente configurato nella macchina linux per accedervi; inoltre l'opzione read only = yes impedisce qualunque scrittura.

Come si vede in figura, è possibile configurare opzionalmente il nome del server che verrà visualizzato nel titolo della finestra windows, basta modficare il parametro server string del file smb.conf, come ad esempio:

        server string = InforPazzo Linux Samba Server

Sembra fin troppo semplice...ma pare funzionare!

Aprire un progetto su SourceForge

Per poter cominciare a lavorare seriamente al mio progetto di media center, ho deciso di usare un servizio di hosting gratuito per progetti open source.

La scelta era tra launchpad, savannah e sourceforge, e la scelta è ricaduta su quest ultimo per i seguenti motivi:

• launchpad: usa bazaar come sistema di gestione del codice, che però non conosco e non mi andava di studiare
• savannah: non sono del tutto sicuro che il mio progetto faccia uso al 100% di free software (mame? mldonkey? mplayer?) e non mi va di verificare
• sourceforge: mi ha convinto la prima voce di questa pagina: code hosting con SVN che era proprio quello che cercavo

Creazione di un progetto su SourceForge

La prima cosa da fare per creare un progetto è registrare un account; sourceforge accetta login con openid (ne ho uno con google), ma bisogna comunque immettere dei dati.

Dopodichè si passa alla creazione del progetto, nome, descrizione, e più in dettaglio le caratteristiche tipo: licenza, categoria, parole chiave, linguaggio ed altro (qui il tutorial ufficiale).

Dopo aver inserito i dati del progetto, si passa all'upload di un po' di codice.

Ho preparato un archivio contenente il codice python, le immagini ed un file README con delle informazioni base del progetto; questo archivio l'ho caricato tra i file di progetto di sf usando l'interfaccia web.

Da ricordarsi di aggiungere uno o più screenshot del progetto: nel tag Develop, alla voce Screenshots (vedi immagine seguente) si apre la schermata per la loro gestione: selezionare la voce Admin per uploadare le schermate.

Controllo del codice

Tra i vari servizi, sourceforge fornisce un repository SVN del progetto.

Per poter scaricare il codice il comando è

svn co https://atlantismc.svn.sourceforge.net/svnroot/atlantismc atlantismc

Per aggiungere file e cartelle il comando è

svn add main.py README main.mnu data

Per finalizzare l'aggiunta (o la modifica) il comando è

svn commit

usando come utente e password quelle fornite all'atto della registrazione.

Tutti questi comandi svn vanno lanciati nella stessa cartella di progetto.

Il repository SVN è browsabile anche via web all'URL:

http://atlantismc.svn.sourceforge.net/viewvc/atlantismc/

Ecco la pagina del progetto che ho appena registrato:

https://sourceforge.net/projects/atlantismc/

Buon coding!

Thumbnail

Per la generazione automatica di mini-immagini significative da una collezione di film, ci viene in aiuto il comodo mplayer, mediante il seguente comando:

mplayer test.mpeg -ss 22 -nosound -vo jpeg
-frames 1

Questo comando crea, a partire dal file test.mpg, 22esimo secondo, un file chiamato "00000001.jpg" contenente uno screenshot del filmato.

Nel progetto di un media center, questo risulta utile per visualizzare, di fianco alla lista, uno screenshot del film selezionato in quel momento:

• Il sistema cerca il file film.jpg nella cartella nascosta .cache/
• se lo trova lo visualizza nel riquadro
• se non lo trova lo genera con il comando sopra, lo salva nella cartella nascosta con il nome del film e lo visualizza

Atlantide Media Center: Video Streaming

Gli utlimi aggiornamenti riguardo al media center scritto in python sono:

• ho contattato il creatore dell'immagine che inizialmente avevo impostato come sfondo, per sapere se potevo usarla in via 'ufficiale'. L'autore, gentilissimo e bravissimo, mi ha risposto che i diritti di quell'immagine sono già venduti (buon per lui). Dopo una infruttuosa ricerca su internet, ho deciso di farmene una da me. Con Gimp ho quindi creato questo sfondo, che mi sembra adeguato.

• ho attivato la visualizzazione del canale demoscene.tv alla tv! Da shell bisogna lanciare il seguente comando:
  mplayer -vc vp6 -framedrop -fs http://91.121.4.152:PORTA
  se PORTA = 8000: streaming in alta risoluzione (qui da me spesso si blocca)
  se PORTA = 8074: streaming in bassa risoluzione (meglio)
  se PORTA = 8072: streaming in bassa risoluzione del canale OldSchool! Amiga rulez! :)

• ho impostato i movimenti all'interno del menù mediante i bottoni del mouse con il seguente codice:
  if event.type == MOUSEBUTTONDOWN:
  #sx
  if event.button == 1:
  command = lCurrentMenu[iItemSelected][1]
  globals()[command]()
  #cx
  #elif event.button == 2:
  #dx
  elif event.button == 3:
  sys.exit(0)
  #su
  elif event.button == 4:
  iItemSelected -= 1
  #giu
  elif event.button == 5:
  iItemSelected += 1

• ho trovato una pagina di un progetto simile al mio: http://www.zeroflux.org/proj/htpc/htpc.txt
  
  

Problemi di mldonkey

E' già la terza volta che il servizio mldonkey del media-center non parte più.

La prima volta ho reinstallato il pacchetto e sono riuscito a ripristinare i download recuperando i file che iniziano con "urn_ed2k_" nella cartella /var/lib/mldonkey/temp e il vecchio file di configurazione files.ini.

Dopo di chè ho creato un back-up archivio della cartella /var/lib/mldonkey.

La seconda volta che si è bloccato, ho ripristinato l'archivio vecchio, e recuperato il file files.ini; la cartella /var/lib/mldonkey/temp è un link simbolico, da ripristinare.

La terza volta, il file files.ini era corrotto, ma ho recuperato quello che viene automaticamente backuppato ad ogni lancio del server, situato nella sottocartella old_config/.

Sarà forse il caso di rendere un po' più robusta la gestione dei file di configurazione?

E' anche vero che la versione installata nel media box è la 2.9.5, mentre l'ultima ad oggi è la 3.0.0., che magari risolve il problema. Potrei provare a sostituire il binario mlnet contenuto nella cartella /usr/bin (da fare).

Sessione di VNC con x11vnc

Alcune volte sorge la necessità di accedere da remoto al media box in modalità grafica.
In questo caso ci viene in aiuto programma x11vnc, che implementa un server vnc.
Si installa il pacchetto omonimo, e si esegue con il comando (via ssh):

x11vnc -display :0

Non lo metto in esecuzione automatica, perchè non mi serve automaticamente, ma solo saltuariamente.

Per la visualizzazione, lanciare dal client il programma "Visualizzatore di desktop remoti" nel menù Internet.

Apt/dpackage da linea di comando

Ci sono occasioni (tipo la gestione del media box via ssh) in cui risulta comodo o necessario accedere alla lista di pacchetti installati/installabili senza l'ausilio di interfaccie grafiche (synaptic in primis). Ecco quindi una breve lista di comandi da terminale utili all'uopo:

• lista di pacchetti installati: dpkg -l
• lista di pacchetti installabili: less /var/lib/dpkg/available
• ricerca di una stringa all'interno dei pacchetti: apt-cache search "stringa"
• ricerca di un file all'interno dei pacchetti: dpkg -S "file"
• lista di file installati da un pacchetto: dpkg-query -L

Atlantide Media Center: menù di partenza

Un po' di brainstorming per il media center:

• ogni menù ha una voce 'setup' che permette di configurare gli aspetti di quel menù, come ad esempio il percorso dove trovare i file multimediali, o il comando da impostare per riprodurli
• ogni menù ha una voce 'indietro' ('esci' su quello principale)
• dati possono essere directory e file, che si possono rinominare, cancellare, copiare, spostare; si possono creare directory nuove
• se evidenziata una cartella, ti dice il numero di file e la data del più recente
• se evidenziato un file ti dice dimensione, data e lunghezza (e magari copertina e info IMDB o equivalente italiano!)
• nel menù 'Guarda TV' la funzione 'Setup' attiva la funzione di popolamento dei canali, e il comando per la visualizzazione dei canali stessi
  
• i programmi registrati vanno in 'Registra TV', si possono poi spostare a piacere; in quel menù sono presenti le programmazioni

E ora un po' di codice python...

#!/usr/bin/python
########################################################
# Note sul nome delle variabili e funzioni : 
# iniziano tutte con una sequenza che indica il tipo
#
# i    = intero
# s    = surface
# str  = stringa
# font = font
# r    = rect
########################################################
# Imports
########################################################
import pygame, sys, os
from pygame.locals import *
########################################################
# Inizializzazione variabili
########################################################
pygame.init()
iiResolution = (800, 600)
fontDefault = pygame.font.Font(None, 36)
# set screen resolution
pygame.display.set_mode(iiResolution, 0, 32)
sScreen = pygame.display.get_surface()
strBackgroundFile = os.path.join(".","Atlantis_by_aksu.jpg")
sBackground = pygame.image.load(strBackgroundFile)
strCurrentMenu = os.path.join(".","main.mnu")
########################################################
# Functions
########################################################
def drawMenu(menuFile, iSelected):
# Disegna il contenuto del menuFile ed evidenzia il selected
global sForeground, fontDefault
##################################
file = open(menuFile, 'r')
i=0
centerx = sForeground.get_rect().centerx
offsy   = sForeground.get_rect().centery/2
for line in file:
line = line.replace ( "\n", "" )
sText = fontDefault.render(line, 1, (255, 255, 255))
rText = sText.get_rect()
rText.centerx = centerx
rText.y = i*32+offsy
if i == iSelected:
 rText2 = rText.inflate(118,4)
 rText2.centerx = centerx
 sBox = pygame.Surface.convert_alpha(pygame.Surface((rText2.width, rText2.height)))
 sBox.fill((0, 255, 255, 100))
 sForeground.blit(sBox, rText2)
sForeground.blit(sText, rText)
i=i+1
# Setup string
sText = fontDefault.render("Setup", 1, (255, 255, 255))
rText = sText.get_rect()
rText.centerx = sForeground.get_rect().centerx
rText.y = i*32+offsy
sForeground.blit(sText, rText)
# Exit/back string
i=i+1
sText = fontDefault.render("Exit", 1, (255, 255, 255))
rText = sText.get_rect()
rText.centerx = sForeground.get_rect().centerx
rText.y = i*32+offsy
sForeground.blit(sText, rText)
##################################
def input(events):
# Gestisce gli eventi di input
global iItemSelected
##################################
for event in events:
if event.type == KEYDOWN:
 if event.key == K_UP:
  iItemSelected -= 1
 elif event.key == K_DOWN:
  iItemSelected += 1
 elif event.key == K_ESCAPE:
  sys.exit(0)
else:
 print event
########################################################
# Main
########################################################
iItemSelected =0

# Main loop
while True:
sForeground = pygame.transform.scale(sBackground, iiResolution)
input(pygame.event.get())
pygame.display.flip()
drawMenu(strCurrentMenu, iItemSelected)
sScreen.blit(sForeground, (0,0))

Atlantide Media Center: prime prove

Nell'ottica di implementare un front-end grafico per la mia linux-box, sto studiando il python e pygame.

Questo è il risultato di un paio d'ore di smanettamento:

#!/usr/bin/python

import pygame, sys, os

from pygame.locals import *

screenwidth = 800
screenheight = 600

pygame.init()

# set screen resolution
pygame.display.set_mode((screenwidth, screenheight))#, pygame.FULLSCREEN) 
screen = pygame.display.get_surface() 

back_file_name = os.path.join(".","Atlantis_by_aksu.jpg")
back_surface = pygame.image.load(back_file_name)

font = pygame.font.Font(None, 36)
text = font.render("Guarda un film", 1, (255, 255, 255))
textpos = text.get_rect()
textpos.centerx = back_surface.get_rect().centerx
back_surface.blit(text, textpos)

fore_surface = pygame.transform.scale(back_surface, (screenwidth, screenheight))

screen.blit(fore_surface, (0,0))

pos = 0,0

def input(events): 
	for event in events: 
		if event.type == MOUSEBUTTONDOWN: 
			sys.exit(0) 
		elif event.type == MOUSEMOTION:
			global pos
			pos = pygame.mouse.get_pos()
			screen.blit(back_surface, (pos[0],pos[1])) 
		else:
			print event 

# Main loop
while True: 
	input(pygame.event.get()) 
	pygame.display.flip() 

Chi fa da se fa per tre

Freevo, il media center che sto usando adesso, non mi sta soddisfacendo troppo:
- è di installazione complicata
- spesso alcune funzioni indicate nel wiki non vanno (ad esempio per giocare con il mame)
- per far funzionare la tv sia in visualizzazione che in registrazione bisogna evocare antichi riti voodoo
- le istruzioni per l'installazione non sono sufficienti

Ad esempio ho scoperto da poco che per poter funzionare correttamente freevo ha bisogno di lanciare altri processi suoi, separatamente e rigorosamente a mano...ma non è indicato da nessuna parte...molto utile!

Dopo diversi mesi di utilizzo di freevo, ho deciso di provare ad impostare da me un mio media center, appoggiandomi ai programmi che ho potuto vedere in azione finora, come ad esempio mplayer.

Con Mplayer, infatti, si possono eseguire operazioni di visualizzazione filmati, canali tv e la possibilità di registrarli facilmente.

L'idea è quindi quella di implementare un front-end grafico, che permetta l'esecuzione di Mplayer per le suddette operazioni, con l'aggiunta della possibilità di lanciare il mame per i giochi da bar.

Il front-end sarà implementato in Python, linguaggio che non conosco ma che sembra abbastanza facile, assieme alla libreria pygame che fornisce immediate funzionalità grafiche senza dover conoscere l'hardware sottostante.

Freevo & il topo

Non avendo ancora acquistato un telecomando per controllare freevo, mi sono inventato un modo per poter usare in alternativa il mouse.

Ho appositamente creato una pagina nel wiki di freevo, nella quale descrivo come si configura.

Quello che non ho indicato, ma che potrebbe essere utile farlo in un altra pagina del wiki, è come lanciare freevo dopo che la fase di avvio del mediabox è terminata.

Ho deciso infatti di non eseguire automaticamente freevo, visto che potrei avere bisogno del media box solo come server (mldonkey o file) e non per vedere un film. Inoltre, l'esecuzione di freevo incrementa l'uso della CPU dal 3 al 30% (in modalità idle!), per cui in ottica di risparmio energetico e di durata di componenti hardware ho deciso di lanciarlo solo in caso di necessità.

Login automatico

La prima cosa da fare è quella di impostare il login automatico: si compila il semplice file dal nome autologin.c contentente:

int main() { execlp( "login", "login", "-f", "nomeutente", 0); }

dove al posto di nomeutente si mette l'utenza con cui si vuole effettuare l'accesso automatico.

Poi si modifica il file /etc/event.d/tty1 (/etc/init/tty1.conf) in modo che risulti simile a questo:

start on stopped rc2
start on stopped rc3
start on stopped rc4
start on stopped rc5

stop on runlevel 0
stop on runlevel 1
stop on runlevel 6

respawn
exec /sbin/getty -n -l /usr/local/sbin/autologin 38400 tty1

dove /usr/local/sbin/autologin è il programma compilato poco sopra.


Segnalazione di boot terminato

Nel file .bashrc, eseguito automaticamente nel passo precedente, si mette alla fine la seguente sequenza di comandi:

if [ -z "$DISPLAY" ] && [ $(tty) == /dev/tty1 ]; then
beep
./mousem
fi

Con beep si intende un comando che esegue un suonetto, disponibile nella fattispecie eseguendo "sudo apt-get install beep" da terminale. Se non si sente il suonetto, probabilmente è disabilitato nel file /etc/modprobe.d/blacklist, riabilitarlo commentando la riga "blacklist pcspkr".


Lancio di freevo a schermo spento

Il comando mousem del passo precedente è un altro applicativo scritto in c da compilare

#include <stdio.h>
#include <gpm.h>
#include <unistd.h>

int my_handler(Gpm_Event *event, void *data) {
switch(event->buttons) {
case 1:
printf("tasto dx\n");
break;
case 2:
printf("tasto cx\n");
break;
case 4:
printf("\a\n");
execl("/home/zac/vai.sh", "vai.sh", (char *)0);
break;
}
return 0;
}

int main() {
Gpm_Connect conn;
int c;
conn.eventMask = ~0; /* Want to know about all the events */
conn.defaultMask = 0; /* don't handle anything by default */
conn.minMod = 0; /* want everything */
conn.maxMod = ~0; /* all modifiers included */

if(Gpm_Open(&conn, 0) == -1)
printf("Cannot connect to mouse server\n");

printf("mouse menù\n");

gpm_handler = my_handler;
while((c = Gpm_Getc(stdin)) != EOF)
printf("%c", c);
Gpm_Close();
return 0;
}

Questo programma associa al tasto sinistro del mouse l'esecuzione di un programma a nostra scelta, nella fattispecie lo script vai.sh che contiene:

#!/bin/sh
xinit
./mousem

che esegue il server x, e quando si esce da freevo rilancia automaticamente il programma che ascolta il mouse.