Un processore di effetti di chitarra su Ubuntu

Oltre ad essere un utente ubuntu sono anche un discreto chitarrista. Una delle cose che di più mi manca su Ubuntu è un programma di emulazione di amplificatori in grado di permettermi di sfruttare la mia M-Audio Fast Track (lo so che c'è di meglio ma per divertirsi va più che bene) perfettamente riconsciuta da Ubuntu.

Stasera ho deciso di vedere che cosa è in grado di fare la mia linux box nell'ambito dell'effettistica realtime.

Installiamo il necessario
Prima di tutto ho installato il kernel a bassa latenza presente nei repository Ubuntu (linux-image-2.6.20-15-lowlatency). Quando si parla di audio su linux viene subito da pensare al server audio jackd. Questo server per poter avere buone prestazioni in realtime, ha bisogno di alcuni accorgimenti particolari. Infatti è necessario compilare un apposito modulo per il kernel: non lasciatevi intimidire, non è poi cosi difficile. Vediamo come fare. Prima di tutto vi consiglio di installare il pacchetto module-assitant che vi risparmierà un sacco di noie e alla fine produrrà un bel pacchetto deb con ciò di cui abbiamo bisogno.
Prima di procedere è consigliabile riavviare con il kernel lowlatency.

Quindi installiamo il pacchetto realtime-lsm.
A questo punto andiamo a compilare il nostro modulo (assicuratevi di essere ancora connessi ad internet):

$ sudo m-a a-i realtime-lsm

Questo comando scaricherà dalla rete tutto ciò di cui avrà bisogno per compilare il modulo e per costruire il pacchetto .deb. Alla fine dell'operazione installerà automaticamente il pacchetto con il modulo.
E' arrivato il momento di testare il modulo realtime:

$ sudo modprobe realtime any=1

Se il comando dovesse dare degli errori durante il caricamento provate a riavviare (a me è successo e riavviando ho risolto).

Se l'operazione è andata a buon fine possiamo procedere ad installare gli altri pacchetti: jackd, jack-rack, qjackctl, caps.

Siamo finalmente pronti a testare il nostro processore di effetti.
Lanciamo qjackctl ed impostiamo i parametri per il demone jackd (non dimentichiamoci di attivare l'opzione realtime naturalmente). Quindi lanciamo jack-rack e dopo aver fatto le opportune connessioni attraverso qjackctl possiamo caricare gli effetti. I simulatori di amplificatori, di cabinets, di preamplificatori etc si trovano dal pulsante Aggiungi->Uncategorised->C di jack-rack.

Impressioni d'uso
Giocando con le varie impostazioni si riescono ad ottenere alcuni suoni che non sono malaccio anche se non posso dire che siano pienamente soddisfacenti. Altra nota dolente è che sul mio centrino a 1.5 Ghz non riesco a caricare più di 3 o 4 moduli contemporaneamente in jack-rack. In ogni modo mi sento di consigliarvi di provarli anche solo per il gusto di vedere la vostra chitarra processata da software open source :)

Urban Terror: Ogni tanto meritiamo un piccolo svago:)

Tra uno studio, un lavoro e tutto il resto noi linuxiani amiamo anche passare un po ti tempo a giocare. Visto che purtroppo sulla ubuntu feisty nexuiz sembra avere qualche problemino (almeno sul mio pc crasha non appena inizio una partita) ho cercato delle alternative in rete e ho trovato Urban Terror un gioco davvero ben fatto e divertente da giocare online.



Installazione
Per installare Urban Terror è necessario scaricare questi files dal sito http://www.urbanterror.net/:

1. UrbanTerror40_full.zip
2. ioUrbanTerrorInstaller_1.0.zip
3. http://urt.battleye.com/BEClient_i386.so
4. http://urt.battleye.com/BEServer_i386.so

A questo punto creiamo una cartella UrbanTerror dove meglio ci pare (ad esempio nella nostra home). Unzippiamo il file ioUrbanTerrorInstaller_1.0.zip in una cartella temporanea e copiamo il contenuto della cartella Linux-i386 nella cartella UrbanTerror che avevamo creato in precedenza.
Ora unzippiamo il file UrbanTerror40_full.zip nella cartella UrbanTerror ed infine copiamo i files BEClient_i386.so e BEServer_i386.so nella cartella UrbanTerror/BattlEye.

Siamo quasi pronti a giocare. Rimane solo da dare i permessi di esecuzione al file UrbanTerror/ioUrbanTerror.i386 ed eseguirlo.

Il gioco
Si tratta di una arena a squadre da giocare online. Si muore molto facilmente (è realistico) ma è molto divertente. Lo consiglio a tutti quelli che dopo una intensa giornata di lavoro sentono l'esigenza di "uccidere qualcuno" (metaforicamente naturalmente :)

Happy gaming!

Una classe per le notifiche con python e dbus: parte seconda

Qulche tempo fa in questo post avevo spiegato come è possibile generare una notifica utilizzando python e dbus. Il commento di AS in quel post mi ha dato l'ispirazione per approfondire le conoscenze su dbus e per creare questo nuovo post con una versione più evoluta della classe python per le notifiche (vi suggerisco la lettura del post precedente prima).

La nuova bestiola mostra un esempio di come sia possibile aggiungere funzionalità alle notifiche con l'inclusione di pulsanti.

L'esempio chiarisce inoltre come sia possibile posizionare la notifica in un punto arbitrario del desktop.

Il codice python

import dbus
from dbus.mainloop.glib import DBusGMainLoop

ICON = "file:///home/redgun/python/planimo/data/icons/planimo48.png"

class Notifier:
    def __init__(self):
       dbus_loop = DBusGMainLoop()
       self.session_bus = dbus.SessionBus(mainloop = dbus_loop)
       obj = self.session_bus.get_object("org.freedesktop.Notifications",
                                       "/org/freedesktop/Notifications")
       self.notif = dbus.Interface(obj, "org.freedesktop.Notifications")

       self.notif.connect_to_signal("ActionInvoked", self.action_cb)

    def action_cb(self, id, act):
       print act

    def notify(self, title, message, iconfile = ICON, time = 3000):
       hints = {}
       hints['x'] = 1200
       hints['y'] = 50
       actions = ["a1", "Azione1", "a2", "Azione2"]
       try:
               self.notif.Notify("Notification",
                       dbus.UInt32(0), iconfile, title, message,
                       actions, hints, dbus.Int32(time), dbus.UInt32(0))
       except:
               try:
                       self.notif.Notify("Notification",
                               dbus.UInt32(0), iconfile, title, message,
                               actions, hints, dbus.Int32(time))
               except Exception, detail:
                       print detail

if __name__ == "__main__":
   n = Notifier()
   n.notify("Title", "message <b>bold style</b>", time=10000)

    import gobject
   loop = gobject.MainLoop()
   loop.run()

Il risultato sarà il seguente:



Da notarsi che i pulsanti sono cliccabili e le azioni possono essere gestite all'interno del metodo action_cb. La variabile hints, invece ci permette di impostare le coordinate della notifica sul desktop. Le azioni vengono specificate in una lista dove gli elementi pari rappresentano i nomi delle azioni che andranno a comparire sui pulsanti, mentre quelli dispari rappresentano il valore che verrà passato alla funzione di callback. In questo caso quindi, quando premiamo il pulsante Azione1 la funzione action_cb riceverà nella variabile act il valore a1.

Ubuntu 7.10: nome in codice Gutsy Gibbon

Ancora prima del rilascio ufficiale di Ubuntu Feisty Fawn, Mark Shuttleworth annuncia il nome della prossima Ubuntu: Gutsy Gibbon. Mark ci riprova e assicura che in Ubuntu 7.10 gli effetti grafici saranno abilitati di default (intanto qui una guida su come abilitarli su Feisty Fawn con una ati 9600/9700).

Gusty Gibbon non sarà una LTS release (Long Term Support) e una delle novità importanti che introdurrà sarà il fatto che uscirà in due edizioni distinte: una versione normale ed una priva di ogni software per il quale non è disponibile il codice sorgente, dai firmware ai drivers proprietari e tutti gli altri materiali come suoni e immagini per i quali non si hanno pieni diritti per la modifica.

Per il resto non ci resta che aspettare ansiosi di vedere quale saranno le altre novità introdotte.

Modem Alice Adsl Wireless

Se state pensando di fare un abbonamento ad alice adsl e richiedere il modem in comodato d'uso per connettervi via wireless con la vostra amata Ubuntu ve lo sconsiglio per svariati motivi.

1) Non lasciatevi ingannare dal fatto che appare come un router (4 porte ethernet e interfaccia wireless), non lo è. Con l'apparecchio ci si può collegare da un solo computer per volta. (incredibile ma vero. Probabilmente un blocco via firmware)

2) La connessione ad internet deve essere lanciata direttamente dal computer (non è l'aggeggio che lo fa per voi)

3) Non ha praticamente interfaccia di configurazione se non una per lo stato e per l'attivazione della chiave wep o wpa, tra l'altro predefinita e non modificabile, memorizzata in una sorta di scheda tipo sim card.

4) Il segnale wireless fa a dir poco pena. Da una stanza all'altra con un centrino la rete va e viene.

5) Scordatevi qualsiasi tipo di funzionalità avanzata.

6) L'assistenza telecom lascia a dir poco a desiderare

Vi suggerisco quindi, se proprio non potete fare a meno dell'adsl di telecom di quantomeno acquistare un router per conto vostro!

Pid di un processo a cui appartiene un socket

Come si fa a conoscere il pid di un processo sapendo che è in ascolto su un determinato numero di porta?

Si usa il comando fuser!

Ad esempio supponiamo che sul nostro sistema sia in esecuzione un processo che apre un socket sulla porta 80 (apache ad esempio): per conoscere il pid del processo si può procedere con il comando fuser come segue:

$ fuser -n tcp 80

Questo comando stamperà qualcosa di simile a:

80/tcp: 15136 15140 15141 15142 15143 15144

I numeri che si trovano a destra dei due punti sono tutti pid dei processi facenti uso della porta 80. (in questo caso ne abbiamo più di uno perché apache duplica se stesso quando viene avviato)

Se si tratta di un socket udp è necessario specificarlo al posto di tcp.

N.B. Se il processo appartiene all'utente root è necessario invocare il comando fuser con i privilegi di amministratore e quindi preponendo sudo

feisty compiz e ati mobility radeon 9600/9700

In questi giorni mi sono finalmente deciso a passare alla beta di ubuntu (feisty). Tutto è filato liscio con un semplice sudo update-manager -d anche se ci ha impiagato circa 4 ore con tutti i pacchetti che avevo installati.

Avendo fesity con il supporto a compiz integrato come non provare il fatidico cubo? Forse ero rimasto uno dei pochi a non averlo ancora visto dal vivo e non mi ero mai impegnato ad installare tutto il necessario.

Scopro però che i drivers proprietari della mia scheda Ati mobility radeon 9700 non supportano l'estensione AIGLX necessaria a compiz. Io ho sempre usato questi drivers perché con quelli open non riuscivo ad abilitare il supporto all'accelerazione 3d.

Con un po di impegno in più, questa volta ci sono riuscito e finalmente ho anch'io i cubi rotanti e le finestre fluttuanti :D

Come procedere?

Prima di tutto se si hanno i drivers proprietari ati è necessario rimuoverli completamente.
Quindi bisogna editare il file xorg.conf con:

sudo gedit /etc/X11/xorg.conf

e fare in modo che le varie sezioni contengano quanto segue:

Section "Module"
 ........
 ........
 Load            "dri"
 Load            "glx"
 ........
 ........
EndSection

Section "Device"
 Identifier      "ATI Technologies, Inc. RV350 NP [Mobility Radeon 9600/9700 M10/M11]"
 Driver          "radeon"
 ...........
 Option          "AGPMode" "8"
 Option          "AGPFastWrite" "true"
 Option          "RenderAccel" "true"
 Option          "backingstore" "true"
EndSection

Section "DRI"
 Mode    0666
EndSection

Section "Extensions"
 Option          "Composite" "True"
 Option          "RENDER" "Enable"
 Option          "DAMAGE" "true"
EndSection

A questo punto non rimane che riavviare X (se non funziona riavviate completamente il sistema operativo)

Assicuratevi che l'accelerazione 3d sia attiva con:

glxinfo | grep direct

deve comparire:

direct rendering: Yes

Se compare "no" allora siete sfortunati o avete sbagliato qualcosa.

Se compare "yes" è possibile finalmente abilitare gli effetti grafici: dal menù gnome Sistema->Preferenze->Effetti Desktop abilitare il cubo e le finestre fluttuanti.

Per una gestione più fine delle opzioni compiz, suggerisco di installare il pacchetto gnome-compiz-manager

Catturiamo il SIGTERM con python

Scrivendo una applicazione a volte è necessario compiere delle operazioni di "pulizia" prima che questa venga chiusa. A volte è necessario compierle anche se l'applicazione viene uccisa con kill.

Il comando kill

Il comando Kill serve per inviare dei segnali ad un processo. Utilizzato senza opzioni e con parametro un pid di un processo (che possiamo trovare utilizzando il comando ps), kill invia a tale processo il segnale SIGTERM che in genere indica al processo di terminare le sue operazioni. Esistono molti altri segnali ma in questo post ci occuperemo solo del SIGTERM.

Il modulo signal

Per la gestione dei segnali python mette a disposizione il modulo signal. Una delle funzioni più importanti presenti in questo modulo è la signal(). Questa funzione permette di registrare un handler per un particolare segnale.

Esempio

import signal
import sys
import time

def sigterm_handler(signum, frame):
       print "SIGTERM catturato"
       sys.exit(0)

signal.signal(signal.SIGTERM, sigterm_handler)

while (1):
       sys.stdout.write(".")
       sys.stdout.flush()
       time.sleep(1)

Questo esempio continua a stampare "." fin quando non cattura il segnale SIGTERM inviato con una kill pid. A questo punto stampa il messaggio che indica che il segnale è stato catturato ed esce