Enigma

Leggendo di Enigma mi e' venuta la voglia di provar a scrivere una versione in Python..rendendomi conto che non e' proprio banale

La prima  cosa che ho imparato a mie spese e' che si deve progettare tutto in modo simmetrico perche' la codifica e la successiva decodifica avvengono con le stesse impostazione

In un primo momento avevo usato un array per simulare un rotore ma lo avevo creato inserendo dei valori a caso. Invece per permettere che la decodifica segua lo stesso percorso (all'inverso della codifica) l'array non puo' essere creato a caso ma le posizioni devono essere reciproche...meglio con un esempio...se la posizione  5 dell'array contiene un valore 13 la posizione 13 deve contenere il vaore 5

================================================================================
import numpy as np
import readchar
#                        a  b  c  d  e  f  g  h  i j   k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z
#                        0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 
plugboard   = np.array([16,21,11,15,18,25, 9,22,14, 6,20, 2,13,12, 8, 3, 0,23, 4,24,10, 1, 7,17,19, 5])
rotore_1    = np.array([ 6,10,16,25,20,18, 0,23,17,11, 1, 9,15,19,24,12, 2, 8, 5,13, 4,22,21, 7,14, 3])
rotore_2    = np.array([25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
rotore_3    = np.array([17,22,25, 8,16,20,19,14, 3,23,12,24,10,18, 7,21, 4, 0,13, 6, 5,15, 1, 9,11, 2])
riflettore  = np.array([24, 5,11,16,21, 1,25,23,10,22, 8, 2,13,12,18,20, 3,19,14,17,15, 4, 9, 7, 0, 6])

while True:
    c = readchar.readkey()
    print(c), 
    print(ord(c)-97),
    pg = plugboard[ord(c)-97]
    print("PG "+str(pg)),
    r1 = rotore_1[pg]
    print("/R1 "+str(r1)),
    r2 = rotore_2[r1]
    print("/R2 "+str(r2)),
    r3 = rotore_3[r2]
    print("/R3 "+str(r3)),
    ri = riflettore[r3]
    ri_2 = riflettore[ri]
    print("/RI "+str(ri)),
    print("/RI2 "+str(ri_2)),
    r3 = rotore_3[ri_2]
    print("/R3 "+str(r3)),
    r2 = rotore_2[r3]
    print("/R2 "+str(r2)),
    r1 = rotore_1[r2]
================================================================================

Questa e' la base con tutti i passaggi nei rotori, nella plugboard e nel riflettore
Il problema e' che il dopo il primo passaggio il primo rotore esegue una rotazione per cambiare in automatico il percorso di criptazione ma al momento non sono riuscito ad utilizzare in modo semplice la rotazione dell'array

Dumpster Diving Samsung GT-S5280

E' abbastanza incredibile cosa si trovi nella raccolta differenziata delle batterie. Questa volta e' toccato ad un Samsung GT-S5280 (a cui per ironia della sorte avevano tolto proprio la batteria oltre alla Sim Card ed alla SD Card...falla a capire la logica delle persone)

Ovviamente e' partita la sfida a rimetterlo in vita.

All'accensione era presente un pattern lock....ho provato a  fare un po' di tentativi di sblocco a caso ma senza successo. Non volevo resettarlo perche' ero curioso di vedere in che condizioni era il telefono (ovviamente non era mio interesse accedere ad account privati o foto...le avrei rimosse senza guardarle). Ho provato a cliccare su Forgot Pattern ma questa opzione mi ha portato alla richiesta di Pin ... vallo ad indovinare...1234...No....0000... Entrato, troppo facile.

Alla fine il precedente proprietario aveva fatto un Factory Reset (ma allora perche' mettere il Pattern Lock?) ma in ogni caso il telefon e' perfettamente funzionante e si e' aggiornato per diverse volte (Samsung ha ancora sui server gli aggiornamenti per un telefono  del 2013!)

Conteggio automatico film radon con OpenCV

Per lavoro puo' essere che puo' essere che mi trovi a dover contare delle lastre dei rilevatori di radon e volevo provare a fare qualcosa di mio con OpenCV. Per prova ho preso delle immagini da Google Images e le ho trattate con OpenCV e gli Hough Circles

Immagine non elaborata

link

Immagine non elaborata con sovrapposizione del riconoscimento e del numero degli eventi

Elabotazione Conteggio 126 eventi

questo e' il file Python che e' preso dagli esempi di OpenCV con minime modifiche
=======================================================
import cv2
import numpy as np
# Read image as gray-scale
img = cv2.imread('cr39film.png', cv2.IMREAD_COLOR)
cv2.imshow('Originale',img)

# Convert to gray-scale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Blur the image to reduce noise
img_blur = cv2.medianBlur(gray, 5)
# Apply hough transform on the image
circles = cv2.HoughCircles(img_blur, cv2.HOUGH_GRADIENT, 1, img.shape[0]/32, param1=50, param2=5, minRadius=0, maxRadius=10)
conta = 0
# Draw detected circles
if circles is not None:
    circles = np.uint16(np.around(circles))
    for i in circles[0, :]:
        # Draw outer circle
        #cv2.circle(img, (i[0], i[1]), i[2], (0, 255, 0), 2)
        # Draw inner circle
conta=conta+1
        cv2.circle(img, (i[0], i[1]), 2, (0, 0, 255), 2)

print ("Numero identificazioni :"+str(conta))
cv2.imshow('tt',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
=======================================================

link

Elaborazione Conteggio 175 eventi

diciamo che nonostante  il poco tempo dedicato al problema i risultati non sono niente male

Number Station F03a

Ero sempre stato curioso delle Number Station e volevo provare ad ascoltarle ma ho scoperto che sono praticamente tutte in VLF con frequenze dell'ordine delle migliaia di KHz cioe' ben fuori dal sintonizzatore del mio dongle Usb SDR-RTL

Con questo servizio online si puo' esplorare senza troppi problemi queste frequenze

Il problema a questo punto e' che le trasmissioni di solito sono molto brevi. In questo ci viene in aiuto il sito priyom.org.

Sono riuscito a registrare la trasmissione dell'emittente FO3a alle 10:45 del 4 febbraio 2020 (sembra appartenere alla Polonia) ma ovviamente il tutto e' abbastanza inutile (non si tratta peraltro di una trasmissione con voce sintetica ma una vera e propria trasmissione dati da decodificare per la presenza di una modulazione)

ADS-B con Dump1090

ADS-B  e' un sistema per il controllo del traffico aereo su frequenza di 1.09 GHz che si puo' ricevere tranquillamente con un sistema RTL-SDR da pochi euro senza particolari antenne

Lo ho provato con il software dump1090 su Debian (ho dovuto compilare da sorgenti perche' non ho trovato il pacchetto apt su testing)

Una volta avviato il programma con

./dump1090 --interactive si puo' avere la lista dei dati ricevuti

Al momento la funzione --net non funziona perche' GMaps non e' piu pubblico

Usando FlightRadar24 e' stato possibile verificare che ricevevo  anche distanti 100 Km (la stazione ricevente e' posizionata a Firenze)

Abilitando lo switch --raw si osservano i pacchetti esadecimali
Per il dettaglio della decodifica si rimanda a questo sito

-----------------------------------------------------------------------------------
*8d4caa77589704822c7d7a8719c8;
*8d4caa779910a2bcb0082dae0e6c;
*a00012b0b8adc570a8000482522a;
*a800118eba0a432ee01402fc49f1;
*5d4ca815fff886;
*5d3c6742ce5fc7;
*a000133bc4662330a800003a2dd4;
*a8000516a74a392f212c26c0885a;
*8d3c6742991418328004214c8854;
*02e192b030f0ca;
*a00012b0000000000000001d8a97;
*5d4caa77e1bd4d;
*02e197178f112b;
*02e197178f112b;
*02e197178f112b;
*8d4ca815f8230006004878f3f968;
*5d4b9067729b5b;
*02e197178f112b;
*8d3c674258b9715920c213e6d5d7;
*a00012b0b8adc570a8000482522a;
*a000133cc4662330a80000bddf33;
*02e1933c39b1b2;
*8d4caa77589700fd788cb9f6c050;
*8d4ca815e1051600000000a2765f;
*8d4ca815ea447865351c08d85a00;
*a0001717c6500031300000993d6b;
*80e1933c609bc1adaa921b079299;
*02e1933c39b1b2;

ISS SSTV 31/01/2020 16:46 GMT

Questa e' stata acquisita utilizzato il servizio Web SDR  di http://farnham-sdr.com/

Tensorflow Lite su Arduino Ble 33

A questo link e' comparso un interessante esempio su come utilizzare i sensori (accelerometro e giroscopio) di una Arduino BLE per addestrare una rete neurale con Tensorflow Lite e poi utilizzare la stessa libreria per classificare le gesture sempre tramite  Arduino

Per prova ho inserito la Arduino sotto ad un guanto (per tenerla bloccata) e poi registrando un centinaio di rotazione del polso verso l'interno e verso l'esterno

L'ultima modifica che ho apportato e' di modificare a 50 il numero di campioni per gesture
Una volta salvata due file csv (uno per movimento) ho utilizzato questo Colab per creare il file model. h

Grafico accelerazione di riferimento

Come si deve dai grafici l'errore del modello in train/validation e' estremamente ridotto

Grafico giroscopi di riferimento

Training and validation loss

Stesso grafico precedente eliminando i primi 100 dati

Risultati validazione

Il risultato del Notebook sono un file di modello di Tensorflow Lite ed un file model.h che deve essere copiato nello sketch ImuClassifier per fare il deploy del modello

Devo ammettere che il sistema funziona ma e' lontano dall'essere perfetto. Devo ancora capire se e' un problema di posizionamento del sensore durante le varie proprie (che per ovvi motivi non e' sempre identico) od un addestramento errato