ADXL335 come tiltmetro

Questo e' una verifica se si puo' usare ADXL335 come misuratore di angoli affidabile.
Per ottenere la misura degli angoli il sensore deve essere fermo; a questo puo' si puo' utilizzare la scomposizione del vettore forza di gravita' per misurare gli angoli di pitch e roll

Per effettuare la verifica e' stato impiegato un tavolo di laboratorio inclinabile con una vite senza fine. Per ottenere una misura piu' precisa dell'angolo di inclinazione non e' stato usato un goniometro ma sono stati impiegate le misure dei due cateti dell'angolo in modo da ricavare l'angolo come arctangente

In generale e' stato osservato che in condizioni statiche la misura dell'angolo ha una deviazione standard di 0.25° decimale dal valore medio.

Plottando i dati dell'angolo misurato come arctg e da ADXL335 (entrambe le misure non sono da considerarsi particolarmente raffinate...nonostante l'uso di un calibro le misure delle distanze si sono rivelate piuttosto difficoltose)

DXL335 con Arduino FIO

Un semplice progettino per un accelerometro accoppiato a XBee.
Per questa configurazione e' stata scelta una Arduino Fio, purtroppo oramai fuori produzione, una scheda che monta il microcontrollore di Arduino Leonardo accoppiato ad un socket Xbee con un connettore JST per una batteria LiPo e la predisposizione per il pannello solare

Il modulo Xbee non e' presente nella foto per far vedere il socket. il cavo blu in origine era tra DTS di Xbee e D10 per mandare il sleep mode il modulo di trasmissione)

La Arduino FIO si programma tramite FTDI Breakout (i pin devono essere saldati a mano).
L'ADXL e' stato brutalmente saldato ai pin A5, A6 ed A7 per i canali rispettivamente Z,Y ed X mentre per l'alimentazione ho fatto un paio di patch

Come si deve dal confronto con la moneta da due euro la dimesione totale del progetto e' estremamente ridotta (la batteria LiPo e' da 1400 mAh)


Lo sketch e' molto semplice e si limita ad effettuare una lettura analogica su ogni asse (per la conversione in accelerazione si veda questo precedente post) e mandare la lettura sulla porta seriale che e' direttamente collegata, senza modificare niente al modulo XBEE
------------------------------------------------------
void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.print(analogRead(A7));
  Serial.print("\t");
  Serial.print(analogRead(A6));
  Serial.print("\t");
  Serial.print(analogRead(A5));
  Serial.println();
  delay(100);
}

ADXL335 Accelerometro come tiltmetro

In questo post del 2012  avevo usato il componente CMPS10 per avere le indicazione di Yaw, Pitch e Roll.
Con il solo accelerometro (quindi senza una bussola) e' possibile tuttavia avere le informazioni di inclinazione dell'accelerometro in Pitch e Roll (Yaw non e' possibile perche' il calcolo richiede la scomposizione del vettore di accelerazione di gravita' e quindi la rotazione sul piano ortogonale al vettore gravita' non e' registrabile)

Sfruttando questo post ho provato a fare la stessa cosa con un ADXL335

Nel post e' peraltro interessante l'uso di un filtro passa basso.Agendo  sul parametro alpha si puo' ottenere un filtraggio meno (con numeri vicini a 1) o piu' aggressivi (con numeri dell'ordine di 0.1)
A sensore fermo la misura oscilla con filtro a 0.4 di circa +/- 1°
---------------------------------------------------------------------------
const float alpha = 0.5;

double fXg = 0;
double fYg = 0;
double fZg = 0;

double Xg = 0;
double Yg = 0;
double Zg = 0;


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

void loop()
{
    double pitch, roll, Xg, Yg, Zg;
    Xg = (analogRead(A5)*(5.0/1023.0))-1.59;
    Yg = (analogRead(A4)*(5.0/1023.0))-1.60;
    Zg = (analogRead(A3)*(5.0/1023.0))-1.67;

    Xg = 9.8*(Xg/0.33);
    Yg = 9.8*(Yg/0.33);
    Zg = 9.8*(Zg/0.33);
   
  
    //Low Pass Filter
    fXg = Xg * alpha + (fXg * (1.0 - alpha));
    fYg = Yg * alpha + (fYg * (1.0 - alpha));
    fZg = Zg * alpha + (fZg * (1.0 - alpha));

    //Roll & Pitch Equations
    roll  = (atan2(-fYg, fZg)*180.0)/M_PI;
    pitch = (atan2(fXg, sqrt(fYg*fYg + fZg*fZg))*180.0)/M_PI;

    Serial.print(pitch);
    Serial.print(":");
    Serial.println(roll);

    delay(100);
}
---------------------------------------------------------------------------

Integrazioni dati da accelerometro ADXL335/GY-61

Ho provato ad usare, su suggerimento di un amico, l'accelerometro come misuratore di spostamento.
In estrema sintesi integrando i dati di accelerazione si puo' avere una stima, seppure un po' grossolana, di quanto e' stato spostato il sensore (ovviamente se il sensore viene spostato con velocita' costante questo sistema non funziona)

Il sistema che ho usato e' una schedina GY-61 su cui e' montato un ADXL335 gia' usato altre volte nella versione Sparkfun

Il problema maggiore e' cercare di gestire il rumore dello strumento e la deriva (su quello orginale Sparkfun il modulo non mostra deriva mentre su questo modello cinese la deriva e' presente)

Questo e' lo script per la gestione del calcolo dello spostamento su due assi (x,y); l'asse z ha una sensibilita' differente a quella su x ed y e diventa difficile fare misure accurate

Per prima cosa viene convertito il valore delle porte analogiche in accelerazione in m/s2 togliendo l'offset per avere una misura piu'possibile vicina a zero in condizioni statiche
Successivamente viene integrata la velocita' ed in seguito lo spostamento (vedi questo link per una spiegazione piu' dettagliata)
L'integrazione avviene mediando il valore della accelerazione tra il valore attuale e quello precedente e moltiplicando per il delta di tempo (qui impostato a 0.05 secondi)
Succesivamente si passa allo spostamento sui due assi e calcolando quindi la risultante dello spostamento sui due assi

Il calcolo viene effettuato solo se viene superato un valore di trigger in modo da evitare di registrare tutto il rumore
ATTENZIONE : questo calcolo funziona solo per moti su superfici orizzontali. In caso contrario viene registrata anche una componente della accelerazione di gravita' per cui i dati sono falsati
--------------------------------------------------------------------------
unsigned long time, old_time;
int x,y,z;
float xx,yy,zz,ax,ay;
float old_ax,old_ay,old_vx,old_vy; //
float vx,vy,av_ax,av_ay,av_vx,av_vy; //valori medi di acc e vel sui due assi
float dx,dy,old_dx,old_dy; //spostamento
float delta_time;
float risultante;

void setup() {
  Serial.begin(115200);
  old_ax=0;
  old_ay=0;
  old_vx=0;
  old_vy=0;
  old_dx=0;
  old_dy=0;
  av_ax=0;
  av_ay=0;
  av_vx=0;
  av_vy=0;
}

void loop() {
  //z = analogRead(A3);
  y = analogRead(A4);
  x = analogRead(A5);
  //zz = z * (5.0 / 1023.0);
  yy = y * (5.0 / 1023.0)-1.67;
  xx = x * (5.0 / 1023.0)-1.61;
 
  ax = 9.8*(xx/0.33);
  ay = 9.8*(yy/0.33);

  //toglie offset
  ax = ax + 0.06;
  ay = ay + 0.68 ;
 
if ((ax-old_ax) > 0.3)
  {
  //time = millis();
  //delta_time = (time - old_time)/1000;
  delta_time = 0.05;
 
  //calcolo dell'accelerazione media
  av_ax = (ax+old_ax)/2;
  av_ay = (ay+old_ay)/2;

  //calcolo della velocita'
  vx = old_vx + (av_ax * delta_time);
  vy = old_vy + (av_ay * delta_time);

  // calcolo della velocita' media
  av_vx = (vx+old_vx)/2;
  av_vy = (vy+old_vy)/2;

  // spostamento
  dx = old_dx + (av_vx * delta_time);
  dy = old_dy + (av_vy * delta_time);

  // risultante
  risultante = sqrt((dx*dx)+(dy*dy));

  Serial.print(ax);
  Serial.print(";");
  Serial.print(ay);
  Serial.print(";");
  Serial.print(vx);
  Serial.print(";");
  Serial.print(vy);
  Serial.print(";");
  Serial.print(dx);
  Serial.print(";");
  Serial.print(dy);
  Serial.print(";");
  Serial.println(risultante);
  }

  delay(50);
  //old_time = time;

  //scambio delle variabili
  old_dx = dx;
  old_dy = dy;
  old_vx = vx;
  old_vy = vy;
  old_ax = ax;
  old_ay = ay;
}
--------------------------------------------------------------------------

ADXL335 su Photon Particle

Ho avuto modo di provare una scheda Particle Photon, un modulo programmabile con WiFi, che ha la caratteristica principale di essere programmabile via Cloud con una interfaccia Web. Il prezzo attuale e' circa sui 19 dollari (spedizione esclusa)

Il processore e' un ARM Cortex M3 con un 1Mb di memoria flash e 128 Kb di ram con sistema operativo FreeRTOS 

La scheda e' estremamente piccola (pesa sui 5 grammi ed ha dimensioni di 36.5x20.3x6.8 mm, vedi per confronto la breadboard) e puo' essere alimentata da Usb oppure da VIN con un intervallo da 3.6 a 5.5 V

Immagine ufficiale dal sito del produttore

Si puo' derivare corrente dal pin 3V3 (3.3 V) oppure dal VIN (4.8 V/1A)
Il consumo dichiarato e' di 80 mA ma nelle mie prove ho visto un valore medio di 40 mA (con trasmittente accesa)

Sono disponibili 7 pin analogici con un ADC a 12 bit (come Arduino Due), una seriale TTL e 7 pin GPIO digitali

La programmazione avviene puntando il browser su https://build.particle.io e selezionando il proprio dispositivo.

Si programma in modo molto simile ad una Arduino e per caricare lo sketch sulla scheda si preme il pulsante del fulmine. Visto che tutto avviene via rete non e' necessario nessun cavo di collegamento dati e non e' nemmeno necessaria la vicinanza fisica (io la prova l'ho effettuato programmando da remoto senza averla nemmeno mai vista direttamente)


L'aspetto forse piu' interessante e' che le variabili (per esempio la lettura di un sensore) si possono effettuare direttamente via cloud. Non e' necessario conoscere l'IP della Photon e non e' necessario smanettare sul router per le regole delle porte del firewall

se nello sketch si inserisce una riga del tipo

Spark.variable("volts_x", &volts_x, DOUBLE);

il valore di questa variabile sara' disponibile all'indirizzo (con servizio REST)

https://api.particle.io/v1/devices/ID_PHOTON/volts_x?access_token=ACCESS_TOKEN

dove si deve sostituire a ID_PHOTON una stringa alfanumerica di 24 caratteri identificativa del dispositivo mentre ACCESS_TOKEN e' una stringa di 40 caratteri (entrambe si recuperano dall'interfaccia web cliccando nella colonna a sinistra in basso sul simbolo del mirino (Devices) per ID_PHOTON e su Settings per l'ACCESS_TOKEN

La risposta del sito e' qualcosa di questo tipo (il valore della variabile nel campo result)
--------------------------------------------------------------------------------

{
  "cmd": "VarReturn",
  "name": "volts_x",
  "result": 2.0012695312499997,
  "coreInfo": {
    "last_app": "",
    "last_heard": "2015-11-13T09:19:34.112Z",
    "connected": true,
    "last_handshake_at": "2015-11-13T09:19:02.262Z",
    "deviceID": "430024000e47343233323032",
    "product_id": 6
  }
}

--------------------------------------------------------------------------------
Un altro vantaggio dell'approccio Cloud e' che si puo' ospitare una pagina Web su un IP pubblico e gestire tutti i sensori con indirizzi su rete privata

Dato che le informazioni passano via Cloud non e' possibile avere un refresh estramamente veloce (nelle prove e' stato chiaro che scendere sotto 1Hz di refresh dei dati era molto difficile) 


Per provare la Photon ho collegato un Breakout ADXL335 di Sparkfun, accelerometro in uscita analogica, che e' settato per avere un passo di campionamento di 50 Hz (sono gia' presenti condensatori da 10 microFarad) con misure +/- 3g. Visto che e' stato alimentato a 3.3V la conversione tra V e g e' pari a 330mV/g. Quindi ad accelerazione zero viene letto un valore in tensione pari 1.65 v (3.3V/2). Effettuando la sottrazione tra il valore letto e 1.65 V ed effettuando la conversione si ha il valore in accelerazione g 
Il consumo dell'ADXL335 e' di circa 375 microAmpere


Attenzione : la sensibilita' e' differente sui vari assi. Su X e Y sono significative fino al centesimo di g mentre su Z e' significativo il decimo di g

Utilizzando questa pagina (modificata da un esempio trovato in rete) 

-----------------------------------------

<html>
    <head>
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js" type="text/javascript" charset="utf-8"></script>
    <script src="raphael-2.1.4.min.js"></script>
    <script src="justgage-1.1.0.min.js"></script>
    <script>
    var accessToken = "INSERIRE ACCESS TOKEN";
    var deviceID = "INSERIRE DEVICE ID"
    


    var url_x = "https://api.spark.io/v1/devices/" + deviceID + "/volts_x";
    var url_y = "https://api.spark.io/v1/devices/" + deviceID + "/volts_y";
    var url_z = "https://api.spark.io/v1/devices/" + deviceID + "/volts_y";


    function callback_x(data, status){
        if (status == "success") {
            volts_x = parseFloat(data.result);
            g.refresh(volts_x);
            setTimeout(getReading_x, 50);
} else {
            alert("There was a problem");
        }
}


    function callback_y(data, status){
        if (status == "success") {
            volts_y = parseFloat(data.result);
            g2.refresh(volts_y);
            setTimeout(getReading_y, 50);
} else {
            alert("There was a problem");
        }
}


    function callback_z(data, status){
        if (status == "success") {
            volts_z = parseFloat(data.result);
            g3.refresh(volts_z);
            setTimeout(getReading_z, 50);
} else {
            alert("There was a problem");
        }
}


    function getReading_x(){
         $.get(url_x, {access_token: accessToken}, callback_x);
    }
    function getReading_y(){
         $.get(url_y, {access_token: accessToken}, callback_y);
    }
    function getReading_z(){
         $.get(url_z, {access_token: accessToken}, callback_z);
    }




    </script>
    </head>
    <body>
    <table><tr>
    <td><div id="gauge_x" class="200x1600px"></div></td>
    <td><div id="gauge_y" class="200x160px"></div></td>
    <td><div id="gauge_z" class="200x160px"></div></td>
</tr></table>


<script>
        var g = new JustGage({
        id: "gauge_x",
        value: 0,
        min:-3.0,
        max: 3.0,
        title: "Acc. Z(g)",
        decimals : 2
        });
        getReading_x();


        </script>


        <script>
        var g2 = new JustGage({
        id: "gauge_y",
        value: 0,
        min: -3.0,
        max: 3.0,
        title: "Acc. Y(g)",
        decimals : 2
        });
        getReading_y();
        </script>


        <script>
        var g3 = new JustGage({
        id: "gauge_z",
        value: 0,
        min: -3.0,
        max: 3.0,
        title: "Acc. X(g)",
        decimals : 2
        });
        getReading_z();
    
    </script>
    </body>
    </html>

-----------------------------------------

Si puo' avere una lettura dei valori di accelerazione mediante Photon su Web

(ovviamente l'asse Z misura l'accelerazione di gravita' e quindi non e' zero, il valore dovrebbe essere piu' vicino ad 1, forse c'e' da rivedere il fattore di conversione)

Essendo una visualizzazione via Web il refresh dei dati e' piuttosto lento e lontano dalla frequenza di 50 Hz. In Javascript ho impostato un valore di lettura ogni 50 millisecondi ma aprendo in Chrome Strumenti per sviluppatori/Network si vede chiaramente che vengono impiegati dai 350 ai 500 ms per ogni transazione web (quindi un campionamento intorno a 2-3 Hz)

Una ultima considerazione : come "brand" scegliere Photon e Particle come nomi non e' che sia proprio un colpo di genio. Cercando sui motori di ricerca "Photon Particle" per ottenere informazioni su questo dispositivo saltano fuori seriosissimi articoli di fisica e non quanto desiderato

ADXL335 su Arduino Due

L'ADXL335 e' un accelerometro triassiale analogico.
Ne ho comprato uno gia' saldato su basetta su Sparkfun ed il suo utilizzo e' piuttosto immediato. Basta dare corrente e leggere i valori di tensione sui tre pin di misura (uno per ogni asse)

Problema: quale tensione?? Sulla scheda tecnica dell'ADXL335 c'e' indicato che deve alimentato a 3.3V mentre su altre fonti viene riportato che sulla schedina di Sparkfun c'e' gia' un regolatore di tensione per cui puo' essere alimentato dai 5V dell'Arduino
Per non rischiare ho alimentato il pin VCC con il pin da 3V dell'Arduino e collegato il GND

Per la prova ho utilizzato solo l'asse Z collegato alla porta A0 (analogica 0 dell'Arduino)
Ho utilizzato una Arduino Due piu' che altro per avere un dato a 12 bit

Lo sketch montato sulla scheda e' quanto mai semplice

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

void loop() {
  analogReadResolution(12);
  int sensorValue = analogRead(A0);
  Serial.println(sensorValue);
  delay(1);     
}
------------------------------------------------

Sul portatile ho messo un piccolo script in Python in modo da salvare oltre al dato anche il tempo (in millisecondi) per vedere quanto era stabile il passo di acquisizione

------------------------------------------------

import serial

import time

ser = serial.Serial('/dev/cu.usbmodem621', 9600)
while True:
line = ser.readline() 
millis = int(round(time.time() * 1000))
print str(millis)+","+line,
------------------------------------------------

Per avere un'idea della qualita' del dato ho fatto prima una misura cercando di non avere accelerazioni sull'asse verticale

Senza perturbazione

La misura ha avuto un valore medio di 1670 unita' +/- 2 unita' di standard deviation. Il valore massimo misurato e' stato di 1677 unita' (3 misure) ed un valore minimo di 1661 (1 misura)

Osservando la scala dei tempi, il passo di campionamento e' piuttosto variabile con un valore medio di 6 ms +/- 2 ms

Successivamente ho provato a fare una misura camminando attorno al tavolo dove era appoggiato il sensore.

Camminando attorno al tavolo

Il valore medio misurato e' stato di 1669 unita' (coerente con quello precedente) con valore massimo di 1679 u e minimo di 1659 u

Sul grafico sono inserite le rette dei valori massimi, minimo e +/- st.dev della misura senza perturbazione.

I dati sono molto grossolani ma c'e' una qualche indicazione che il sensore abbia registrato la variazione di accelerazione verticale indotta dal mio camminare

Giusto per prova ho provato anche con il campionamento a 10 bit sempre su Arduino 2

il valore medio e' stato di 419 unita' con una standard deviation di 0.5 unita' (su 500 misure)

419 unita' a 10 bit su Arduino 2 valgono 2.04 V

1669 unita' a 12 bit su Arduino 2 valgono 2.03 V

In questo caso pero' ho deliberatamente picchiettato sul tavolo (come si vede chiaramente dal grafico, nella figura in basso un ingrandimento). Si vedono chiaramente i rimbalzi del segnale

Cerchero' nei prossimi giorni di fare qualche esperienza di campagna per vedere se l'integrato puo' essere utilizzato come piccolo sismometro