giovedì 1 dicembre 2016

Notifiche cloud con Firebase su Android

In questo post viene descritto come usare il cloud di Firebase per mandare notifiche push su dispositivi Android.

Per prima cosa ci si deve registrare, anche con account gratuito, sulla console di firebase e si crea un progetto



si crea quindi una nuova applicazione. E' possibile creare applicazione per Android ed IOS. In questo caso si sceglie Android


per creare l'applicazione e' richiesto il solo nome del pacchetto Android


a questo punto si clicca sul pulsante con i tre puntini sovrapposti e si visualizza la configurazione SDK



e si scarica il file google-services.json che dovra' essere copiato nella directory /app del proprio progetto

si crea quindi un progetto Android usando il nome del pacchetto gia' fornito nella configurazione di Firebase


build.gradle (Project)
-------------------------------------

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.2'        
        classpath 'com.google.gms:google-services:3.0.0'
        // NOTE: Do not place your application dependencies here; they belong        // in the individual module build.gradle files    }
}

allprojects {
    repositories {
        jcenter()
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}
-------------------------------------

build.gradle (Module: App)
-------------------------------------
apply plugin: 'com.android.application'
android {
    compileSdkVersion 23    
    buildToolsVersion "23.0.3"    
    defaultConfig {
        applicationId "com.lucainnocenti.notifica.notifica"        
        minSdkVersion 21        
        targetSdkVersion 23        
        versionCode 1        
        versionName "1.0"        
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"    }
    buildTypes {
        release {
            minifyEnabled false            
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'        }
    }
}

dependencies {
    compile 'com.google.firebase:firebase-messaging:10.0.0'    
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'    })
    compile 'com.android.support:appcompat-v7:23.4.0'    
   testCompile 'junit:junit:4.12'}

apply plugin: 'com.google.gms.google-services'
-------------------------------------



AndroidManifest.xml
-------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"    package="com.lucainnocenti.notifica.notifica">

    <application        android:allowBackup="true"        android:icon="@mipmap/ic_launcher"        android:label="@string/app_name"        android:supportsRtl="true"        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

    <service        android:name=".MyFirebaseMessagingService" android:exported="false">
        <inter-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </inter-filter>
    </service>

    <service        android:name=".MyFirebaseInstanceIdService" android:exported="false">
        <inter-filter>
            <action android:name="com.google.firebase.MESSAGING_ID_EVENT" />
        </inter-filter>
    </service>
</manifest>
-------------------------------------



MyFirebaseMessagingService.java
-------------------------------------
package com.lucainnocenti.notifica.notifica;

import android.util.Log;

import com.google.firebase.iid.FirebaseInstanceIdService;
import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

/** * Created by root on 29/11/16. */
public class MyFirebaseMessagingService extends FirebaseMessagingService{
    private static final String TAG="MyFMService";

    @Override    public void onMessageReceived(RemoteMessage remoteMessage)
    {
        Log.d(TAG,"ID :"+remoteMessage.getMessageId());
        Log.d(TAG,"Notification :" +remoteMessage.getNotification());
        Log.d(TAG,"Data : "+remoteMessage.getData());

    }
}
-------------------------------------

MyFirebaseInstanceIdService.java
-------------------------------------
package com.lucainnocenti.notifica.notifica;

import android.util.Log;

import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.FirebaseInstanceIdService;
import com.google.firebase.messaging.FirebaseMessaging;

/** * Created by root on 29/11/16. */
public class MyFirebaseInstanceIdService extends FirebaseInstanceIdService {
    private static final String TAG="MyFirebaseIIDService";
    private static final String FRIENDLY_ENGAGE_TOPIC = "friendly_engange";



    @Override    public void onTokenRefresh(){
    String token = FirebaseInstanceId.getInstance().getToken();
    Log.d(TAG,"Token " + token);
        FirebaseMessaging.getInstance().subscribeToTopic(FRIENDLY_ENGAGE_TOPIC);
    }

}
-------------------------------------

Una volta compilata ed installata l'applicazione si crea un messagggio dall'interfaccia web della Firebase Console dal menu Notification
Si possono creare diverse regole. La cosa piu' semplice e' mandare il messaggio a tutti gli utenti che hanno installato l'applicazione impostando il solo identificativo del pacchetto (altrimenti per creare dei messaggi personalizzati bisogna conoscere gli identificativi unici dei vari client)


Non e' possibile avere un QoS .. in pratica si sa se il messaggio e' stato inviato dal server ma non quanti sono stati consegnati regolarmente

Per inviare messaggi non e' strettamente necessaria l'interfaccia Web. Si puo' utilizzare anche il comando curl da riga di comando

Per prima cosa si clicca sull'icona dell'ingranaggio vicino al nome del progetto e si selezionano le impostazioni del progetto, si seleziona Cloud Messaging e si copia la Server Key (nel futuro si dovra' usare il token ovvero il codice sottostante)


e si lancia poi il seguente comando inserendo la
---------------------------------------
curl --insecure --header "Authorization: key=XXXXXXXXXXXX" --header "Content-Type:application/json" -d "{\"notification\":{\"title\":\"note-Title\",\"body\":\"note-Body\"}}" https://fcm.googleapis.com/fcm/send
---------------------------------------



Arduino 101 a Foligno

In occasione del recente sisma a Norcia il mio ente ha richiesto ai geologi di un servizio volontario di protezione civile presso le aree colpite dal sisma. Con l'occasione volevo provare a vedere se l'accelerometro integrato in Arduino 101 era in grado di registrare i movimenti del terreno. Il luogo di pernottamento era presso Foligno dove e' presente anche una stazione sismica che pubblica i dati su Internet ed era quindi la posizione ideale per la calibrazione


visto il rumore dell'accelerometro, la minima accelerazione valida registrata era superiore a 0.03g (maggiore del 3% dell'accelerazione di gravita')

lo sketch impiegato e' stato semplicemente quello degli esempi della IMu di Curie

--------------------------------
#include "CurieIMU.h"

void setup() {
  Serial.begin(9600); // initialize Serial communication
  while (!Serial);    // wait for the serial port to open

  // initialize device
  Serial.println("Initializing IMU device...");
  CurieIMU.begin();

  // Set the accelerometer range to 2G
  CurieIMU.setAccelerometerRange(2);
}

void loop() {
  float ax, ay, az;   //scaled accelerometer values

  // read accelerometer measurements from device, scaled to the configured range
  CurieIMU.readAccelerometerScaled(ax, ay, az);

  // display tab-separated accelerometer x/y/z values
  Serial.print("a:\t");
  Serial.print(ax);
  Serial.print("\t");
  Serial.print(ay);
  Serial.print("\t");
  Serial.print(az);
  Serial.println();
}

/*
   Copyright (c) 2016 Intel Corporation.  All rights reserved.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*/

--------------------------------
dato che Arduino non ha un Real Time Clock ho usato uno script Python per aggiungere il timestamp ai dati di accelerazione
sisma.py
---------------------------
#!/usr/bin/env python
import time
import datetime
import serial

port = serial.Serial("/dev/ttyACM0", baudrate=9600, timeout=3.0)

base_datetime=datetime.datetime(1970,1,1)

while True:
    millis=int(round(time.time()*1000))
    delta = datetime.timedelta(0,0,0,millis)
    target_date=base_datetime+delta
    print target_date,
    print "\t",
    rcv = port.readline()
    print rcv[:-2]
---------------------------
con poi uno script bash per lanciare il tutto

---------------------------
#!/bin/bash
nome=$(date '+%F--%T').log
/home/luca/sisma.py > /home/luca/$nome
---------------------------

il sistema ha lavorato per oltre 48 ore ma, nonostante la stazione sismica avesse registrato diversi eventi (tutti di modesta entita' sicuramente sotto al 4°§) , i dati della Arduino non mostravano niente di significativo


Dati registrati da Arduino


Esempio dati sismografo Foligno Monte Pale http://www.iesn.it/index.php/eventi-iesn/umbria/foligno-pg.html
La spiegazione e' venuta da questo grafico empirico che correla la magnitudine con l'accelerazione (in cm/sec2). Come si vede per avere una accelerazione di almeno 0.03g (29 cm/sec2) sono necessari sismi di almeno il 5° Richter

http://www.ingegneri.info/forum/viewtopic.php?f=2&t=44944







mercoledì 30 novembre 2016

Mqtt con Arduino e Centos 7 ed Android

Ho voluto provare ad usare il protocollo MQTT, attualmente al centro dell'attenzione per InternetOfThings.
Si tratta di un protocollo molto leggero sull'occupazione di banda per lo scambio di messaggi (applicabile anche a sistemi di chat come per esempio Facebook Messenger) con la logica sottoscrizione/pubblicazione di messaggi su un canale. I client ricevono i messaggi in modalita' push




per installare il server MQTT su Centos si procede con
yum install mosquitto

e si apre la porta 1883 del firewall per accettare connessioni dall'esterno
firewall-cmd --zone=public --add-port=1883/tcp permanent

si lancia quindi il server dalla linea di comando
mosquitto

da linea di comando per pubblicare un messaggio (dati) con l'identificativo luca/inno (dato che e' in localhost non e' necessario specificare l'indirizzo del server)
mosquitto_pub -t "luca/inno" -m "dati" -q 1 -r

su un altro terminale si puo' lanciare il comando per sottoscrivere i messaggi del server
mosquitto_sub -t "luca/inno"
e si osservano i messaggi scorrere

Si puo' utilizzare una Arduino MKR1000 (o simile con connettivita' di rete) per pubblicare i dati mediante la libreria MQTT utilizzando il seguente script (in giallo le linee di codice specifiche di MQTT)
-----------------------------------------------------------
#include <SPI.h>
#include <WiFi101.h>

#include <MQTTClient.h>


char ssid[] = "Android";     //  your network SSID (name)
char pass[] = "XXXXXXXXXXXXXX";  // your network password
int status = WL_IDLE_STATUS;     // the Wifi radio's status

WiFiClient net;
MQTTClient client;
unsigned long lastMillis = 0;



void setup() {
  Serial.begin(9600);

  // check for the presence of the shield:
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue:
    while (true);
  }
connect();

}

void connect(){
    // attempt to connect to Wifi network:
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to WPA SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network:
    status = WiFi.begin(ssid, pass);

    // wait 10 seconds for connection:
    delay(10000);
  }

  // you're connected now, so print out the data:
  Serial.print("You're connected to the network");
  printCurrentNet();
  printWifiData();

  client.begin("192.168.43.4", net);

  Serial.print("\nconnecting...");
  while (!client.connect("luca", "", "")) {
    Serial.print(".");
    delay(1000);
  }

}

void loop() {
  client.loop();

  // publish a message roughly every second.
  if(millis() - lastMillis > 1000) {
    lastMillis = millis();
    if (WiFi.status() != WL_CONNECTED)
          {
          connect();
          //printCurrentNet();
          }
     client.publish("luca/inno", "dati");
     Serial.println("Inviato");

  }
  
  
}

void printWifiData() {
  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);
  Serial.println(ip);

  // print your MAC address:
  byte mac[6];
  WiFi.macAddress(mac);
  Serial.print("MAC address: ");
  Serial.print(mac[5], HEX);
  Serial.print(":");
  Serial.print(mac[4], HEX);
  Serial.print(":");
  Serial.print(mac[3], HEX);
  Serial.print(":");
  Serial.print(mac[2], HEX);
  Serial.print(":");
  Serial.print(mac[1], HEX);
  Serial.print(":");
  Serial.println(mac[0], HEX);

}

void printCurrentNet() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print the MAC address of the router you're attached to:
  byte bssid[6];
  WiFi.BSSID(bssid);
  Serial.print("BSSID: ");
  Serial.print(bssid[5], HEX);
  Serial.print(":");
  Serial.print(bssid[4], HEX);
  Serial.print(":");
  Serial.print(bssid[3], HEX);
  Serial.print(":");
  Serial.print(bssid[2], HEX);
  Serial.print(":");
  Serial.print(bssid[1], HEX);
  Serial.print(":");
  Serial.println(bssid[0], HEX);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.println(rssi);

  // print the encryption type:
  byte encryption = WiFi.encryptionType();
  Serial.print("Encryption Type:");
  Serial.println(encryption, HEX);
  Serial.println();
}

void messageReceived(String topic, String payload, char * bytes, unsigned int length) {
}

venerdì 18 novembre 2016

Amazon Button Tear Down

E' da pochi giorni disponibile in Italia per l'acquisto l'Amazon Button, un dispositivo che permette (in pieno stile IoT) di effettuare acquisti su Amazon con la sola pressione di un tasto.
Grazie all'amico G.S. e' tempo di procedere allo smontaggio



il dispositivo e' facilmente accessibile tramite viti (TORX) e connessioni a scatto e presenta una comoda con alimentazione a batteria di tipo AAA



Quella che e' venduta in Italia risulta essere la revisione 2 della scheda che si differenzia di molto rispetto alla Rev.1 commercializzata negli USA gia' da piu' di un anno (e per la quale esistono gia' molti hack per prendere possesso del dispositivo)


Un primo aspetto importante: rispetto alla versione 1, sulla quale era possibile saldare dei connettori di programmazione per il JTAG, in questa PCB ci sono i punti di saldatura ma non e' presente il chip di programmazione ed interfaccia.
E' presente una connettivita' sia WiFi che BT4
I chip che sono montati, in particolare il microprocessore, sono di particolare interesse
Microcontrollore : Atmel ATSAMG55J19A-MU
 WiFi : Atmel ATWINC1500B
 BT : Cypress CYBL10563-68FNXI

Considerando il tipo di utilizzo il microcontrollore e' un mostro da 120 MHz con SPI, I2C, 8 canali analogici  con ADC a 12 bit

mercoledì 16 novembre 2016

50 anni dall'Alluvione di Firenze

Con qualche giorno di ritardo sull'annivesario alcune foto d'epoca sull'alluvione del 1966

Angolo del bar in Via Erbosa 93A 

Immagine attuale da una prospettiva differente


Ex negozio Coop via Erbosa 34 (L'acqua era arrivata fino a sopra il terrazzo)


Via Erbosa 87 (la finestra del primo piano e' completamente sommersa)

Via Erbosa 87 (l'acqua inizia a scendere)





lunedì 14 novembre 2016

Autografo di Eugene Cernan (Apollo 10, Apollo 17)

E' un periodo che mi sto interessando alle missioni di esplorazione lunare, in particolare leggendo i libri scritti di proprio pugno dagli astronauti (per adesso Gene Cernan, Walter Cunningham ed il controllore di volo Eugene Kranz)

Visto il costo spesso non trascurabile se su Amazon e' presente una copia usata, e' sempre benvenuta


La sorpresa e' stata tanta quando aprendo Last Man on the Moon di Cernan ho trovato la copia autografata dall'astronauta stesso.


Oltre al valore aggiunto di carattere non monetario, c'e' da dire che un libro firmato da un astronauta aumenta in modo significativo anche il suo valore pecunario. Come si vede dal "listino prezzi" una firma di Cernan e' quotata dallo stesso 300 dollari



lunedì 31 ottobre 2016

Nexus 7 e consumo anomalo di batteria

Sono un felice possessore di Nexus 7 ma da oltre un anno ho notato un problema che me lo rendeva sostanzialmente inutilizzabile ovvero il consumo anomalo della batteria (spento alla sera,sottolineo spento e non in stand-by al 90% la mattina dopo era praticamente privo di carica). Stanco di questo problema, pensando che la batteria originale fosse oramai esaurita (anche se a fronte di uno scarso utilizzo) ho deciso di ordinarne una nuova


Visto che pero' la batteria e' stata comprata su un e-commerce cinese e' passato un bel po' di tempo prima di averla tra le mani e mi e' venuta la strana idea di resettare il Nexus 7 al suo firmware originale....incredibilmente sono spariti tutti i problemi di batteria.
A questo punto mi e' venuto il forte sospetto che l'anomalia era derivata dal passaggio da Android 4 (firmware originale) al 5....evitando di aggiornare il sistema il Nexus 7 e' tornato come nuovo e mi trovo una batteria inutilizzata

mercoledì 26 ottobre 2016

Frane a Pelago

Durante i periodo di tesi (e per le escursioni) mi sono trovato spesso a percorrere la strada che da Pontassieve porta alla Consuma e mi sono sempre chiesto il motivo della forma del versante indicato dalla freccia.


Da un estratto del Piano Strutturale del Comune di Pelago Tav. G.02 Novembre 2013 aggiornato a marzo 2014 l'area di interesse (al centro dell'immagine sottostante) e' circondato da orli di scarpata e corone di frana attive ed inattive


Guardando nella parte basale del pendio si vede quelli che sembrano gli accumuli al piede della frana

A questo punto mi sono incuriosito se si osservano movimenti dall'analisi dei permanent scatterers. I dati sono pubblici ma non facilmente reperibili. Si deve andare sul portale cartografico nazionale, selezionare il servizio WMS (il tema non e' listato in basso) e cercare Progetto Permanent Scatterer (http://wms.pcn.minambiente.it/pst) per poi selezionare la propria area (Firenze) ed il satellite di riferimento (ERS o CSK Cosmo SkyMed)


Da questa immagine non sembra che vi sia attivita' di versante



Windows for legacy PC

Quando pensi di averle viste piu' o meno tutte in ambito informatico viene subito sconfessato. Solo in questi giorni sono venuto a conoscenza di Windows for Legacy PCs,  un progetto del 2006 per far girare Windows XP su hardware obsoleto, ovvero Pentium a 200 MHz con 128 Mb di ram (a cui e' poi succeduta una versione di Windows 7 con la stessa politica)


Il fatto che non la conoscessi dipende anche dal fatto che non si tratta di una versione di vendita al dettaglio (era venduta solo per volumi a grosse industrie)
La cosa piu' curiosa e' che non e' presente Internet Explorer


Al momento pero' questa cosa va piu' nel capitolo curiosita' che in quello delle cose utili perche' anche se uno riuscisse a trovare una licenza di installazione il sistema avrebbe solo gli aggiornamenti di Service Pack2

Da Peccioli ad Houston

In in precedente post avevo parlato della roccia lunare in esposizione a Peccioli mettendo l'accento sull'eta' dichiarata di 4 milioni di anni specialmente in relazione alla geologia lunare


del resto pero' avevo letto la scheda petrografica del campione (qui) che riportava la seguente tabella


e per quanto strano avevo accettato la datazione (potevano essere stati compiuti due errori dalla Nasa su due documenti di cui uno ufficiale??)

A distanza di 5 mesi ho ripreso in mano l'argomento e curiosando su internet ho trovato il sito geologialunare.it curato dal Dr. G. Turdo con cui ho avviato una corrispondenza via mail sull'argomento a cui ha gentilmente risposto (grazie mille) facendomi notare che nello stesso documento alla stessa pagina poco piu' in alto della tabella c'era il seguente grafico


in cui viene chiaramente indicata la data in b.y. (miliardi di anni) e non m.y (milioni di anni)...scemo io a non vederlo.

A questo punto ho scritto una mail al Lunar Sample Facility Laboratory che, in stile pienamente USA, mi ha risposto nel giro di un paio di giorni confermandomi l'errore e che la targhetta sarebbe stata corretta una volta che il campione rientrava nel loro laboratorio dopo le esposizioni a giro per  il mondo...concludendo con un invito a visitare il loro laboratorio ad Houston come ringraziamento

venerdì 21 ottobre 2016

ADXL335 come tiltmetro

Questo e' una verifica se si puo' usare ADXL335 come misuratore di angoli affidabile.
Per ottenere la misura degli angoli il sensore deve essere fermo; a questo puo' si puo' utilizzare la scomposizione del vettore forza di gravita' per misurare gli angoli di pitch e roll

Per effettuare la verifica e' stato impiegato un tavolo di laboratorio inclinabile con una vite senza fine. Per ottenere una misura piu' precisa dell'angolo di inclinazione non e' stato usato un goniometro ma sono stati impiegate le misure dei due cateti dell'angolo in modo da ricavare l'angolo come arctangente


In generale e' stato osservato che in condizioni statiche la misura dell'angolo ha una deviazione standard di 0.25° decimale dal valore medio.

Plottando i dati dell'angolo misurato come arctg e da ADXL335 (entrambe le misure non sono da considerarsi particolarmente raffinate...nonostante l'uso di un calibro le misure delle distanze si sono rivelate piuttosto difficoltose)



Faglia bordiera del bacino di Firenze

Fin dai tempi dell'Universita' mi e' stata chiara la genesi del bacino di Firenze ma ultimamente mi sono reso conto che non sapevo ubicare effettivamente la posizione e non avevo nemmeno l'idea se ci fossero delle evidenze geomorfologiche....ho scoperto che ho sempre avuto sott'occhio questa struttura tettonica senza di fatto riconoscerla.

Per trovare la posizione della struttura, vista la sua dimensione, si parte semplicemente dai dati SRTM


Dopo averli banalmente elaborati in QGis si vede chiaramente la rottura di pendio che e' stata contraddistanta dalla linea blu. Sovrapponendo la foto area di Google Maps per avere dei riferimenti la situazione e' piu' o meno questa


Dato che abito in zona Fiesole ho zoomato nell'area per vedere se potevo riconoscere qualcosa di familiare. La rottura di pendio e' posta in prossimita' di S.Domenico


Andando sulla strada che da Firenze porta a Fiesole, fermandosi tra l'ospedale di Camerata e S.Domenico e guardando in direzione Est, si ossserva chiaramente l'andamento della struttura (da mangiarsi i gomiti....ci saro' passato mille volte)


Per conferma ho cercato qualcosa a riguardo in bibliografia. Qui e' evidenziato il sistema tettonico completo e si vede che la faglia risalta ancora di piu' perche' si trova al contatto tra i depositi Plio-Pleistocenici e il Macigno

Coli Rubellini 2007

Coli Rubellini 2013



venerdì 14 ottobre 2016

Settaggio proxy su Linux

per impostare i settaggi del proxy si puo' esportare il valore delle variable http_proxy ed https_proxy da linea di comando ma queste impostazioni lavorano solo a livello della sola shell aperta.

Per impostare i settaggi del proxy a livello di tutto il sistema (per esempio per fare girare bene Chrome) si puo' editare il file /etc/environment

-----------------------------------------------------------------
http_proxy="http://myproxy.server.com:8080/" 
https_proxy="http://myproxy.server.com:8080/" 
no_proxy="localhost,127.0.0.1,localaddress,.localdomain.com" 
------------------------------------------------------------------

e si riavvia il servizio della rete

venerdì 7 ottobre 2016

AKAI LPK25 e ZynAddSubFx

Sulla base del precedente tentativo, ho accoppiato la AKAI LPK25 ad un altro synth software disponibile su Linux ovvero ZynAddSubFx

La procedura e' leggermente differente perche', dopo aver attivato il sintetizzatore, da consolle si digita

aconnect -o



Ci si appunta i numeri di dispositivo dei client (in questo caso la tastiera come input ed il synt come output) e si collegano di due dispositivi con
aconnect nr_client1 nr_client2
nel caso acconnect 24 128


mercoledì 5 ottobre 2016

AKAI LPK25 con Linux

Il blog rinasce in una nuova veste abbondando l'elettronica ed interessandosi di tutto un po' con piu' attenzione alla musica

In questo post viene descritto come interfacciare una LPK25, un midi controller a basso costo con una estensione di due ottave (l'altezza e' modificabile con un Octave +/-)


Il dispositivo su Ubuntu viene immediatamente riconosciuto come dispositivo MIDI over USB

Per poterci suonare, essendo una tastiera priva di suoni, si deve utilizzare un sintetizzatore software (fluidsynth con interfaccia grafica QSynth) e da un programma che connette la tastiera al sintetizzatore (in questo caso vmpk). Tutti questi programmi si possono installare mediante apt-get.

Prima di iniziare a suonare ci sono un po' di impostazioni da fare. Si parte da QSynth entrando in setup (pulsante in basso a sinistra) abilitando l'input Midi sul primo tab


Nel tab Audio si setta il driver Alsa


e poi dove e' inserito il file dei suoni nel tab Soundfonts

Si avvia QSynth e ci si sposta su Virtual MIDI Piano Keyboard e dal menu Edit/Connections e si seleziona come Input MIDI la LPK25



















mercoledì 31 agosto 2016

LLama3 Anita

A seguito di questo post ho provato a vedere ho provato a vedere cosa accadeva ad utilizzare un modello specifico per la lingua italiana in...