GL-Como

Linux Day 2025

2025-10-17T20:30:00+02:00

Anche quest'anno il GL-Como partecipa al Linux Day!

L'appuntamento annuale organizzato da ILS è nato nel 2001 per promuovere le idee del software libero e dell'open source, con un occhio di riguardo verso Linux. L'evento è costituito da una rete di eventi decentralizzati in tutta Italia organizzati autonomamente da gruppi volontari e appassionati.

In questa edizione il GL-Como si unisce a ILS Casorate Sempione, sabato 25 ottobre presso la biblioteca comunale Alda Merini .

Il programma definitivo è disponibile su https://casoratesempione.ils.org/2025/07/18/linuxday-2025/

Linux App Summit 2022

2022-05-25T12:28:00+02:00

Nei giorni 29 e 30 aprile 2022, in due membri del gruppo si è partecipato all’evento Linux App Summit.

E' la prima volta che partecipiamo al LAS, evento a livello mondiale, giunto alla sua quarta edizione, che ha lo scopo di far incontrare sviluppatori di programmi per il desktop Linux con riferimento agli ambienti KDE e GNOME.

Quest'anno il Linux App Summit si è tenuto presso il Centro Giovani Smart Lab di Rovereto, un ambiente polifunzionale dove si tengono varie attività e con uno spazio per concerti e conferenze.

Abbiamo preso confidenza con la location già da giovedì sera, durante il "party di pre-registrazione": dopo aver ritirato i nostri badge abbiamo gironzolato per il posto bevendo qualcosa e mischiandoci ai presenti.

Le giornate “lavorative” del venerdì e sabato sono state intense con interventi dal vivo e on-line (purtroppo non sempre di qualità); durante i coffe break veniva offerto uno spuntino con succo di frutta e cornetto.

La giornata di sabato è terminata con un aperitivo release party in occasione del rilascio della versione di Ubuntu 22.04: pizza, focaccia e birra a volontà; si è fatta anche la foto di gruppo.

Il risultato dei lavori di questi due giorni indicano che c’è sempre fermento nel mondo open source, tanti nuovi progetti e aggiornamenti di quelli esistenti, che c'è il coinvolgimento di giovani sviluppatori e che serve sempre il supporto di tutti sia a livello economico che intellettuale.

In attesa della prossima edizione vi consiglio di visitare il sito e di approfondire gli argomenti trattati.

Buone cose a tutti.

Cinema web in javascript - Parte 1

2022-02-10T16:00:00+01:00

Proviamo a scrivere un'applicazione web che permette di vedere un video con gli amici e di commentarlo via chat.

L'idea è di avere un lettore video in una pagina web che carica un file video da un url e che sia controllato da uno dei partecipanti.

Avremo quindi un utente (che chiameremo 'controllore') crea una "stanza", decide l'url del video che sarà riprodotto e che controlla il lettore video. Gli altri utenti quando si connettono alla stanza vedranno caricarsi il video scelto e la riproduzione sarà sincrona con quella del 'controllore', che invierà una serie di messaggi per far sapere se è in pausa o in play, e a che posizione del video si trova.

Abbiamo quindi bisogno di un sistema per inviare e ricevere messaggi tra diversi computer attraverso javascript.

Potremmo scrivere un server che distribuisce i messaggi ai vari client collegati via websocket, ma scrivere e mettere online un server simile è troppo complicato per ora.

Potremmo utilizzare webrtc e mettere in comunicazione i browser tra di loro, ma serve comunque un sistema per inizializzare le connessioni, attraverso un software lato server (e siamo come sopra) o attraverso un canale di comunicazione alternativo (per esempio scambiandosi delle stringhe di connessione via email o via chat esterne), ma è scomodo. Per di più il codice javascript per gestire tutto questo diventa alquanto complicato.

L'idea per questo esperimento è di utilizzare ntfy che è un server di pub-sub basato su http: messaggi inviati a un "topic" con una richiesta HTTP POST vengono girati a tutti i client in ascolto su quel topic. E siccome per questo esperimento non vogliamo gestire niente lato server, utilizzeremo il servizio gestito dallo stesso progetto: https://ntfy.sh/

Scrviamo del codice

Cominciamo con la nostra pagina:

<!DOCTYPE html>
<html>
    <style>
        .hidden { display: none; }
    </style>
    <body>
        <div id="start">
            <p>
                <label for="video_url">URL video:</label>
                <input id="video_url">
            </p>
            <button id="start_button">Start</button>
        </div>


        <video id="player" class="hidden" controls></video>

        <a id="room_link" href="#"></a>

    </body>
    <script src="app.js"></script>
</html>

Una pagina molto semplice: abbiamo un campo di testo un cui inserire l'indirizzo del video da riprodurre e il lettore video, che teniamo nascosto finchè l'utente non pigia "Start".

Il codice della nostra applicazione è tutto nel file app.js:

let e_start_form = document.getElementById("start");
let e_video_url = document.getElementById("video_url");
let e_start_button = document.getElementById("start_button");
let e_player = document.getElementById("player");
let e_room_link = document.getElementById("room_link");

iniziamo salvandoci un riferimento agli elementi nella pagina che dovremo modificare.

Definiamo poi un po' di variabili:

let topic = "";             // topic su ntfy che useremo per inviare e ricevere i messaggi
let video_url = "";         // l'url del video che stiamo vedendo
let last_time = -1;         // questo è l'ultima posizione nel video che abbiamo notificato
let player_state = "stop";  // stato del lettore, "stop" "play" "pause"
let im_control = false;     // siamo noi i controllori nella stanza?

const MIN_T = 5;            // tempo minimo tra le notifiche

let eventSource = null;

Teniamo traccia del topic (che è una stringa di testo e che genereremo casualmente), e dell'url del video. Il lettore ci notifica a ogni cambio della posizione nel video. Se inviamo un messaggio per ogni aggiornamento finisce che generiamo troppo traffico inutile, quindi teniamo traccia dell'ultima posizione inviata e quando la nostra posizione cambia più di un tot di secondi, allora inviamo una nuova notifica. Questa quantità è definita nella costante MIN_T, qui definita a 5 secondi. Ovviamente le notifiche le inviamo solo se siamo i controllori, e siamo i controllori se abbiamo creato noi la stanza, nel qual caso la variabile im_control sarà true.

L'utima variabile, eventSource la vediamo dopo, è l'oggetto che riceve i messaggi da ntfy.

Ora definiamo qualche funzione.

Per prima la funzione che invia i messaggi:

function send_message_sync() {
    if (!im_control) return;
    const ct = e_player.currentTime;
    last_time = ct;

    let data = {
        'type':'sync',
        'url': video_url,
        'state': player_state,
        'currenttime': ct,
    }

    fetch('https://ntfy.sh/' + topic, {
        method: 'POST',
        body: JSON.stringify(data),
    });
}

Ntfy prende solo testo, quindi nella funzion costruiamo un messaggio e lo convertiamo in JSON per inviarlo al topic con una richiesta POST.

Il messaggio conterrà:

il tipo di messaggio
l'url del video che stiamo guardando
lo stato del lettore
la posizione del lettore in secondi

Il tipo di messaggio è sync, ed è l'unico che vedremo per ora. In una versione più avanzata la pagina conterrà anche una chat, quindi ci sarà anche un messaggio di tipo chat.

Poi definiamo la funzione che crea una nuova stanza:

function create_room() {
    video_url = get_required_value(e_video_url);
    if (!video_url) return;

    let room_id =  Math.random().toString(16).substr(2, 20);

    im_control = true;

    start(room_id);
}

Qui recuperiamo il valore inserito nel campo di testo, che non deve essere vuoto, nel caso usciamo subito dalla funzione.

get_required_value() è una funzione di supporto che controlla che il campo non sia vuoto e nel caso imposta il campo stesso come non valido.

function get_required_value(e) {
    let v = e.value;
    if (v == "") {
        e.setCustomValidity("Field required.");
        return null;
    }
    e.setCustomValidity("");
    return v;
}

Tornando a create_room(), generiamo un nuovo id random e impostiamo im_control a true: l'utente che crea la stanza è il controllore.

Chiamiamo quindi start() che avvia la stanza:

function start(room_id) {
    topic = room_id;

    e_start_form.classList.add("hidden");
    e_player.classList.remove("hidden");

    e_room_link.href = "#" + topic;
    e_room_link.innerText = topic;

    eventSource = new EventSource('https://ntfy.sh/' + topic + '/sse');
    eventSource.addEventListener('message', on_message);

    if (video_url !== "") {
        e_player.src = video_url;
    }
}

Il room_id diventa il topic che useremo con ntfy.

Nascondiamo la form e mostriamo il player video, e aggiorniamo il link chiamato room_link in modo che l'utente possa copiare il link diretto alla stanza, compreso del topic. Il link sarà http//server/percorso/#topic.

Creiamo poi l'oggetto EventSource. EventSource è un oggetto del browser che implementa un client Server-side events. Una volta connesso, viene mantenuta la connessione aperta e ogni volta che il server genera un nuovo messaggio l'oggetto emette l'evento message che noi gestiamo nella funzione on_message() che vediamo sotto.

Questo ci permette di ricevere da ntfy i messaggi che il controllore invia al topic.

Per concludere la funzione, se è stato definito un url video, lo facciamo caricare al lettore.

Per chiudere il funzionamento della pagina per il controllore, gestiamo un po' di eventi.

Quando l'utente clicca su "Start", creiamo la stanza:

e_start_button.addEventListener("click", create_room);

Quando la posizione del lettore nel video cambia, emette l'evento 'timeupdate', se il tempo corrente è diverso di più di MIN_T, inviamo il messaggio di sync:

e_player.addEventListener("timeupdate", (event) => {
    if ( Math.abs(last_time - e_player.currentTime) > MIN_T ) send_message_sync();
});

Aggiorniamo lo stato del lettore quando passa a play o pausa, inviano un messaggio di sync. Inviamo "stop" quando il video finisce.

e_player.addEventListener("play", (e) => { 
    player_state = "play"; 
    send_message_sync();
});
e_player.addEventListener("pause", (e) => { 
    player_state = "pause";
    send_message_sync();
});
e_player.addEventListener("ended", (e) => { 
    player_state = "stop"; 
    send_message_sync(); 
});

E con questo abbiamo terminato la parte di codice che riguarda il controllore. Ora vediamo cosa ci serve per far funzionare gli altri partecipanti.

E gli spettatori?

Inanzitutto dobbiamo ricevere i messaggi inviati dal controllore e reagire di conseguenza. Quindi definiamo la funzione on_message() che gestisce l'evento message dell'oggetto EventSource:

function on_message(e) {

}

il parametro e è un oggetto che contiene i dettagli dell'evento. In questo caso ci sarà una proprietà data che sarà il json ricevuto dal server. Questo json contiene a sua volta una proprietà message che contiene il messaggio che il controllore ha effettivamente inviato al topic.

Una volta estratto quello possiamo reagire di conseguenza:

function on_message(evt) {
    let data = JSON.parse(evt.data);
    data = JSON.parse(data.message);

    switch(data.type) {
        case "sync":
            // il messaggio è di tipo sync
            // se sono il controllore, ho inviato io il messaggio,
            // non ho bisogno di reagire.
            if (im_control) return;

            // se il lettore video ha un indirizzo diverso da quello
            // nel messaggio, dobbiamo aggiornarlo
            // Questo permette agli spettatori di caricare il video
            // la prima volta che ricevono un messaggio di sync
            if (data.url != e_player.currentSrc) e_player.src = data.url;

            // se il mio lettore video è più di MIN_T lontano dalla posizione
            // del messaggio allora mi riposiziono.
            // questo lascia al player un po' di gioco per gestire ritardi di
            // buffering senza essere sempre spostato mentre cerca di recuperare
            // nuovi dati video.
            if (Math.abs(data.currenttime - e_player.currentTime) > MIN_T) {
                e_player.currentTime = data.currenttime;
            }

            // se lo stato del player del controllore è diverso da quello locale
            // aggiorniamoci!
            // se arriva lo stato stop, "scarico" il video dal lettore
            // impostando un url vuoto
            if (data.state != player_state) {
                switch (data.state) {
                    case "pause":
                        e_player.pause();
                        break;
                    case "play":
                        e_player.play();
                        break;
                    case "stop":
                        e_player.src = "";
                        break;
                }
            }

            break;
    }
}

L'utente spettatore per entrare nella chat deve utilizzare il link che riporta l'id della stanza come fragment.

Quindi al caricamento della pagina controlliamo se c'è un id nell'url, e nel caso avviamo la stanza:

let hash = window.location.hash.replace("#", "");
if (hash != "") {
    start(hash);
}

L'api javascript lo chiama hash. Il valore riporta anche il # iniziale, che togliamo. Quello che resta, se c'è, è l'id della nostra stanza, che quindi passiamo a start().

Rendiamo felice il browser

A questo punto abbiamo la possibiltà di creare una stanza con un player che sarà sincronizzato tra i vari spettatori, più o meno qualche secondo (ma nelle mie prove riesce ad essere abbastanza preciso).

Quando uno spettatore entra nella stanza il player non ha sorgente che verrà caricata al primo messaggio di sync.

Se il video si trova su un dominio differente, il fatto di caricare l'url via javascript potrebbe far scattare qualche estensione blocca-pubblicità. Non possiamo fare molto, salvo servire il file video dallo stesso dominio su cui si trova la pagina.

Al primo messaggio di sync che arriva con stato play, invochiamo e_player.play(). Questo fa sciuramente scattare la protezione del browser che blocca l'autoplay dei video. L'utente deve eseguire un'azione sul browser che porta a far partire il video, ma nel nostro caso non è così, e quindi viene bloccato.

Per bypassare il problema, aggiungiamo un div con un messaggio di avviso nell'html, giusto sotto il player video, e lo teniamo nascosto:

...
        <video id="player" class="hidden" controls>
        <!--👇 questo è nuovo -->
        <div id="alert" class="hidden">Per avviare il video premi "play"</div>
...

aggiungiamo una nuova variabile

let e_start_form = document.getElementById("start");
let e_video_url = document.getElementById("video_url");
let e_start_button = document.getElementById("start_button");
let e_player = document.getElementById("player");
let e_room_link = document.getElementById("room_link");
// 👇 questo è nuovo
let e_alert = document.getElementById("alert");

e modifichiamo la funzione on_message().

Ora se lo stato corrente locale è stop (stato in cui si trova lo script all'avvio), e il messaggio di sync riporta play mostriamo il messaggio di avviso.

            ...
            if (data.url != e_player.currentSrc) e_player.src = data.url;

            // 👇 questo è nuovo
            // il browser ci impedisce di passare da "stop" a "play" la prima volta
            // usando javascript, quindi mostriamo il messaggio di avviso
             if (player_state == "stop" && data.state == "play") {
                e_alert.classList.remove("hidden");
                return;
            }

            ...

E per terminare, nasconiamo il messaggio di avviso quando il lettore passa in play.

e_player.addEventListener("play", (e) => { 
    player_state = "play"; 
    send_message_sync();
    // 👇 questo è nuovo
    e_alert.classList.add("hidden");
});

Conlusioni e note

Ovviamente il codice qui descritto è pittosto semplice e non gestisce eventuali errori, così come non tiene conto di alcuni casi 'strani'.

Per esempio, nel caso il file sorgente sia un mp4 "frammentato", il browser non puo' sapere quanto è lungo tutto il video, ma solo quanto è lungo fino al frammento caricato. Diciamo che ogni frammento è un minuto di video, appena caricato il video il browser pensa che tutto il video duri un minuto. Poi a una successiva richiesta, riceve il frammento successivo ed ora pensa che duri due minuti.

Diciamo che il nostro "controllore" è a 1m39s, quindi già nel secondo frammento, quando uno spettatore si collega.

Appena collegato lo spettatore riceve un messaggio di sync che gli da l'url da caricare e lo fa saltare a 1m39s. Pero' il browser dello spettatore ha fin'ora caricato solo il primo frammento e quindi pensa che il video duri solo un minuto. Quindi il lettore salterà alla fine del frammento e andrà in stop, e il browser smetterà di chiedere nuovi frammenti, lasciando lo spettatore con il video fermo che non prosegue.

Vi lascio il piacere di risolvere questi problemi.

Un'altra cosa da notare è che utilizzare così ntfy.sh non è bello, ed è facile incappare nei limiti di richieste. Ma è comunque possibile installarsi il proprio server ntfy e farci ciò che si vuole.

Per ultimo, è chiaro che abbiamo accuratamente evitato di parlare di CSS, salvo per ciò che è utile al funzionamento (come la classe .hidden). Di CSS non ne parleremo proprio, lascio a voi il piacere di creare una veste grafica interessante.

Nel prossimo articolo proviamo ad aggiungere una chat.

Il codice scritto fin'ora lo trovate qui

Serata Lesana - un gestore di collezioni

2021-09-21T13:00:00+02:00

È online la presentazione del progetto Lesana e derivati tenuta durante la serata di giovedì 16 scorso.

I video sono pubblicati sul canale GL-Como su peertube.uno @glcomo@peertube.uno, che è possibile seguire con un account sul fediverso (Friendica, Mastodon, etc)

Lesana - un gestore di collezioni - parte 1

Lesana - un gestore di collezioni - parte 2

I link:

Lesana - https://lesana.trueelena.org/
Lesana Web : interfaccia web a una collezione Lesana - https://git.sr.ht/~fabrixxm/lesanaweb
Collector : applicazione Python/Gtk3 per getire una collezione Lesana - https://git.sr.ht/~fabrixxm/Collector

Serata su lesana, software di gestione di inventari

2021-09-14T10:00:00+02:00

Giovedì 16 settembre il GL-Como torna a fare serate a tema: stavolta l'argomento è lesana, un programma per gestire inventari di collezioni, come libri, musica, componenti di elettronica, abbastanza versatile da poter essere usato ad esempio per un issue tracker personale.

lesana è un programma da riga di comando ed una libreria python, e ne esistono già un'interfaccia grafica scritta in GTK e un visualizzatore web.

Saranno presenti gli autori di lesana e delle interfacce grafiche.

L'appuntamento è per giovedì 16 settembre 2021 alle 21:00 all'indirizzo

https://live.gl-como.it/view.html#GL-Como

dove saranno disponibili lo streaming e una chat per interagire con i relatori.

Maggiori informazioni su lesana si trovano sul sito del progetto:

https://lesana.trueelena.org/

Opencast Alpha n.51

2021-04-07T10:00:00+02:00

La puntata numero 51, con una parvenza di regolarità, dedicata all'imminente release di Debian Bullseye

Scarica: Ogg/Vorbis / Mp3

I links

I link di Opencast li trovate anche sulla Linkopedia

Abbiamo registrato con Mumble, ognuno a casa propria.

Installare un server minetest da usare con gli amici

2021-04-05T23:42:00+02:00

Dopo mesi di lockdown in cui si sono incontrati gli amici solo tramite videoconferenza (ovviamente sul proprio server jitsi), viene voglia di interagire di più, e cosa c'è di meglio che farlo in una comoda sala da té costruita su dei pioppi, o sul fondo di una miniera scavando ferro, oro, diamanti e MESE?

MESE? sì, sto parlando del minerale originale del mondo di Minetest, un gioco libero della stessa famiglia del proprietario Minecraft, in cui si interagisce in vari modi con un mondo composto da cubi di materiale vario.

Uno dei punti di forza di minetest è la varietà di mod disponibili (e la facilità con cui se ne possono scrivere di personalizzati, usando il linguaggio lua), per cui l'esperienza di gioco può essere resa molto diversa a seconda dei gusti dei partecipanti: un server può offrire uno spazio per costruire strutture, un'altro un mondo pieno di pericoli da esplorare ed un'altro ancora può dare spazio a giocatori che vogliono combattere tra di loro o contro mostri.

In questo articolo ci concentreremo soprattutto sulla prima opzione, ma dando indicazioni su cosa modificare se si preferiscono le altre due (o varie combinazioni).

Installazione

Partiamo come al solito da un'installazione di debian su una macchina che possa essere raggiunta da internet (la solita vps, o un SBC in casa con un router opportunamente configurato); ad aprile 2021 possiamo scegliere se usare buster (l'attuale stable) più buster-backports oppure bullseye, la prossima stable di imminente rilascio.

Installiamo quindi il server minetest ed altri strumenti utili:

# apt install -t buster-backports minetest-server minetestmapper

e poi la selezione di mod che vogliamo usare, ad esempio:

# apt install -t buster-backports \
      minetest-mod-basic-materials minetest-mod-craftguide \
      minetest-mod-homedecor minetest-mod-unifieddyes \
      minetest-mod-moreblocks minetest-mod-moreores

Quindi passiamo a configurare il nostro server modificando il file /etc/minetest/minetest.conf: di sicuro vogliamo modificare nome (server_name), descrizione (server_description) e volendo il messaggio mostrato al collegamento (motd), e possiamo scegliere se vogliamo annunciare il server sull'elenco comune dove chiunque possa giocarci (per iniziare, o comunque se si vuole giocare solo con i propri amici, conviene lasciare server_announce = false) e se impostare una password comune per poter entrare nel server (default_password).

Decidiamo poi, nello stesso file, che tipo di esperienza di gioco vogliamo avere, impostando creative_mode (true per far sì che i giocatori abbiano a disposizione tutti i materiali senza doverli andare a cercare, false per la modalità classica in cui li si deve trovare e scavare), enable_damage (utile se si vuole rendere pericolosa l'esplorazione o si vuole fare combattimento) ed enable_pvp (per il combattimento tra giocatori).

Inoltre in default_privs impostiamo che privilegi devono avere di default i giocatori: il minimo consueto è interact, shout, ma in un mondo incentrato sulla costruzione più che sull'esplorazione può essere utile aggiungere anche fly, fast, home. La wiki di minetest documenta i privilegi a disposizione.

Infine, impostiamo il nome di un giocatore che avrà i privilegi di admin, nella variabile name.

A questo punto passiamo nella directory del mondo, /var/games/minetest-server/.minetest/worlds/world/ e configuriamo quali mod vogliamo abilitare in world.mt; può essere necessario fare un po' di prove, dato che le dipendenze non vengono abilitate automaticamente, ma ad esempio questa è una combinazione funzionante con i mod installati prima:

load_mod_unifieddyes = true
load_mod_moreores = true
load_mod_moreblocks = true
load_mod_plasmascreen = false
load_mod_lavalamp = false
load_mod_building_blocks = false
load_mod_homedecor_3d_extras = false
load_mod_lrfurn = false
load_mod_homedecor = true
load_mod_inbox = false
load_mod_basic_materials = true
load_mod_itemframes = false
load_mod_computer = false
load_mod_craftguide = true
load_mod_currency = true
load_mod_fake_fire = false
load_mod_homedecor_i18n = true

Infine, riavviare minetest-server per applicare le modifiche:

# service minetest-server restart

Primi passi nel mondo

A questo punto, sul proprio pc, installare il gioco minetest (in debian il pacchetto minetest e collegarsi al server usando il nome utente che si è selezionato come admin, ricordandosi di cambiare la password (con il comando /setpassword) appena entrati.

Dopo aver esplorato un po' si può scegliere un posto da cui partire con la costruzione: lo si può impostare come propria “casa” usando il comando /sethome, ma può anche valere la pena di impostarlo come punto di partenza per tutti i giocatori: premere F5 per abilitare la modalità di debug e scoprire le coordinate in cui ci si trova, quindi tornare sul server, modificare static_spawnpoint in /etc/minetest/minetest.conf e riavviare nuovamente il server.

Ulteriori comandi utili sono documentati sulla wiki di minetest.

Ulteriori migliorie

Mappa del mondo

Il comando /usr/games/minetestmapper può essere usato per generare una mappa generale di tutto quanto è mai stato esplorato; può essere una buona idea aggiungere a crontab una riga come:

05 8,16,0 * * * /usr/games/minetestmapper -i /var/games/minetest-server/.minetest/worlds/world/ -o /var/www/minetest/world_map.png --drawscale

per rigenerare la mappa ogni 8 ore, lasciandola in una directory dove può essere servita da un eventuale server web presente sulla macchina.

“backup”

Per avere una forma minimale di backup, possiamo sfruttare git: creiamo un repository nella directory del mondo:

# cd /var/games/minetest-server/.minetest/worlds/world/
# git init

e poi impostiamo a crontab un commit automatico quotidiano:

14 4 * * * cd /var/games/minetest-server/.minetest/worlds/world/ ; git add . ; git commit -m 'daily commit'

Da un altro computer facciamo poi un clone di questo repository, e mantenendo aggiornato quel clone potremo recuperare il mondo in caso di catastrofi.

Come proseguire

A questo punto si è pronti per passare la password del server ai propri amici ed iniziare a giocare, il che probabilmente vuol dire che non si avrà più tempo per ulteriori configurazioni :)

Se invece si riesce a mantenere l'autocontrollo, queste sono alcune idee di migliorie su cui si può lavorare.

Ulteriori mod

I mod disponibili per minetest-sono estremamente numerosi e vari: la maggior parte viene pubblicata sul forum di minetest, ma una buona selezione di mod scelti per la loro qualità e affidabili può essere ottenuta cercando i mod che sono stati pacchettizzati per debian con il comando:

$ apt search minetest-mod

l'elenco è troppo lungo per parlarne in questo articolo, ma una buona idea può essere quella di installarli localmente sul proprio pc, provarli su un mondo single player e installare sul server ciò che si è trovato particolarmente interessante.

In alternativa, se tra i propri amici ci sono dei giocatori di minetest, di sicuro avranno un elenco di mod che trovano interessanti da suggerire.

Più mondi sullo stesso server

Il pacchetto debian di minetest-server è predisposto per poter gestire più mondi: per farlo basta creare una nuova configurazione in /etc/minetest/<nome>.conf e far partire il server con systemctl start minetest-server@pvp.service; sarà necessario usare una porta diversa, e ulteriori dettagli si possono trovare nel file /usr/share/doc/minetest-server/README.Debian installato dal pacchetto del server.

Backend più adatti a server affollati

Il backend di default di minetest è sqlite3, che non è in grado di scalare e supportare server con molti utenti: se si pensa di averne bisogno sono disponibili ulteriori backend come redis o postgresql, la cui configurazione è spiegata sempre sulla wiki di minetest.

Ovviamente, in questo caso non sarà più possibile usare git per effettuare un backup del mondo, ma sarà necessario avere una strategia di backup più tradizionale.

Conclusione

Qui avrebbe dovuto esserci una conclusione, ma chi doveva scriverla era impegnato a giocare…

Opencast Alpha n.50

2021-03-02T10:00:00+01:00

La puntata numero 50, la puntata d'oro!

Non pensavate che ci saremmo arivati? Nemmeno noi, e invece eccoci qui!

Una puntata dedicata al giovane mondo di linux sugli smartphone: parleremo di pinephone, cosa funziona, cosa ancora non funziona, le nostre esperienze.

Scarica: Ogg/Vorbis / Mp3

I links

PinePhone
Librem 5
Mobian
Manjaro
Lista dei SO disponibili per il PinePhone
Phosh
Plasma Mobile
ReText
Xournal
Xournal++, una versione riscritta ed aggiornata di Xournal (non è stato testato, nel caso fateci sapere!)
Confy
ConfClerk
VLC
Dino
Gajim
Cawbird
Tootle
Anbox
Anbox sul wiki di mobian

Abbiamo registrato con Mumble, ognuno a casa propria.

Opencast Alpha n.49

2021-02-12T23:00:00+01:00

Dopo anni di silenzio audio (ma non video), una nuova puntata di OpenCast!

Dopo la prima edizione interamente online di FOSDEM, raccontiamoci com'è andata, cosa abbiamo visto e cosa ci siamo segnati da rivedere!

Scarica: Ogg/Vorbis / Mp3

I links

I link di Opencast li trovate anche sulla Linkopedia

Abbiamo registrato con Mumble, ognuno a casa propria.

Controllo vocale delle luci di casa

2020-08-09T16:00:00+02:00

Avendo in casa una lampada "smart" della serie Trådfri di IKEA a fare poco di "smart", un computer con linux, ed essendo capitato sul sito di voice2json.org mi son detto: perchè non fare due più due più due?

Ed ecco il risultato! (cinque... oh no.)

Step 1: controllare le luci

Cominciamo col poter controllare le luci da riga di comando.

Cosa serve:

Una lampadina "smart" della serie Trådfri di IKEA
Il suo gateway, già accoppiato e testato
Un computer con linux
bash, grep, sed
coap-client (debian: libcoap2-bin, AUR: coap-client)
lo script "tradfri" che trovate qui https://git.sr.ht/~fabrixxm/tradfri-cli/blob/master/tradfri

Salviamo lo script in una cartella appropriata, p.e. ~/tradfri/ e lo rendiamo eseguibile.

Da console lo eseguiamo una prima volta per fargli creare il file di configurazione vuoto: ~/tradfri/tradfri.rc.

Editiamo il file di configurazione e inseriamo l'ip e il codice del gateway. Possiamo anche inserire un nome utente a scelta, o lasciare che lo script ne generi uno a caso.

Eseguiamo ancora lo script per fare login. Teoricamente dovrebbe salvare in automatico la chiave di sessione nel file di configurazione, ma non funziona. La chiave viene stampata a terminale e dovremmo copiarla nel file di configurazione a mano.

Ora possiamo verificare che funzioni:

$ ~/tradfri/tradfri info

per avere informazioni sul gateway

$ ~/tradfri/tradfri devicelist

per avere un elenco degli id dei devices collegati al gateway

$ ~/tradfri/tradfri deviceinfo <id>

per avere i dettagli di ogni device. Cerchiamo quello che corrisponde alla lampadina. Nel mio caso è il device con id 65538

Proviamo ad accendere e spegnere la lampadina:

$ ~/tradfri/tradfri light <id> on
$ ~/tradfri/tradfri light <id> off

Se tutto funziona ora dovremmo poter controllare la lampadina.

Impostiamo un alias, un nome, per la lampadina. Diciamo che è la lampadina del salotto. La chiameremo quindi "salotto".

Per impostare l'alias creiamo il file ~/tradfri/aliases.rc e ci scriviamo dentro:

salotto=<id>

sostituendo l'id con quello della nostra lampadina. p.e:

salotto=65538

Ora possiamo controllare la lampadina riferendoci al suo nome:

$ ~/tradfri/tradfri light salotto on
$ ~/tradfri/tradfri light salotto off

Step 2: controllo vocale

serve:

lo stesso computer dello step 1
microfono e (opzionalmente) casse
aplay
python
pazienza

Installiamo voice2json seguendo la guida qui: http://voice2json.org/install.html

è disponibile un pacchetto debian che non ho provato, ma la compilazione da sorgente non è complicata.

Il profilo in italiano da scaricare è qui https://github.com/synesthesiam/it_pocketsphinx-cmu/releases

Possiamo seguire la guida di voice2json per vedere che funzioni.

Ho trovato che nel profilo in italiano il frasario (il contenuto del file senteces.ini) non funziona benissimo, in particolare la parola "lampada" non viene riconosciuta. Si puo' sostituirla con la parola "luce" e rilanciare il training per avere risultati migliori.

Una volta che voice2json funziona, possiamo mettere assieme i pezzi.

Innanzitutto modifichiamo il file senteces.ini per adeguarsi alle nostre esigenze. Cambiamo il contenuto in:

[ChangeLightState]
light_state = (accendi | spegni){state}
light_name = (soggiorno | garage){name}

<light_state> [la] luce (in|del) <light_name>

Il nuovo file imposta quindi un solo "intent" (ChangeLightState) e definisce il nome delle lampade con una sola parola.

Perchè l'accrocchio funzioni, i nomi delle lampade in questo file devono corrispondere ad almeno un alias del file ~/tradfri/aliases.rc.

Seguendo questa guida abbiamo definito l'alias soggiorno e quindi potremmo dire "accendi la luce del soggiorno" o "spegni la luce in soggiorno".

Scarichiamo lo script listen.sh, lo salviamo in ~/tradfri/ e lo rendiamo eseguibile.

Lo apriamo con un editor di testo per modificare i primi due percorsi:

il percorso all'eseguibile di voice2json
il percorso allo script tradfri

Ci servono anche tre file di suoni, che troviamo qui che vanno salvati in ~/tradfri/sounds/

nota: vi sarete accorti che arriva tutto da un repo git. Per fare più in fretta, possiamo clonare il repo https://git.sr.ht/~fabrixxm/tradfri-voice e scaricare così lo script, i suoni e il file senteces.ini da copiare nel profilo.

E lo eseguiamo.

Lo script resterà in attesa della frase di attivazione ("Hey, Mycroft"), stampando a terminale "Waiting for wake word...".
Quando riconosce la frase di attivazione, esegue un suono di notifica e resta in ascolto del comando (p.e. "accendi la luce del soggiorno").
Terminato l'ascolto del comando, emette un nuovo suono di notifica e tenta di riconosce ed eseguire il comando.
Se l'operazione va a buon fine vedremo accendersi la luce del soggiorno!
Altrimenti un nuovo suono di notifica che segnala un errore viene emesso.
Il ciclo poi si ripete e lo script si rimette in attesa della frase di attivazione.

Link e riferimenti

voice2json.org : Command-line tools for speech and intent recognition on Linux
tradfri-cli : a WiP commandline client for tradfri gateway
tradfri-voice : Experimental tradfri light voice control
ikea-tradfri-coap-docs

nota: questo post non è sponsorizzato in nessuna maniera da IKEA, la quale è proprietaria del marchio "Trådfri"