martedì 19 febbraio 2019

Gnome Boxes e risoluzione schermo Windows Host

Visto che non ho piu' voglia di litigare con Virtualbox su Debian 9 ho provato a migrare su Gnome Boxes  per le cose piu' semplici

Il livello di configurazione e' molto meno dettagliato rispetto a Virtualbox ed e' abbastanza spiazzante il modo per manadare ad alta risoluzione lo schermo



Una volta installata la macchina virtuale Windows, si devono scaricare, da dentro la macchina virtuale) da https://www.spice-space.org/download.html gli spice tools (il corrispettivo delle Guest Additions di VirtualBox) per Windows e sembra non accadere niente.

Al riavvio della macchina virtuale la risoluzione non e' cambiata e non e' scalata con due bande nere ai lati. Cliccando destro sul Desktop di Windows/Impostazione Schermo si puo' cambiare la risoluzione dello schermo. In pratica la risoluzione non viene in automatico scalata come avviene in Virtualbox ma la si deve impostare in modo manuale

lunedì 18 febbraio 2019

Ambiente di sviluppo STM32 su Debian



Si scarica il pacchetto principale da

git clone https://github.com/ve3wwg/stm32f103c8t6.git

e lo si scompatta nella directory stm32

poi si scarica libopncm3

git clone https://github.com/libopencm3/libopencm3.git

e si scompatta nella sottodirectory /libopnmc3 di /stm32

apt-get install build-essential libgtk-3-dev libusb-1.0-0-dev cmake gcc-arm-none-eabi

si puo' quindi lanciare la compilazione andando in /stm32 e digitando
make

-------------------------------------
modifica : in Debian esiste il pacchetto stlink-tools
-------------------------------------

non e' ancora finita perche' Debian non ha nei repository i tool st-flash ed st-info e si devono compilare da sorgenti partendo da https://github.com/texane/stlink. Si scompatta lo zip e lo si mette in /stm32/stlink e si seguono le istruzioni da  https://github.com/texane/stlink/blob/master/doc/compiling.md





venerdì 15 febbraio 2019

RTL-SDR e telecomando cancello FAAC

Volevo curiosare come funziona il telecomando dell'apricancello usando RTL-SDR. Frugando un po' ho trovato che il telecomando funziona a 433.84 MHz, Quando si schiaccia il pulsante di fatto vengono emesse due frequenze molto vicine attorno a 433.84 MHz. La prima e' una emissione continua mentre la seconda e' una trasmissione ad impulsi (indicativamente il secondo contiene il codice per apire il cancello, il numero di impulsi e' la chiave)





Lora SX1278 con AS15-USB-T2 e AS32-TTL-100

Volevo provare Lora con Arduino e mi sono comprato i due moduli AS15-USB-T2 e AS32-TTL-100 (il primo per la connessione al computer via USB ed il secondo il vero e proprio modulo radio con SX 1278)





Quando mi e' arrivata la coppia di radio l'ho inserita in due computer ed ho aperto Minicom per vedere se riuscivo a creare un collegamento visto che i moduli possono essere usati anche seriali virtuali

La cosa ha funzionato (dopo aver impostato la connessione 9600 8N1  mettendo ad OFF Hardware Flow Control) ma al momento di trasferire un file la connessione e' crollata

Ho provato a montare un SX1278 ad una Arduino via Seriale ma dopo aver trasmesso un po' di byte ancora una volta la trasmissione si e' arrestata. Ed a questo punto RTFM....leggendo infatti nel dettaglio le istruzioni che si trovano a questo link si vede che la trasmissione e' a pacchetti (piu' nel dettaglio a pacchetti da 58 byte). Non si puo' inviare semplicemente un flusso di dati ma basta mettere un ritardo di tempo tra due pacchetti

Per esempio questo script funziona
70 millisecondi e' l'intervallo minimo per cui si deve separare due pacchetti, per tempi piu' brevi viene spedito un solo pacchetto

Per le connessioni su Arduino ho usato un level converter per portare tutto a 3.3 V nonostante i pin siano dati per compatbili per 3.3V e 5V ma se si guarda la configurazione di AS15-USB-T2 si vede che e' configurato a 3.3 V
Per settare il Mode 0 (ovvero trasmissione) ho connesso sia MD0 che MD1 a GND. Il pin D1TX di Arduino e' stato connesso (via level converter) a RXD di SX1278



=================================================
void setup() {
  Serial.begin(9600);
}
void loop() {
  for (int t=0; t<40; t++)
      {
      int sensorValue = analogRead(A0);
      float voltage = sensorValue * (5.0 / 1023.0);
      Serial.println(voltage);
      }
   delay(70);
}
=================================================
mentre questo non funziona 
=================================================
void setup() {
  Serial.begin(9600);
}
void loop() {
      int sensorValue = analogRead(A0);
      float voltage = sensorValue * (5.0 / 1023.0);
      Serial.println(voltage);
}
=================================================


A seconda della posizione di M0 ed M1 si possono ottenere le impostazioni di configurazione oppure modalita' di powersave


A questo link c'e' una libreria per il modulo  E32-TTL-100 molto simile a quello che uso.  

https://github.com/Bob0505/E32-TTL-100/blob/master/E32-TTL-100.ino

Ho provato ad usarlo con AS32-TTL-1000 con le connessioni suggerite anche se al posto dei suggeriti resistori da 4.7 KOhm  ho connesso con un level converter

    | D7         | <------------------> | M0   |
    | D8         | <------------------> | M1   |
    | A0         | <------------------> | AUX  |
    | D10(Rx)| <------------------> | Tx   |
    | D11(Tx)| <------------------> | Rx   |

Con questa connessione e' possibile programmare la modalita' di LoRa comandandando D7 e D8
Per usare il file .ino si deve inserire nella medesima directory anche il file E32-TLL-100.h

Per settare la modalita' trasmissione ricezione/trasmissione si deve modificare il parametro alla riga 133 (DEVICE_B per trasmettere, DEVICE_A per ricevere)

RTL-SDR e Lora SX1278

Ho provato a vedere il comportamento della radio Lora del modulo SX1278 mediante il programma gqrx


La larghezza di banda della Lora nella configurazione di base risulta essere di 500 KHz. Non si tratta di un picco ma sul grafico la trasmissione si configura come un rettangolo

giovedì 14 febbraio 2019

UBX Parser Python

un lettore di file derivanti da progetto Zero

-----------------------------
import sys
contatore = 0

#i messaggi UBX-RXM-RAWX hanno classe 2 e id_messaggio 15

with open("02121413.TXT") as f:
  while True:
    c = f.read(1)
    if not c:
        break
    if (ord(c) == 0xB5):
        contatore = contatore + 1
        print(str(contatore) +"   ###########  ")
        print("Sync Char 1   " + hex(ord(c)))
        c=f.read(1)
        if (ord(c) == 0x62):
            buffer = []
            print("Sync Char 2   " + hex(ord(c)))
            ########## CLASS ######################
            c=f.read(1)
            print "Class   " + hex(ord(c))
            buffer.append(ord(c))
            ######### MESSAGE #######################
            c=f.read(1)
            print "Message " + hex(ord(c))
            buffer.append(ord(c))
            #############P1 ##########################
            c=f.read(1)
            print "Lunghezza Payload HB " + hex(ord(c))
            hb = ord(c)
            buffer.append(ord(c))
            #############P1 ##########################
            c=f.read(1)
            print "Lunghezza Payload LB  " + hex(ord(c))
            lb = ord(c)
            buffer.append(ord(c))
            ###########LUNGHEZZA PAYLOAD ##############
            lunghezza = hb+(lb*255) 
            print "Lunghezza Payload " + str(lunghezza)
            #inizia a leggere il payload
            if (lunghezza < 1000):
                    for count in range(1,lunghezza):
                        c=f.read(1)
                        #inserisce il payload in un buffer per validarlo
                        buffer.append(ord(c))
             
                    #calcolo del chacksum 
                    # https://gist.github.com/tomazas/3ab51f91cdc418f5704d
                    #CALCOLA CHECKSUM E STAMPA PAYLOAD
                    CK_A,CK_B = 0, 0
                    for i in range(len(buffer)):
                        print hex(buffer[i])
                        CK_A = CK_A + buffer[i]
                        CK_B = CK_B + CK_A

                    # ensure unsigned byte range
                    CK_A = CK_A & 0xFF
                    CK_B = CK_B & 0xFF

                    print "UBX packet checksum:", ("0x%02X,0x%02X" % (CK_A,CK_B))
                  
                    #lettura primo checksum   
                    c=f.read(1)
                    ck_a1 = ord(c)
                    print "CK_A ric " + hex(ck_a1)
                    #lettura secondo checksum
                    c=f.read(1)
                    ck_b1 = ord(c)
                    print "CK_B ric " + hex(ck_b1)
                    
                    if (CK_A == ck_a1):
                        print "############################VALIDATO############"
                    print "\n\n\n"
                    sys.stdin.readline()

venerdì 8 febbraio 2019

Harlem GlobeTrotters Firenze 7 febbraio 2018 Firenze San Marcellino

Esibizione per i giovani giocatori di basket di Firenze di due rappresentanti degli Harlem Globe Trotters al palazzetto di San Marcellino