RTKLib e GPS L1/L5 Pixel 6

Aggiornamento

Questo e' il migliore risultato dopo alcune prove

Visto il servizio EUREF che distribuisce dati GNSS sia in formato Rinex che NTRIP (RTCM 3) ho voluto provare ad usare la app Geo++ RINEX su un Google Pixel 6 per vedere come funziona la banda L5 in accoppiata  alla classica L1

I dati della stazione di base che ho preso a rifeirmento derivano dalla stazione

https://epncb.oma.be/_networkdata/siteinfo4onestation.php?station=IGMI00ITA

che si trova a Firenze. 

     City or Town             : Firenze
     State or Province        : TOSCANA
     Country or Region        : ITA
     Tectonic Plate           : EURASIAN
     Approximate Position (ITRF)
       X coordinate (m)       : 4523251.085
       Y coordinate (m)       : 896760.233
       Z coordinate (m)       : 4391796.488
       Latitude (N is +)      : +434744.34
       Longitude (E is +)     : +0111249.69
       Elevation (m,ellips.)  : 95.1

in Rtkpost Options/Positions si devono le coordinate ECEF della stazione riprese dalla tabella soprastante

 

i file delle osservazioni della stazione base dell'IGM vengono forniti in formato CRX e RNX 

Per utilizzare il formato CRX in RTKLIB si puo' usare il tool CRX2RNX (https://terras.gsi.go.jp/ja/crx2rnx.html) che dal file CRX porta ad un file OBS. Per quanto riguarda il file RNX basta rinominarlo (dentro c'e' il NAV in formato Rinex)

 

 Queste sono le impostazioni delle Options di RTKLib (per un corretto funzionamento ho dovuto usare i files di RTKLIB Demo5 http://rtkexplorer.com/downloads/rtklib-code/ , Le librerie RTKLib che si scaricano in APT da Debian sono obsolete e non riconoscono i nuovi formati dati ed i nuovi sensori

questo il riultato di una acquisizione speditiva

Ho provato a seguire le istruzioni https://rtklibexplorer.wordpress.com/2021/02/27/another-look-at-l1-l5-cellphone-ppk-with-rtklib/ dove l'autore scende a circa +/-10 cm di precisione m

Io non sono sceso sotto al metro

Emulatore Android su Apple M1

Attualmente Android Studio non e'compatibile con Apple M1 in particolare per quanto riguarda l'emulatore che richiede le estensioni VTX (le app si possono sempre compilare ed eseguire su dispositivi fisici) E' comunque possibile installare in modo separato l'emulatore in beta da https://github.com/google/android-emulator-m1-preview

Prima di utilizzarlo si deve in ogni caso indicare la posizione di adb che normalmente si trova in /Users/lucainnocenti/Library/Android/sdk/platform-tools

Scansioni codici QR in Kotlin Android

Nel 2013 avevo fatto qualche esperimento con la lettura dei codici a barre tramite la libreria ZXing.

Ad oggi le funzioni di scansioni dei codici sono incluse nelle librerie di Google Play ma le trovo complicate mentre la libreria ZXing (https://github.com/zxing/zxing) e' in maintenance mode. Ho trovato una alternativa a questo link    https://github.com/yuriy-budiyev/code-scanner

build.gradle(app)

implementation 'com.budiyev.android:code-scanner:2.1.0'

Layout

=====================================================

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <FrameLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <com.budiyev.android.codescanner.CodeScannerView
            android:id="@+id/scanner_view"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:autoFocusButtonColor="@android:color/white"
            app:autoFocusButtonVisible="true"
            app:flashButtonColor="@android:color/white"
            app:flashButtonVisible="true"
            app:frameColor="@android:color/white"
            app:frameCornersSize="50dp"
            app:frameCornersRadius="0dp"
            app:frameAspectRatioWidth="1"
            app:frameAspectRatioHeight="1"
            app:frameSize="0.75"
            app:frameThickness="2dp"
            app:maskColor="#77000000"/>
    </FrameLayout>

</androidx.constraintlayout.widget.ConstraintLayout>

=====================================================

codice

=====================================================

    val scannerView = findViewById<CodeScannerView>(R.id.scanner_view)

    codeScanner = CodeScanner(this, scannerView)

    // Parameters (default values)
    codeScanner.camera = CodeScanner.CAMERA_BACK // or CAMERA_FRONT or specific camera id
    codeScanner.formats = CodeScanner.ALL_FORMATS // list of type BarcodeFormat,
    // ex. listOf(BarcodeFormat.QR_CODE)
    codeScanner.autoFocusMode = AutoFocusMode.SAFE // or CONTINUOUS
    codeScanner.scanMode = ScanMode.SINGLE // or CONTINUOUS or PREVIEW
    codeScanner.isAutoFocusEnabled = true // Whether to enable auto focus or not
    codeScanner.isFlashEnabled = false // Whether to enable flash or not

    // Callbacks
    codeScanner.decodeCallback = DecodeCallback {
        runOnUiThread {
            Toast.makeText(this, "Scan result: ${it.text}", Toast.LENGTH_LONG).show()
        }
    }
    codeScanner.errorCallback = ErrorCallback { // or ErrorCallback.SUPPRESS
        runOnUiThread {
            Toast.makeText(this, "Camera initialization error: ${it.message}",
                Toast.LENGTH_LONG).show()
        }
    }

    scannerView.setOnClickListener {
        codeScanner.startPreview()
    }
}

override fun onResume() {
    super.onResume()
    codeScanner.startPreview()
}

override fun onPause() {
    codeScanner.releaseResources()
    super.onPause()
}

Decrittare PGP in Kotlin per Android

Un comodo sistema per decrittare messaggi PGP con Kotlin su Android e' quello di usare la libreria https://github.com/Tlaster/KotlinPGP che in pratica e' un wrapper per BountyCastle 

in build.gradle(app)  si aggiunge

 

implementation 'moe.tlaster:kotlinpgp:1.0.20'

il codice e' sostanzialmente autoesplicativo per quanto e' semplice

=================================================

package com.luca.innocenti.pgp_k2

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import moe.tlaster.kotlinpgp.KotlinPGP

class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
var segreta = "-----BEGIN PGP PRIVATE KEY BLOCK-----\n" +
"\n" +
"lQPFBF9CQ3QBCADVYsnRyqe+2oiaLyZjXzhayQ+GAoGD80jynlwnZQxbSR7thnkz\n" +
"IMg0BtzzQtJMS1Iim/4WRqivWKLRXWupYPMPbH9/6sgAfHnCTfuLtnHDNgfW7A5s\n" +
"GnJQ9/1L9WsS+q8zoSIc8KJ6NCAuYVu3G5hsOwI29GVbh+y0Vr+Bw/QxZbAxS4A2\n" +
"MJhsOsUFU6fJgIjGOwp2Yeie9Bw8cs7CRRhoqYlnbDx1zAmfwLH2VYcAo5PeDLwi\n" +
"KPnKn0i3oBb27eQ5ruYV757m5j8PM75CLlnEeV367LLOYj6nQM3kKoq1Lpc9AOTv\n" +
"vDUOWpF979klsBXM8dxClFZ/PHz3j1LD6DuHABEBAAH+BwMCn6zXeF315vD/wHHD\n" +
"7YaSYS2kpgW4ELMRCQEzLgPRtFRaJIsMYPPiy2Ofc8NGjKA4DwLroKuT6+nSlNiy\n" +
"SrOQh1Lc+J+OZVftDfcyYhFlW222Zpr/0uRVOir1XRNkWC+fy3N03axd/JDb+qXH\n" +
"By3mV/zl563itPQj1NVk3iKDph5dAp0svAMBxDdQORx/XmtqqdIBnAfrBM5S6Trs\n" +
"shYitQ10tFWROu9GKgbbDt1DFSojOOpRLy2OLPBOo6EQiYjTKn6+KHlfk6hixSoa\n" +
"nY/F9mG80Wu+o74DLW5AvzTbY573PyrOWisDXM/r0/EPfTrT7Zu/afRr7+tv5R26\n" +
"/D1dUN+MnTx45/+mBpTFLArmlh9pxUQwlPUjoO+PJc2N/ThIeIp3XcjdEIV0Xety\n" +
"TqO6ruQ8q3iqG9hm/ARwbP09kJszHZmUHatnWJb2JjQaCYa+Hr4rCXq8lMtPR4HI\n" +
"Wf33lh4/anOxjhshxyyNab8HXCb0bWEMliIk05nXdoX+cq2bMr7hX9K9alGURWxo\n" +
"0Qzq7x0069Mwc6m3OHMYRpbBHi+13ug1FROieyP/pcS497hOxuolF8m+UtZqE9+o\n" +
"/zq1MQdZLJG8u8Qx4jrDoqNUyVQLU1nwV6CF6Ev3pxv0wGMHFWlZoZit0mNNraTi\n" +
"3b8oSDNCi5j9lvi8axaaK5/mchUJ4Lh3kWxY1xvaxOZccav0KKSqJka8CZVVMQJe\n" +
"PDHwCdJRVHs63ieF0Se9+s4upxPTqwdaRjspy2Nn0D5UMytyJrf+SLlCZ5qYfyPf\n" +
"TfdRGCku2sAp1EUbc5oqjukTWfgl62XSeWOhzbK+ABC5Y3rVHeM4i3d1v2hvywJs\n" +
"7vjIzEPs6xEdpoEDuVuj22VrPpqNq5tYIqB+HvIN4hECp2F/21N8AFbhRT5N7EFW\n" +
"bnnpJMFI58K0H0RldjRIZWFsdGggPGluZm9AY29kZW1vdGlvbi5pdD6JAU4EEwEK\n" +
"ADgWIQSKlM4/rvOrumHZe3V4sj4ziH+dlwUCX0JDdAIbAwULCQgHAgYVCgkICwIE\n" +
"FgIDAQIeAQIXgAAKCRB4sj4ziH+dl0gqCAC/HiaXvmAMGPlashl0KIJQoV49vsnB\n" +
"YV+SsXnFQ0moRISQ/uZQKTc/4jiDmQgmBsVfVggXik1B+ebg9obN/hQC7t3qUlIB\n" +
"49t+j4bgnCEIeKKxt2eTAZ2D6pSkBKCoA4Nx5/uwINDYwtYpcMv7hde04/hmK2l4\n" +
"DBbltM2YY54yGjHgNkX4bb2PNq3tzmlK9Qha0ihnzxbyr50DbYNbYy1+Tu5oStUu\n" +
"6X/ezx2pzbrJM0FU8FXp/lrYby1Q7UnLGRhBTBKclMJo1qaVqtBrldFEBb/mfkwO\n" +
"miQhuc/NZy5P5+JzHJ3Xcn0Zb63kdSqOVcRHtarZHbajj2PxJlsu9BoBnQPGBF9C\n" +
"Q3QBCADHCeE1HaTpc94+2sNvQ+on/nf8KjPdy1AM/MdZ2BccWMr6IgzASt24Z20C\n" +
"hiR2DL8OgrghDVttOjAq0HvcKVeY1I/QbmfYOBYXPqvpAHOMs3h6xAgnl0P0Vojo\n" +
"upypxvv5XLpVbZT3o/KjOpD3hDUy+WbEUy9oe6HfGUzzy2g0qZ5Usardb11I0fpJ\n" +
"R74aNwVdB7rBK4SMNSS5vE/5ygzq3BdfblJ8FYtgzqlqQEeJipznXUj/RVNLPRFV\n" +
"04AQVHOoDe2S/+v2/cx22b37e/vUDnaM0pCs3kg+wXLNVL3DuzMaen/Q2UF/E2kR\n" +
"C3Nz8+jFARtb22y0qLZ1KPBxQnINABEBAAH+BwMCKJbrhc0ea4z/ECsxLBycoH1n\n" +
"LoFEIQbHd4tdoYDUorJG8pn0JsYbFUtgPk4/lKFMdXBiHAisG/UPQ1P00Y2rhpbt\n" +
"2H6wiWOe12hva1CQjqp4LmvE3t/D3chVuuTnuo49Em8xp4ZtxUQfohBnQGy7COGM\n" +
"lfPmN2zdZbLfZ50jyaf0rU59GdWA/NzSYHs5kJRZL5906tbmWFZQVphReQFhH18Z\n" +
"8TAB54M+27ZkoDWxQzRJfeypSS+cIFVPpRrcWjFdFy5jNNEvXSggEwjxKDf+/Op5\n" +
"zAuvn4QF76DVExNkQEgUr23b3m4SUDXoJOjj8fAMNzJsKJhvwJQS85aLg/gIzqbD\n" +
"Du+uPWH7xLRjQyeuqkiZHrxrzpS1nyQIKTVgg+zyfKr89ffBBDpxw/ALL3rZo1wv\n" +
"NX9hAcExR1I4lS3BRqNwrIsWmbcD5dV3EhSNTErmZFUv/rMFrU5X9/WPW9dE4jJt\n" +
"ILxkFxUdhMKwvyjYhxBUAeuKGwKlAxytxvXZDUv5xfX3LeFYyIJDSiTEzoI5/y/v\n" +
"9EeCdb6dYhyiChcbr2B1FiNIgubiUaRw1uNcQgr9dlO9Ee3EeCUBAeKmjMKc9YWF\n" +
"sncVuF2XEnGnZaE3rZBqfJUSysjtD7cc8FSn+7Y/Bx3HI/r5e5KtpD1BK7Zk4tNn\n" +
"r+As0EM4kYsdcN7Be5L7ptwv8LNZA099p8v0OJtDwO3h3frImby6+uJHl0M1JLmu\n" +
"noplQSNowydDbXX2H13/v6kF3E+LwR8310Blv+lqSN3ZRjX4+HUYo/cmOWbKKxHZ\n" +
"G0lHbRP88HethLQ4+F/8WDFcMtRurnBGhqhYTUU3EPYTsAEQFWfAaLORKpQcU9Ep\n" +
"tgCI3TSAviFRxJVxiNCsBDubpukkZ94wbiZsxeNvjFHN+Ejhxw8SfoyHvbchb0mA\n" +
"y0ZyiQE2BBgBCgAgFiEEipTOP67zq7ph2Xt1eLI+M4h/nZcFAl9CQ3QCGwwACgkQ\n" +
"eLI+M4h/nZfoQwf7BGcEl2znkyPcwOkLYzd65xwdZRHccjnTA5zQK8F6kKSOQ7XD\n" +
"LMQUA4tyIYhItZ1ImET90mC8wnoEZPyWuS2NtvBidCvJzGVHflJQkeMfIRJI86Sd\n" +
"SawIV2ydAgo+XXiBVKHobAoFeiO0EaZb7hcOf4FMc+o+UAaacGquwL4k7hkyo9sy\n" +
"ngRBaBmteyyqfP2b9+EGDmknNU2mB8nzjUyeyT1C6xlC+aSjPvISyVXovPhQ6mxY\n" +
"l2IiN27/Ixmqb+JgIDvp6Qb4ZTPQ1ctlfLFn0eekmJ9IGqH0fNct8rMVHI5zq114\n" +
"1XGfLXE+Y3U1WlFWF19aWRB054bdz5DDgBjIbw==\n" +
"=7ffe\n" +
"-----END PGP PRIVATE KEY BLOCK-----"

var encryptedData:String = "-----BEGIN PGP MESSAGE-----\n" +
"Version: OpenPGP.js v4.10.4\n" +
"Comment: https://openpgpjs.org\n" +
"\n" +
"wcBMA8AU2yvA99UdAQf+MylbvwaDMuqBneUH8kfMhq5CxCiUwORkZ4sE7/e+\n" +
"CIb+XTc5wYCuTIIqsv8JfcCjLs6fSwjlvEcvjSAn08geiIrquiBbgnkBWPR7\n" +
"iv7CMt6LPzcKfuHt18ZZarEQEf4mwH/DxU+ohYqXpRIuAVbGbcR1n1qWPkto\n" +
"hWDQQLXFZ/fAYKdZekA+SdvISrzpEbS+yy5y0K035oD0aqee6Up93jARvHTk\n" +
"R7kWuBCFoMk23PDTZM+Hv9DNumOXIOm/avZfbVr4I0O0LYlCaq1QOkmV1sfq\n" +
"P2lLD2cGgYp0c6VeLCb9/bbZx/UXPBiakXS3dH09jDE7zUXvk9mrPFz3YlA5\n" +
"M9I/AViN02M0pF83CYzDqCkJ4GkzjAv50bXWzn4ZS0nNR1dl9rY/Ve6KSGiV\n" +
"kTRtpLQ17TI1awzTg4wyifMkrYNW\n" +
"=xPR8\n" +
"-----END PGP MESSAGE-----"

val decrypt = KotlinPGP.decrypt(segreta, "password", encryptedData)
Log.d("test", decrypt.result)

}
}

Da Arduino ad Internet tramite Android

Avevo la necessita' di collegare una Arduino Nano 33 BLE ad internet ma non avevo molte idee quando ho pensato di usare come ponte un telefono Android

La Arduino e' contenuta nella scatolina bianca 

Per leggere i dati della porta seriale di Arduino ho collegato un cavo OTG alla USB di Android usando la libreria https://github.com/felHR85/UsbSerial. I dati poi sono stati inviati in HTTP Get tramite OKHttp. Il progetto della applicazione Android si trova sul mio GitHub https://github.com/c1p81/Seriale (si tratta di una modifica dell'esempio della libreria UsbSerial)

Questo e' invece lo skecth Arduino

=========================================================
#include <Arduino_LSM9DS1.h>
#include <Arduino_HTS221.h>
#include <Arduino_LPS22HB.h>
#include <Arduino_APDS9960.h>

int conteggio;

void setup() {
  conteggio = 0;
  Serial.begin(9600);
  while (!Serial);

  if (!IMU.begin()) {
    Serial.println("Failed to initialize IMU!");
    while (1);
  }

  if (!HTS.begin()) {
    Serial.println("Failed to initialize humidity temperature sensor!");
    while (1);
  }

  
  if (!BARO.begin()) {
    Serial.println("Failed to initialize pressure sensor!");
    while (1);
  }

   if (!APDS.begin()) {
    Serial.println("Error initializing APDS9960 sensor.");
  }

}

void loop() {
  float  x, y, z;
  double dx,dy,dz;
  double mx,my,mz;
  double fx,fy,fz;
  double pitch,roll = 0.0;
  double mpitch,mroll = 0.0;
  const float alpha = 0.5;

  float pressure = BARO.readPressure();
  float temperature = HTS.readTemperature();
  float humidity    = HTS.readHumidity();

   while (! APDS.colorAvailable()) {
    delay(5);
  }
  int r, g, b, light_int;

  APDS.readColor(r, g, b, light_int);

  

  if (IMU.accelerationAvailable()) {
    IMU.readAcceleration(x, y, z);
    dx = (double)x;
    dy = (double)y;
    dz = (double)z;
    
    mx = mx + dx;
    my = mx + dy;
    mz = mx + dz;
    
    fx = (dx*alpha) + (fx*(1-alpha));
    fy = (dy*alpha) + (fy*(1-alpha));
    fz = (dz*alpha) + (fz*(1-alpha));

    conteggio++;
  }

  if (conteggio > 10000)
      {
        mx = mx /conteggio;
        my = my /conteggio;        
        mz = mz /conteggio;
        
        roll = atan2(fy,fz)*57.29577;
        pitch = atan2(-fx,sqrt((fy*fy)+(fz*fz)))*57.29577;

        mroll = atan2(my,mz)*57.29577;
        mpitch = atan2(-mx,sqrt((my*my)+(mz*mz)))*57.29577;

        Serial.println(String(mpitch)+";"+String(mroll)+";"+String(pitch)+";"+String(roll)+";"+String(temperature)+";"+String(humidity)+";"+String(pressure)+";"+String(light_int));
        conteggio = 0;
        fx = fy = fz = 0;
        mx = my = mz = 0;
      
      }

  
  delay(10);
  //delay(5000);
}

=========================================================

I dati sono plottati sul server mediante JSCanvas. Gli script si trovano qui https://github.com/c1p81/Seriale/tree/master/app/seriale_html

Android Studio WiFi Adb Plugin

Per programmare con Adb via WiFi si puo' fare in vari modi

Usando un plugin (la via piu' comoda) si puo' installare un plugin di Android Studio da File/Settings/Plugins e scegliendo per esempio Android WiFi ADB

Si aggiungera' una icona (in verde chiaro al centro nell'immagine successiva)

Si collega il telefono via USB agganciandosi alla stessa WiFi del portatile. Si clicca sull'icona, si attende la connessione e successivamente si puo' disconnettere il cavo USB

Altrimenti da shell si possono inviare i seguenti comandi

A cavo USB attaccato si digita

adb shell setprop service.adb.tcp.port 4444

adb tcpip 4444
adb connect ip_telefono:4444

OkHttp per Android

Per utilizzare chiamate HTTP in un progetto Android basato su Java (per Kotlin una libreria comoda e' Fuel ) si puo' utilizzare OKHttp anche se e' cosi' immediato utilizzarla

Per aggiungere la libreria al progetto si edita build.gradle(progetto) aggiugendo la riga in giallo

allprojects {    repositories {        google()
        jcenter()
        maven { url "https://jitpack.io" }            }}

e si aggiunge la libreria indicata dalla riga in giallo

dependencies {    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation 'androidx.appcompat:appcompat:1.1.0'    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'    testImplementation 'junit:junit:4.12'    androidTestImplementation 'androidx.test.ext:junit:1.1.1'    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
    implementation 'com.github.felHR85:UsbSerial:6.1.0'    implementation("com.squareup.okhttp3:okhttp:4.5.0")}

Per prima cosa si aggiunge il permesso di accesso ad Internet nel Manifest

<uses-permission android:name="android.permission.INTERNET" />

In seguito si crea un directory xml in res e si crea un nuovo file XML denominato network_security_config.xml con i permessi di accesso alla rete

Per esempio qui si abilita il traffico HTTP (HTTPS e' default) verso tutti i domini
network_security_config.xml
-----------------------------------------

<?xml version="1.0" encoding="utf-8"?><network-security-config xmlns:android="http://schemas.android.com/apk/res/android">    <base-config cleartextTrafficPermitted="true" />
</network-security-config>

-----------------------------------------

Si torna al Manifest e si aggiunge la riga in giallo

<application    android:allowBackup="true"    android:icon="@mipmap/ic_launcher"    android:label="@string/app_name"    android:networkSecurityConfig="@xml/network_security_config"    android:roundIcon="@mipmap/ic_launcher_round"    android:supportsRtl="true"

il metodo standard per implementare la chiamata e' creare una classe

public static class senddata {
    OkHttpClient client = new OkHttpClient();
    String run(String url) throws IOException {
        Request request = new Request.Builder()
                .url(url)
                .build();
        try (Response response = client.newCall(request).execute()) {
            return response.body().string();        }
    }
}

e poi chiamare il metodo per esempio in GET

senddata invio = new senddata();try {
    String response = invio.run("http://XXX.XXXX.XXX.XXX/seriale/index.php?stringa="+data.toString()+"&batteria="+percentage);} catch (IOException e) {
    e.printStackTrace();}

JSON con GSON e Kotlin

Per leggere un file Json con Kotlin si puo' utilizzare la libreria GSON aggiungendo il gradle.build la seguente linea

implementation 'com.google.code.gson:gson:2.8.6'

facciamo per esempio che il file JSON ha il seguente tracciato

    val json = "{'cicli':26,'soglia': 1.5}"

si deve creare una classe che ricostruisce il tracciato record e crea dei metodi per leggere le proprieta'

class imposta(
    var cicli:Int = 0,
    var soglia:Float = 0.0f) {
            fun Get_cicli():Int {
                return cicli
            }

            fun Get_soglia():Float {
                return soglia
            }
            override fun toString(): String {
                return "${this.cicli}, ${this.soglia}"
            }
    }

dopo si cio' si puo' chiamare la funzione .fromJson per poter popolare le variabili

override fun onCreate(savedInstanceState: Bundle?) {
    ...........

    val json = "{'cicli':26,'soglia': 1.5}"


    var impostazioni = Gson().fromJson(json, imposta::class.java)
    var prova = impostazioni.Get_cicli()
    Log.d("imposta", impostazioni.toString())
    Log.d("imposta", prova.toString())

Errore Pitch, Roll, Azimuth su Android Nexus 5

Volevo fare un po' di test sull'accuratezza dei dati degli accelerometri di un telefono (nello specifico un Nexus 5) e per fare cio' mi sono scritto questa applicazione in Kotlin che cerca di disabilitare il Doze Mode per fare lavorare in continuo la app

Di seguito i risultati

Ogni punto sul grafico e' dato dalla media di 20000 misure ed e' rappresentativo di circa 7.5 minuti

Misura 1
nr punti : 144
durata minuti : 1080
Std.dev pitch : 0.33 gradi decimali
Std.dev roll : 0.36 gradi decimali
St.dev azimuth : 0.65 gradi decimali


Misura 2
nr punti : 39
durata minuti : 273
Std.dev pitch : 0.1 gradi decimali
Std.dev roll : 0.09 gradi decimali
St.dev azimuth : 0.067 gradi decimali

Misura 3
nr punti : 122
durata minuti : 812
Std.dev pitch : 0.19 gradi decimali
Std.dev roll : 0.17 gradi decimali
St.dev azimuth : 0.1 gradi decimali

Misura 4
nr punti : 84
durata minuti : 574
Std.dev pitch : 0.4 gradi decimali
Std.dev roll : 0.14 gradi decimali
St.dev azimuth : 0.21 gradi decimali


In generale la standard deviation rimane sotto (anche abbondantemente) a 0.5 gradi decimali.. non male

L'unico aspetto che mi ha lasciato un po' perplesso e' il fatto che durante la prova 4 le misure evidenziano un chiaro trend crescente

Database su Android con Room e Kotlin

Il nuovo approccio per avere un database persistente su Android e' quello di utilizzare Room

Per integrare la libreria nel progetto Android si deve modificare il file build.gradle (app) aggiungendo il plugin kapt in testa

apply plugin: 'com.android.application'apply plugin: 'kotlin-android'apply plugin: 'kotlin-android-extensions'apply plugin: 'kotlin-kapt'

ed aggiungendo le seguenti dipendenze (questo sono le dipendenze per Kotlin, nel caso di uso di Java la terza riga, quella che inizia con kapt, deve essere sostituita con

annotationProcessor "androidx.room:room-compiler:$room_version"

==============================

def room_version = "2.2.5"
implementation "androidx.room:room-runtime:$room_version"kapt "android.arch.persistence.room:compiler:$room_version"
// optional - Kotlin Extensions and Coroutines support for Roomimplementation "androidx.room:room-ktx:$room_version"
// Test helperstestImplementation "androidx.room:room-testing:$room_version"
annotationProcessor "android.arch.persistence.room:compiler:1.0.0"

La gestione delle chiamate Rooms avviene per SQL

In sintesi viene definito il tracciato record del database. Da notare che non sono esplicitamente previsti campi DateTime; per questo motivo uso lo Unix Time come Long
Il nome dell'unica tabella e' nome_tabella

Le query sono incluse nella sezione DAO. Ogni query riporta un int che dice quante righe sono state interessate dalla query stessa

Nella sezione Database viene collegata la tabella al Db
Attenzione: se si cambia il tracciato record deve essere modificato il numero di versione del Db
Il nome del file e' inserito in DatabaseBuilder

Le query vengono gestite all'interno di coroutine

Per copiare il database dal telefono al PC si puo' usare

adb -d shell "run-as com.luca.innocenti.roomdb cat /data/data/com.luca.innocenti.roomdb/databases/sensori.db" > /home/luca/room.db

dove com.luca.innocenti.roomdb e' il nome del package mentre sensori.db e' il nome del file
database sul telefono
Altrimenti da Android Studio si va su View/Tool Windows/Device File Explorer

Per leggere il file su desktop si puo' utilizzare DB Browser for SQLite

package com.luca.innocenti.roomdb

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import androidx.room.*
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {

    @Entity(tableName = "nome_tabella")
    data class TabellaEntity(
            @PrimaryKey(autoGenerate = true)
            var id: Int,            @ColumnInfo(name = "tempo") var tempo: Long = 0,            @ColumnInfo(name = "pitch") var pitch: Float = 0.0f,            @ColumnInfo(name = "roll") var roll: Float = 0.0f,            @ColumnInfo(name = "azimuth") var azimuth: Float = 0.0f,            @ColumnInfo(name = "nota") var nota: String

    )

    @Dao    interface DbDao {
        @Query("SELECT * FROM nome_tabella")
        fun getAll(): List<TabellaEntity>

        @Query("SELECT * FROM nome_tabella WHERE nota LIKE :nota")
        fun findByNota(nota: String): List<TabellaEntity>

        @Insert        fun insertAll(vararg todo: TabellaEntity)

        @Delete        fun delete(todo: TabellaEntity)

        @Query("DELETE FROM nome_tabella WHERE id = :id")
        fun getSingleRecordDelete(id: Int): Int

        @Query("UPDATE nome_tabella SET nota=:nota WHERE id = :indice")
        fun getSingleRecordUpdate(nota: String, indice: Int): Int


        @Update        fun updateDb(vararg todos: TabellaEntity)
    }

    @Database(entities = [TabellaEntity::class], version = 1)
    abstract class AppDatabase : RoomDatabase() {
        abstract fun DbDao(): DbDao
    }


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)


        val db = Room.databaseBuilder(
                applicationContext,                AppDatabase::class.java, "sensori.db"        ).build()

        GlobalScope.launch {            db.DbDao().insertAll(TabellaEntity(0,12,13.4f,7.7f,0.3f,"Nota"))
            db.DbDao().insertAll(TabellaEntity(0,13,13.4f,7.7f,0.3f,"Nota2"))

            var data = db.DbDao().getAll()

            data?.forEach {                Log.d("test", it.toString())
            }
            var ricerca = db.DbDao().findByNota("Nota")
            ricerca?.forEach{                Log.d("ricerca", ricerca.toString())
            }
            db.DbDao().getSingleRecordDelete(6)

            data = db.DbDao().getAll()
            data?.forEach {                Log.d("dopo", it.toString())
            }
            db.DbDao().getSingleRecordUpdate("modifica",6)

            data = db.DbDao().getAll()

            data?.forEach {                Log.d("dopo", it.toString())
            }
            //db.clearAllTables()            db.close()
        }    }
}

Accensione automatica da ricarica di telefoni Android

Per un nuovo progetto avevo bisogno di una funzione che trovo molto comoda su IPhone, ovvero l'avvio automatico da spento quando viene inserito il cavo USB collegato alla corrente, e che non avevo trovato su Android

Lo scopo poi e' quello di avviare in automatico una applicazione una volta terminato il boot

Frugando ho trovato che questa opzione e' facilmente disponibile nei Nexus con semplici comandi da fastboot

./adb reboot bootloader
./fastboot oem off-mode-charge 0
./fastboot reboot

A questo punto per rimuovere il lock screen di Android si va in Impostazioni/Sicurezza/Blocco schermo/nessuno

A questo punto sarebbe interessante avviare in automatico un app (od un servizio)
Per fare una prova ho usato Nexus 5 con Android 6 perche' le versioni piu' recenti
di Android rendono piu' difficile lanciare una app al boot in automatico

Si vede modificare il Manifest (righe evidenziate in giallo)

AndroidManifest.xml
============================================

<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android"    package="com.luca.innocenti.autoboot">    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

    <application        android:allowBackup="true"        android:icon="@mipmap/ic_launcher"        android:label="@string/app_name"        android:roundIcon="@mipmap/ic_launcher_round"        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>

        <receiver
            android:name=".BootReceiver"
            android:enabled="true"
            android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED" />
            <action android:name="android.intent.action.QUICKBOOT_POWERON" />
        </intent-filter>
    </receiver>

    </application>
</manifest>

============================================

Nella MainActivity si crea una nuova classe che riceve la notifica dell'avvenuto boot
(per vedere se il codice funziona si osservi logcat, non ci sono messaggi per l'utente)


MainActivity.kt
============================================

package com.luca.innocenti.autoboot
import android.content.BroadcastReceiverimport android.content.Contextimport android.content.Intentimport android.content.Intent.ACTION_BOOT_COMPLETED
import androidx.appcompat.app.AppCompatActivityimport android.os.Bundleimport android.util.Log
class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

class BootReceiver : BroadcastReceiver() {

    override fun onReceive(c: Context, intent: Intent?) {
        val action = intent?.action        Log.d("ASD123123", "RECEIVED BOOT")
        val b = intent?.toUri(Intent.URI_INTENT_SCHEME)
        when (action) {
            ACTION_BOOT_COMPLETED -> startWork(c)
        }
    }


    private fun startWork(context: Context) {
        Log.d("Test", "Test")
    }
}

Flutter webview

Ultimamente sto avendo parecchie noie da Play Store perche' alcune mie vecchie applicazioni realizzate con PhoneGap vengono ritenute pericolose per vulnerabilita' delle librerie contenute in phonegap e vengono rimosse in automatico. Ho cosi' cercato in giro un framework alternativo con caratteristiche simili a PhoneGap ed ho voluto provare a convertire una mia app PhoneGap in Flutter (anche perche' essendo un prodotto Google spero che non eliminino le app dallo store se compilate con Flutter)

Per installare Flutter si inizia scaricando il pacchetto del framework da questo link
Si scompatta e si mette in path la directory /flutter/bin
Per editare i progetti si puo' usare Android Studio aggiungendo i plugin di Flutter e Dart da Preferences (CTRL+ALT+S) e poi Plugin/Marketplace

Si crea quindi un nuovo progetto Flutter

si modifica il file pubsec.yaml per inserire la dipendenza dal plugin flutter_webview

dependencies:
  flutter:
    sdk: flutter
  flutter_webview_plugin: ^0.3.10+1

modificare il file pubspec.yaml per includere le directory di assets della

(attenzione che:
- le varie righe devono essere indentate in modo corretto
- deve essere creata una riga per ogni subdirectory contenuta in assets
- la directory assets non viene creata di default

flutter:

assets:
  - assets/
  - assets/css/
  - assets/altimetria/
  - assets/img/
  - assets/imgit/

per confronto questa e' parte dell'albero assets del mio progetto

Alla fine si crea popola con la webview e si fa puntare la url ai file locali

main.dart

import 'package:flutter/material.dart';
import 'package:flutter_webview_plugin/flutter_webview_plugin.dart';
void main() {
  runApp(new MyApp());}

class MyApp extends StatefulWidget{
  _MyAppState createState() => _MyAppState();}

class _MyAppState extends State<MyApp> {
  @override  Widget build(BuildContext context) {
    return new MaterialApp(
        home: new WebviewScaffold(
          url: "file:///android_asset/flutter_assets/assets/index.html",        ),        debugShowCheckedModeBanner: false,    );  }
}

BLE Write Characteristic da Android

Dopo il precedente tentativo di leggere una caratteristica BLE da Python adesso un tentativo di scrivere una caratteristica (lo so e' una brutta traduzione) da Android su un dispositivo BLE

Lo sketch Arduino e' stato modificato per esporre una caratteristica 2A30 in modalita' lettura/scrittura, settare il valore a 3, leggere il valore e se e' differente da 3 spengere il Led di Arduino

=================================================================
#include <ArduinoBLE.h>

BLEService numero("180F");
BLEUnsignedCharCharacteristic casuale("2A19",BLERead | BLENotify); 
BLEUnsignedCharCharacteristic scrittura("2A30",BLERead | BLEWrite); 


long previousMillis = 0;  
byte test =3 ;

void setup() {
  Serial.begin(9600);  
  while (!Serial);
  pinMode(LED_BUILTIN, OUTPUT); 
  if (!BLE.begin()) {
    while (1);
  }

  BLE.setLocalName("Random");
  BLE.setAdvertisedService(numero); 
  numero.addCharacteristic(casuale);
  numero.addCharacteristic(scrittura);
  
  BLE.addService(numero); 
  casuale.writeValue(0); // set initial value for this characteristic
  scrittura.writeValue(2);
  BLE.advertise();
}

void loop() {
  int i = 0;
  BLEDevice central = BLE.central();
  if (central) {
    while (central.connected()) {
      long currentMillis = millis();
      if (currentMillis - previousMillis >= 20) {
        previousMillis = currentMillis;
        scrittura.readValue(test);
        if(test ==3)
            {
            Serial.println(test);
            digitalWrite(LED_BUILTIN, HIGH);
            }
            else
            {
            Serial.println(test);
            digitalWrite(LED_BUILTIN, LOW);
            }
            
      }
    }
    digitalWrite(LED_BUILTIN, LOW);    
  }
}

=================================================================

Per Android ho usato la libreria a questo indirizzo . Ne esistono di piu' complete ma
in questo caso avevo bisogno di semplicita'
=================================================================

package com.ble.ellamma.ble;
import android.bluetooth.BluetoothDevice;

import android.content.Context;

import android.content.Intent;

import android.os.Bundle;

import android.support.v7.app.AppCompatActivity;

import android.util.Log;
import com.ble.ellamma.bleand.Ble;

import java.util.UUID;

public class MainActivity extends AppCompatActivity {

    private static final String MAC_ADDRESS = "ED:CB:86:2A:68:C1";    private static final UUID BLE_NOTIFY_CHARACTER =  UUID.fromString("00002a19-0000-1000-8000-00805f9b34fb");    //.00002a19-0000-1000-8000-00805f9b34fb--18
    private static final UUID BLE_SERVICE = UUID.fromString("0000180f-0000-1000-8000-00805f9b34fb");
    private static final UUID CLIENT_CCD =  UUID.fromString("00002a30-0000-1000-8000-00805f9b34fb");

    ArrayList<String> getDevicess;    List<BluetoothDevice> getConnectedDevicess;


    @Override    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);        

        setContentView(R.layout.activity_main);
        getDevicess = new ArrayList<>();        

        getConnectedDevicess = new ArrayList<>();
        Ble ble = new Ble(this,getApplicationContext(),".Myreceiver");
        ble.enableBle();        

        //ble.scanLeDevice(true,1000);        

        //ble.getDevices();

        ble.connectBLE(MAC_ADDRESS);        

        byte dati[] = "A".getBytes();        

        ble.writeCharacteristics(dati,BLE_SERVIVE,CLIENT_CCD,true);        

        ble.disConnectBLE();
    }

    public void onReceive(Context context, Intent intent) {
        //String data = intent.getStringExtra("data");        

        //Log.w("Luca", "Request Recieved On MyReciever ::" + data);
    }

}