ConnManCtl Command line network manager

Cercando di mettere su una macchina dalle risorse ridotte ho installato una Debian netinst con I3
Per ridurre il carico volevo un network manager da linea di comando ed ho trovato connmanctl

per utilizzarlo si digita connmanctl e si apre un prompt

enable wifi
scan wifi
services
agent on
connect (si deve copiare la stringa accanto al nome del proprio AP vedi immagine)

Nell'uso mi sono accorto che il DNS non viene gestito dal DHCP ma viene preso quello inserito in resolv.conf

Una volta connessi ad una rete wifi al successivo riavvio non e' necessario ripetere la procedura di autenticazione

OpenCV Houghes Circles and Gui test

===============================================
import cv2
import numpy as np

alpha_slider_max = 20
title_window = 'Conteggio eventi'

def on_trackbar(val):
    #img = originale.copy()
    #cv2.rectangle(img,(0,0),(100,100),(255,255,255),-1)
    
    t1 = cv2.getTrackbarPos(trackbar_name, title_window)
    t2 = cv2.getTrackbarPos(trackbar_name_2, title_window)
    t3 = cv2.getTrackbarPos(trackbar_name_3, title_window)

    par1 = cv2.getTrackbarPos(trackbar_name_4, title_window)
    par2 = cv2.getTrackbarPos(trackbar_name_5, title_window)

    #print(str(t1))
    #print(str(t2))
    #contrasto
    img = originale.copy()
    contrast = t3
    f = 131*(contrast+127)/(127*(131-contrast))
    alpha_c = f
    gamma_c = 127*(1-f)
    img_con = cv2.addWeighted(img,alpha_c,img,0,gamma_c)
    #img_con = f*(img)+127*(1-f)
    cv2.imshow("contrasto",img_con)

    #img=originale.copy()
    gray = cv2.cvtColor(img_con, cv2.COLOR_BGR2GRAY)
    img_blur = cv2.medianBlur(gray, 5)
    circles = cv2.HoughCircles(img_blur, cv2.HOUGH_GRADIENT, 1, img.shape[0]/64, param1=par1, param2=par2, minRadius=t1+1, maxRadius=t2+1)
    conta = 0
    if circles is not None:
    circles = np.uint16(np.around(circles))
    for i in circles[0, :]:
conta=conta+1
        cv2.circle(img_con, (i[0], i[1]), 2, (0, 0, 255), 2)

    font = cv2.FONT_HERSHEY_SIMPLEX
    cv2.putText(img, "{:.0f}".format(conta) ,(10,15), font, 0.5,(255,0,0),2,1)
    cv2.imshow(title_window,img_con)
    #print ("Numero identificazioni :"+str(conta))
    #print(str(val))

global originale

originale = cv2.imread('cr39film.png', cv2.IMREAD_COLOR)
gray = cv2.cvtColor(originale, cv2.COLOR_BGR2GRAY)


cv2.namedWindow(title_window)
trackbar_name = 'MinRadius x %d' % alpha_slider_max
trackbar_name_2 = 'MaxRadius x %d' % alpha_slider_max
trackbar_name_3 = 'Contrasto x %d' % 127

trackbar_name_4 = 'Par 1 x %d' % alpha_slider_max
trackbar_name_5 = 'Par 2 x %d' % alpha_slider_max


cv2.createTrackbar(trackbar_name_2, title_window , 5, alpha_slider_max, on_trackbar)
cv2.createTrackbar(trackbar_name, title_window , 1, alpha_slider_max, on_trackbar)
cv2.createTrackbar(trackbar_name_3, title_window , 1, 127, on_trackbar)
cv2.createTrackbar(trackbar_name_4, title_window , 1, 50, on_trackbar)
cv2.createTrackbar(trackbar_name_5, title_window , 1, 5, on_trackbar)


on_trackbar(5)
cv2.waitKey()
cv2.destroyAllWindows()

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;