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()

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

Mai giocare con le LiPo

Ieri stavo lavorando sul banco per forare una scatola in plastica. Per una serie di sfortunate coincidenze (oltre al fatto che usavo un trapano non mio in cui e' rimasto incastrato il grilletto) la punta del trapano e' entrata in contatto con una LiPo.....e sono stato avvolto dalle scintille

Fortunatamente sono riuscito togliere la spina prima che la punta del trapano mi ferisse e senza che la LiPo esplodesse

U-Blox U-Center e Wine

U-Center di U-Blox funziona correttamente in Wine su Debian
L'unica accortezza e' che si deve creare un symlink della porta USB verso un COM virtuale con

ln -s /dev/ttyACM0 /home/luca/.wine/dosdevices/com5

a questo punto il GPS verra' visto in U-Center sotto COM5

Arduino MKR1400

E' arrivata sulla scrivania la concorrente diretta della Particle Electron (e molto probabilmente la vincitrice), la Arduino MKR1400 una MKR1000 con in aggiunta un modulo GSM

La scheda funziona con le microSIM e non con le nanoSIM (come la Electron) e supporta senza nessun problema Things Mobile

Una prima cosa strana: la scheda mi e' arrivata senza antenna nonostante sullo store ne viene segnalata la presenza. Ho utilizzato quella della Electron

Ho avuto problemi di connessione con la porta seriale. In caso di necessita' di reset della scheda si deve premere due volte in modo ravvicinato il tasto di reset

Il connettore della LiPo e' di tipo JST-PH
Per controllare il livello della batteria si puo' usare questo sketch
----------------------------------------------------------------------------

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(ADC_BATTERY);
  float voltage = sensorValue * (4.3 / 1023.0);
  Serial.print(voltage);
  Serial.println("V");
}
----------------------------------------------------------------------------

Per inviare SMS il codice piu' semplice e' il seguente.
Negli sketch deve essere sempre inserita la parte in giallo di configurazione della seriale
Alla SIM e' stato rimosso il pincode per cui non e' necessario configuralo nello sketch

----------------------------------------------------------------------------
#include <MKRGSM.h>


GSM gsmAccess;
GSM_SMS sms;

void setup() {
 Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  
bool connected = false;

  while (!connected) {
    if (gsmAccess.begin() == GSM_READY) {
      connected = true;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("GSM initialized");
}

void loop() {
  delay(1000);
  sms.beginSMS("+393471xxxxxxx");
  sms.print("Prova MKR14000");
  sms.endSMS(); 
  Serial.println("Inviato");
  delay(60000);
}
--------------------------------------------------------

Nel momento di provare ad usare la MKR1400 in accoppiata con un ADXL345 sono entrato in una serie di problemi apparentemente senza uscita perche' ogni volta che cercavo di configurare il canale I2C la scheda perdeva la configurazione della porta seriale su USB e non eseguiva nessuno sketch

Dopo un'oretta di prove a caso ho messo un delay di 5 secondi all'inizio della funzione di setup()  e l'accelerometro ha iniziato a funzionare in modo corretto

MKR1400 e ADXL345

----------------------------------------------------------
/
#include <MKRGSM.h>

GSM gsmAccess;
GSM_SMS sms;

#include <SparkFun_ADXL345.h>         // SparkFun ADXL345 Library

ADXL345 adxl = ADXL345();             // USE FOR I2C COMMUNICATION
int interruptPin = 2;                 // Setup pin 2 to be the interrupt pin (for most Arduino Boards)

void setup(){
  
  Serial.begin(9600);  
  while (!Serial)
  {}; 
  delay(5000);
  Serial.println("SMS Messages Sender");

  
  // Start the serial terminal
  Serial.println("SparkFun ADXL345 Accelerometer Hook Up Guide Example");
  Serial.println();
  
  adxl.powerOn();                     // Power on the ADXL345

  adxl.setRangeSetting(16);           // Give the range settings
                                      // Accepted values are 2g, 4g, 8g or 16g
                                      // Higher Values = Wider Measurement Range
                                      // Lower Values = Greater Sensitivity

  adxl.setSpiBit(0);                  // Configure the device to be in 4 wire SPI mode when set to '0' or 3 wire SPI mode when set to 1
                                      // Default: Set to 1
                                      // SPI pins on the ATMega328: 11, 12 and 13 as reference in SPI Library 
   
  adxl.setActivityXYZ(1, 0, 0);       // Set to activate movement detection in the axes "adxl.setActivityXYZ(X, Y, Z);" (1 == ON, 0 == OFF)
  adxl.setActivityThreshold(75);      // 62.5mg per increment   // Set activity   // Inactivity thresholds (0-255)

  adxl.setInactivityXYZ(1, 0, 0);     // Set to detect inactivity in all the axes "adxl.setInactivityXYZ(X, Y, Z);" (1 == ON, 0 == OFF)
  adxl.setInactivityThreshold(75);    // 62.5mg per increment   // Set inactivity // Inactivity thresholds (0-255)
  adxl.setTimeInactivity(10);         // How many seconds of no activity is inactive?

  adxl.setTapDetectionOnXYZ(0, 0, 1); // Detect taps in the directions turned ON "adxl.setTapDetectionOnX(X, Y, Z);" (1 == ON, 0 == OFF)

  // Set values for what is considered a TAP and what is a DOUBLE TAP (0-255)
  adxl.setTapThreshold(50);           // 62.5 mg per increment
  adxl.setTapDuration(15);            // 625 μs per increment
  adxl.setDoubleTapLatency(80);       // 1.25 ms per increment
  adxl.setDoubleTapWindow(200);       // 1.25 ms per increment

  // Set values for what is considered FREE FALL (0-255)
  adxl.setFreeFallThreshold(7);       // (5 - 9) recommended - 62.5mg per increment
  adxl.setFreeFallDuration(30);       // (20 - 70) recommended - 5ms per increment

  // Setting all interupts to take place on INT1 pin
  //adxl.setImportantInterruptMapping(1, 1, 1, 1, 1);     // Sets "adxl.setEveryInterruptMapping(single tap, double tap, free fall, activity, inactivity);" 
                                                        // Accepts only 1 or 2 values for pins INT1 and INT2. This chooses the pin on the ADXL345 to use for Interrupts.
                                                        // This library may have a problem using INT2 pin. Default to INT1 pin.
  
  // Turn on Interrupts for each mode (1 == ON, 0 == OFF)
  adxl.InactivityINT(1);
  adxl.ActivityINT(1);
  adxl.FreeFallINT(1);
  adxl.doubleTapINT(1);
  adxl.singleTapINT(1);
  
attachInterrupt(digitalPinToInterrupt(interruptPin), ADXL_ISR, RISING);   // Attach Interrupt

}

/****************** MAIN CODE ******************/
/*     Accelerometer Readings and Interrupt    */
void loop(){
  
  // Accelerometer Readings
  int x,y,z;   
  adxl.readAccel(&x, &y, &z);         // Read the accelerometer values and store them in variables declared above x,y,z

  // Output Results to Serial
  /* UNCOMMENT TO VIEW X Y Z ACCELEROMETER VALUES 
  Serial.print(x);
  Serial.print(", ");
  Serial.print(y);
  Serial.print(", ");
  Serial.println(z); */
  
  ADXL_ISR();
  // You may also choose to avoid using interrupts and simply run the functions within ADXL_ISR(); 
  //  and place it within the loop instead.  
  // This may come in handy when it doesn't matter when the action occurs. 

}

/********************* ISR *********************/
/* Look for Interrupts and Triggered Action    */
void ADXL_ISR() {
  
  // getInterruptSource clears all triggered actions after returning value
  // Do not call again until you need to recheck for triggered actions
  byte interrupts = adxl.getInterruptSource();
  
  // Free Fall Detection
  if(adxl.triggered(interrupts, ADXL345_FREE_FALL)){
    Serial.println("*** FREE FALL ***");

    //add code here to do when free fall is sensed
  } 
  
  // Inactivity
  if(adxl.triggered(interrupts, ADXL345_INACTIVITY)){
    Serial.println("*** INACTIVITY ***");
     //add code here to do when inactivity is sensed
  }
  
  // Activity
  if(adxl.triggered(interrupts, ADXL345_ACTIVITY)){
    Serial.println("*** ACTIVITY ***"); 
     //add code here to do when activity is sensed
  }
  
  // Double Tap Detection
  if(adxl.triggered(interrupts, ADXL345_DOUBLE_TAP)){
    Serial.println("*** DOUBLE TAP ***");
     //add code here to do when a 2X tap is sensed
  }
  
  // Tap Detection
  if(adxl.triggered(interrupts, ADXL345_SINGLE_TAP)){
    Serial.println("*** TAP ***");
            bool connected = false;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while (!connected) {
    if (gsmAccess.begin() == GSM_READY) {
      connected = true;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }
    Serial.println("Luca mi ha toccato");

   delay(1000);
  sms.beginSMS("+3934710xxxxxx");
  sms.print("Luca mi ha toccato");
  sms.endSMS(); 
  Serial.println("Inviato");
  delay(60000);


  } 
}

SDA SCL per ADXL345 con ESP32 Vroom

Questo e' un promemoria per ricordarmi i pin del canale i2C su Esp32 Vroom 32 altrimenti detto ESP32_Core_Board_v2

Come da pinout
SCL = IO22
SDA = IO21

Comparatore di tensione

Il motivo di questo post era rispondere alla domanda: posso generare un interrupt per una Arduino anche quando il dispositivo di misura non dispone di tale funzione (per esempio un puro strumento analogico con uscita della lettura come variazione di tensione??)

Una risposta puo' essere usare un comparatore di voltaggio mediante circuito operazionale che si comporti come un ADC ad un solo bit. Se il valore letto e' minore di quello di riferimento il circuito risponde con una tensione di uscita zero (stato zero) mentre se e' superiore risponde con uno stato 1 (tensione pari a 5V)

Simulazione effettuate con Every Circuit 

Sul - dell'operazionale si imposta la tensione di riferimento Vr (la soglia a cui si vuole che il circuito cambi stato) e si pone per esempio a 3V. La V+ di alimentazione dell'operazione e' posta a 5V mentre la V- di alimentazione e' posta a zero

Nel + dell'operazione (pin non invertente) si inserisce la tensione pilota (Vp). Nel caso in cui Vr<Vp il circuito entra nello stato 1 ed all'uscita dell'operazionale si ha una tensione di 5V. In caso contrario si ha una tensione pari a 0

Nel primo caso la tensione sul - dell'operazionale (pin invertente) risulta essere di 3V mentre la tensione sul + dell'operazione e' di 4 V. In questa condizione in uscita dall'operazionale si ha un valore di Vcc  a cui e' alimentato l'operazionale (quindi 5V)

 Nel secondo caso la tensione sul + risulta inferiore al valore di riferimento

Dal punto di vista pratico si possono usare LM311, LM345 e LM741
Andando sul dettaglio estremo non e' vero che il circuito puo' assumere solo valori tra 0 e 5V. In un intorno di 10 mv intorno alla tensione di cambio di stato la tensione in uscita assume un valore intermedio tra 0 e 5V ma al mio fine pratico cio' non interessa

http://everycircuit.com/app/


http://www.bristolwatch.com/ele2/comparator.htm