NOAA 18

Una volta capito come funziona ci si prende gusto. A questo giro ho provato a ricevere i dati dal satellite NOOA18, un satellite meteo in orbita polare

Il passaggio sull'Europa e' avvenuto alle 21:15 (GMT+1) del 28 gennaio (fonte https://www.heavens-above.com/)

La caratteristica di questo satellite e' che trasmette sui 137.912 MHz con una ampiezza di banda di 38 KHz. In WebSDR per allargare l'ampiezza di banda si deve selezionare FM e poi con il mouse selezionare ciascun estremo della banda e trascinarlo fino a quando non viene coperta tutta l'estenzione del segnale. Il segnale e' caratterizzato da una serie di righe parallele nella modalita' waterfall

Waterfall

Spettro

Vista la frequenza di esercizio non potevo usare il WebSdr utilizzato per la  ISS e mi sono spostato su questo link http://erc-websdr.esa.int/

Di fatto il problema principale con NOOA e' possedere una antenna a polarizzazione circolare destra

Il file .wav deve essere processato attraverso il software WxtoImg ma e' posssibile utilizzare anche https://noaa-apt.mbernardi.com.ar/

Se si usa WxtoImg si deve prima prendere il file .wav in uscita da WebSDR e processarlo con Audacity per ricampionarlo da 8000 Hz s 11025 Hz. Si salva il file ma cio' comporta che il nuovo file abbia un timestamp diverso dal file iniziale. Per correggere questo problema si utilizza il comando

touch -a -m -t 202001282130.00 t1.wav

dove il timestamp e' formato YYYYMMDDHHMM.SS

Il software si chiama in questo modo perche' il protocollo di trasmissione e' denominato WeFax ed e' in pratica molto simile al buon vecchio sistema Fax che si usava in ufficio

Il servizio APT e' invece una trasmissione di due immagini relative a due bande (in questo caso nel termico) di 2080 x 909 pixels

Elaborazioni con WxToImg

Temperatura Mare

MCIR

Tenpeartura

se si usa noaa-apt i passi di cambio ora e resampling sono eseguiti in automatico e questo e' il risultato. Di fatto con questo software non possono essere eseguite elaborazioni. Le due bande vengono visualizzate a fianco con inclusa la banda di sincronia del segnale 

Per confronto questa e' la stessa immagine acquisita da https://www.osservatoriometeoesismicoperugia.it/satellitipolari/index.html

La differenza principale e' che qui le nuvole sono bianche mentre in wxtoimg risultano grigie

ISS Ham Radio Luca Parmitano 27/01/2020 17:38 GMT

Erano anni che provavo ad ascoltare il canale amatoriale della Stazione Spaziale ISS sulla frequenza 145.800 MHz con radio sempre migliori (ma sempre a basso costo da scanner palmari a RTL-SDR)

Ma di fatto bisogna avere fortuna perche' i transiti della ISS sono di pochi minuti e di solito gli astronauti sono impegnati in altre cose (si tratta di una Ham Radio, non si tratta della radio effettiva di lavoro con il controllo missione)

Finalmente ci sono riuscito anche se non usando la mia apparecchiatura.
Visto che il transito sull'Europa era previsto quando non ero in casa mi sono collegato con il sito http://farnham-sdr.com/ dove si puo' usare una radio RTL-SDR a piacimento (l'antenna si trova nella parte meridionale dell'Inghilterra)

Tramite https://www.heavens-above.com/ era calcolato un transito alle 16:38 GMT (in Italia 17:38) e puntualmente come la ISS e' emersa dall'orizzonte ho visto il segnale sul waterfall

La cosa che mi ha fatto ancora piu' piacere e' stato trovare Luca Parmitano in trasmissione (avevo provato ad ascoltare anche nella precedente missione 36 senza nessun successo)

La cosa impressionante e' lo spostamente doppler del segnale. La frequenza di riferimento e' di 145.800 MHz ma quando emerge dall'orizzonte la frequenza e' oltre 145.803 MHz

per poi spostarsi rapidamente verso sinistra nello spettro, Nel momento di passaggio allo zenit lo spostamento Doppler e' cosi' rapido che la linea di riferimento sullo spettro e' chiaramente inclinata (la ISS e' dannatamente veloce!). Quando e' scomparsa all'orizzonte opposto la frequenza era vicino a 145.796 MHz

Mobike e BLE

Mentre stavo giocherellando con lo scanner Bluetooth LE mi e' apparso in lista un dispositivo Mobike ed ho visto che era stata appena parcheggiata una bicicletta a noleggio fuori dall'ufficio. Avevo sempre pensato che le Mobike fossero basate tutte su comunicazioni dati su rete cellulare ma a quanto sembra non e' proprio cosi..di fatto vengono esposte due servizi di uno scrivibile via BLE

c'e ovviamente chi ha fatto un'analisi decisamente piu' apprfondita

https://gsec.hitb.org/materials/sg2018/D2%20-%20Hacking%20BLE%20Bicycle%20Locks%20for%20Fun%20and%20(a%20Small)%20Profit%20-%20Vincent%20Tan.pdf

e c'e' anche chi ha smontato un lucchetto Mobike trovandoci dentro un modulo telefonico, un GPS ed un processore STM32

https://projectgus.com/2017/04/sharing-bikes-in-shanghai/

In ogni caso la gran parte del lavoro di scambio dati per lo sblocco e' svolto dal telefono del cliente
Sarei curioso di sapere come e' stato risolto da Mobike il problema di alimentare un sistema cosi' energivoro (GPS+Cellulare possono drenare in modo molto veloce le batterie)

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

}

Lenovo Ultrabay HD e LVM

Dato che avevo uno slot libero sul mio Lenovo T430 mi sono comprato una estensione SATA per lo slot Ultrabay. Ho riutilizzato un disco SSD che ho preso da un'altra macchina ma al momento di montarlo sulla Debian Box non riuscivo a vederlo

Guardando con GParted il disco era formattato LVM. A questo punto ho scaricato il pacchetto LVM

apt-get install lvm2

con vgscan ho scansionato i dischi ed ho attivato il volume con

vgachange -ay centos

con lvs si possono vedere le partizioni sul disco. A questo punto si puo' montare il filesystem

mount /dev/centos/home /media/ -o ro,user

a questo punto per fare le cose per bene sarebbe da inserire in fstab. Per avere lo UUID si puo' digitare blkid

Cython

Era un po' di tempo che volevo provare Cython, la versione compilata di Python, ma non avevo mai avuto la necessita'. Con il trasferimento dati via BLE del precedente post pensavo che il collo di bottiglia fosse legato a Python e non al transfer rate di BLE ed ho cosi' convertito lo script in Python tramite Cython. In pratica il primo passo e' la conversione in C mentre il secondo passo e' una classica compilazione con GCC per avere un eseguibile


cython --embed -o ble_test.c ../ble_test.py
gcc -Os -I /usr/include/python2.7/ -o ble_test ble_test.c -lpython2.7 -lpthread -lm -util -ldl


...e no, il problema non era Python

BLE Arduino Nano 33

Un eesmpio di scambio dati via Bluetooth LE tra una scheda Arduino Nano 33 BLE ed un PC

La Arduino Nano BLE 33 e' una scheda interessante perche' oltre al Bluetooth LE sono disponibili una IMU (LMS9DS1), un microfono digitale (MP34DT05), un sensore di colore e prossimita' (APDS9960), un sensore di pressione atmosferica (LPS22HB), un sensore di umidita' relativa e temperatura (HTS221)

Lo sketch su Arduino apre un servizio su BLE con numero 180F ed una caratteristica 2A19 in cui vengono salvati i dati di un contatore progressivo da 0 a 255 (questo per fare in modo che sul lato PC si sia in grado di vedere se si perdono pacchetti)

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

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

long previousMillis = 0;  

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); 
  BLE.addService(numero); 
  casuale.writeValue(0); // set initial value for this characteristic
  BLE.advertise();
}

void loop() {
  int i = 0;
  BLEDevice central = BLE.central();
  if (central) {
    digitalWrite(LED_BUILTIN, HIGH);
    while (central.connected()) {
      long currentMillis = millis();
      if (currentMillis - previousMillis >= 20) {
        i++;
        casuale.writeValue(i%255);
        previousMillis = currentMillis;
      }
    }
    digitalWrite(LED_BUILTIN, LOW);    
  }
}
================================================

Per verificare che i dati vengano inviati correttamente si puo' usare gattool

================================================
gatttool -b ED:CB:86:2A:68:C1 -I
[ED:CB:86:2A:68:C1][LE]> connect
Attempting to connect to ED:CB:86:2A:68:C1
Connection successful
[ED:CB:86:2A:68:C1][LE]> char-read-uuid 2A19
handle: 0x000b value: 41
================================================

A questo punto con la libreria Bluepy si possono leggere i dati inviati dalla Arduino

================================================
from bluepy import btle
from bluepy.btle import UUID, Peripheral

addr = "ED:CB:86:2A:68:C1"
conn = Peripheral(addr, "public")

print ("-Servizi")
services = conn.getServices()
for service in services:
print(service.uuid)


print("-Caratteristica")
charac_dic = service.getCharacteristics()
for charac in charac_dic:
print(charac.uuid)
if charac.uuid == "2a19":
print ("Trovata")
Data_char = charac
print(Data_char)
Data_handle = Data_char.getHandle()
print Data_handle
while True:
print (ord(charac.read()))

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

la trasmissione dati in questo modo e' piuttosto lenta..circa un dato ogni decimo di secondo.

Usando la tecnica di subscribe and notify la Arduino invia i dati al PC senza la necessita' per quest'ultimo di richiederli. Con questa tecnica non si perde nessun pacchetto

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

from bluepy import btle
from bluepy.btle import UUID, Peripheral
import struct

def listAll(p):
for svc in p.getServices():
print(svc.uuid.getCommonName())
for ch in svc.getCharacteristics():
print(" " + str(ch.valHandle) + ": " + ch.uuid.getCommonName())

class MyDelegate(btle.DefaultDelegate):
    def __init__(self):
        btle.DefaultDelegate.__init__(self)

    def handleNotification(self, cHandle, data):
print(ord(data))

addr = "ED:CB:86:2A:68:C1"
p = btle.Peripheral(addr,"public")
services=p.getServices()
for service in services:
   print(service.uuid)

p.setDelegate( MyDelegate() )

listAll(p)

svc = p.getServiceByUUID("0000180f-0000-1000-8000-00805f9b34fb")
ch = svc.getCharacteristics()[0]
p.writeCharacteristic(ch.valHandle+1, b'\x01\x00', withResponse=True)

while True:
    if p.waitForNotifications(1.0):
        continue
    print "Waiting..."