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

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) {
}

Partenza Maratona Firenze 2016

Anche quest'anno servizio volontario alla partenza.

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

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)

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