Accelerometro Tre Assi MMA7361

NE555   Tutorial sul Modulo Accelerometro Tre Assi MMA7361. Verranno Illustrate Caratteristiche Elettriche e Presentato uno Schema con Microcontrollore e Accelerometro…


 
 
 
 




 

MODULO MMA7361, PIN, FUNZIOAMENTO E CARATTERISTICHE

Il modulo MMA7361 è un modulo che contiene l’integrato MMA7361 che è il cuore del modulo, poi dispone di condensatori di filtraggio e un led per la segnalazione della presenza alimentazione. Per alimentare il modulo si può usare una tensione a 5V o una a 3.3V. L’integrato si alimenta a 3.3V, quindi il modulo dispone di un regolatore lineare per passare da 5V a 3.3V, ma se si alimenta a 3.3V il regolatore non viene utilizzato. La piedinatura del modulo è:

NE555

I pin hanno la seguente funzione:

  • 5V: è l’ingresso della tensione di alimentazione a 5V, la tensione di ingresso per il regolatore lineare. Questa tensione può essere al massimo 7V e al minimo 3.6V.
  • 3V3: è la tensione fornita direttamente al chip, questa può essere compresa nel range 3.6V 2.2V con un consumo di corrente di 400µA quando il chip è in funzione.
  • GND: è la massa del modulo.
  • g-Select (GS): questo pin serve a selezionare la sensibilità del modulo. Se vi è un segnale 0 si utilizza la sensibilità 1.5g e si hanno 800mV per ogni g, se si ha invece un segnale alto su questo pin allora si ha una sensibilità di 6g e quindi si hanno 206mV/g. La sensibilità può essere sempre cambiata.
  • Selftest (ST): se si invia un segnale alto su questo pin si va a testare se tutto funziona, quando si va a testare il funzionamento, viene creato un campo magnetico che crea un segnale come se su x e y vi siano -0.1g e su z 1g.
  • X,Y, Z: sono le tre uscite analogiche. Si ha un offset di 1.65V quando si ha un accelerazione di 0g e a questo segnale si somma la tensione dovuta all’accelerazione. Ad esempio se si ha un accelerazione di -1g sull’asse X con sensibilità di 1.5g, si avrà un segnale sul pin X di (1.65 – 1*0.8)=0.850V.
  • Sleep (SL): questo pin serve per disabilitare il modulo. Se si ha un segnale alto il modulo funziona normalmente, se si ha un segnale basso allora il modulo è in sleep e non funziona. Serve ad avere un consumo di 3µA.
  • 0g-Detect (0G): questo pin serve per rivelare se c’è accelerazione o no, se si ha un segnale alto allora vuol dire che ci sono 0g in ogni direzione, in caso contrario vuol dire che vi è una accelerazione su qualche asse.

Il sistema riesce a rilevare variazioni di accelerazione che avvengono al con una velocità massima di 400Hz lungo gli assi X e Y e variazioni alla velocità di 300Hz lungo l’asse Z.  L’integrato per rilevare l’accelerazione utilizza un sistema capacitivo in cui vi sono due armature fisse e una che si muove in funzione dell’accelerazione. Lo schema a blocchi e il sistema per rilevare l’accelerazione sono i seguenti:

NE555

Il blocco “G-CELL SENSOR” contiene le tre capacità disposte lungo i tre assi per rilevare l’accelerazione. L’informazione di capacità viene trasformata in informazione di tensione, questa tensione viene filtrata e amplificata in base alla sensibilità. Vi è inoltre un blocco per compensare la temperatura, visto che possono esserci variazione del segnale in base alla temperatura e non dell’accelerazione. Inoltre vi sono blocchi di controllo e ausiliari.

 




 
LEGGERE L’ACCELERAZIONE DAL MODULO

Parliamo un po’ di fisica. L’accelerazione terrestre, ovvero quella gravitazionale, è di circa 9.8m/s^2, e questa accelerazione viene indicata con 1g. Quindi si ha lungo l’asse z un segnale che indica di avere 1g di accelerazione. Per quanto riguarda asse X e Y si avrà un segnale diverso da quello di offset se il modulo si muove verso destra o sinistra oppure avanti o indietro, oppure se il modulo è inclinato. Se il modulo è inclinato, infatti, l’accelerazione gravitazionale sarà su due o tre assi.

Il segnale che contiene l’informazione sulla accelerazione è una informazione di tensione analogica, quindi per conoscere l’accelerazione ci vuole un ADC e un microcontrollore dispone di un ADC a più canali, quindi si può usare un PIC18F per leggere  e fare operazioni sul segnale in uscita dal modulo.

Principalmente l’operazione da fare è quella della conversione da analogico a digitale, in questo modo si possono fare varie operazioni sul segnale. Ad esempio se si ha un drone, e si vuole sapere se è parallelo all’orizzonte, basta controllare asse X e Y e se questi valori sono uguali all’offset dell’accelerometro vuol dire che il modulo e quindi il drone è parallelo all’orizzonte.

Per testare il modulo verrà scritto un codice e creato un circuito che va a leggere l’informazione analogica sugli assi X, Y e Z, con questi valori si va a creare un flag che avverte se il modulo è parallelo all’orizzonte e infine questi valori vengono convertiti per essere visualizzati su un display LCD.
 
CODICE ESEMPIO MIKROC

Il codice è il seguente:

sbit LCD_RS at RB0_bit;                     //Config connessioni LCD
sbit LCD_EN at RB1_bit;
sbit LCD_D4 at RB2_bit;
sbit LCD_D5 at RB3_bit;
sbit LCD_D6 at RB4_bit;
sbit LCD_D7 at RB5_bit;

sbit LCD_RS_Direction at TRISB0_bit;        //Config connessioni LCD
sbit LCD_EN_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB4_bit;
sbit LCD_D7_Direction at TRISB5_bit;

unsigned int Xinit, Yinit, Zinit, Conv;     //Variabili senza segno
signed int Xasse, Yasse, Zasse, Visual;     //variabili con segno
char TXT[4];                                //Variabile testo


void main() {                               //programma principale

  TRISB = 0x00;                             //PORTB tutte uscite
  TRISA = 0b11100000;                       //Primi tre I/0 TRISA ingressi

  Lcd_Init();                               //Inizializza LCD
  Lcd_Cmd(_LCD_CLEAR);                      //Pulisci LCD
  Lcd_Cmd(_LCD_CURSOR_OFF);                 //Cursore spento

  ADC_Init();                               //Inizializza ADC

  Delay_ms(500);                            //Attesa di stabilizzazione

  Xinit = ADC_Get_Sample(0);                //Leggi valore di riposo asse X
  Yinit = ADC_Get_Sample(1);                //Leggi valore di riposo asse Y
  Zinit = ADC_Get_Sample(2);                //Leggi valore di riposo asse Z
  
  Delay_ms(500);                            //Attesa di stabilizzazione

  while(1){
    Conv =  ADC_Get_Sample(0);              //Leggi valore di riposo asse X
    Xasse = (Conv-Xinit)*6;                 //Sottrai valore a riposo e x6
    IntToStr(Xasse, TXT);                   //Trasforma in stringa
    Lcd_Cmd(_LCD_CLEAR);                    //Pulisci LCD
    Lcd_Out(1, 1, " Acc X");                //Informa che è il dato lungo X
    Lcd_Out(2, 4, TXT);                     //mostra valore in millesimo di g
    Delay_ms(700);                          //Aspetta 0.7S per visualizzare

    Conv =  ADC_Get_Sample(1);              //Leggi valore di riposo asse Y
    Xasse = (Conv-Yinit)*6;                 //Sottrai valore a riposo e x6
    IntToStr(Xasse, TXT);                   //Trasforma in stringa
    Lcd_Cmd(_LCD_CLEAR);                    //Pulisci LCD
    Lcd_Out(1, 1, " Acc Y");                //Informa che è il dato lungo Y
    Lcd_Out(2, 4, TXT);                     //mostra valore in millesimo di g
    Delay_ms(700);                          //Aspetta 0.7S per visualizzare

    Conv =  ADC_Get_Sample(2);              //Leggi valore di riposo asse Z
    Xasse = (Conv-Zinit)*6;                 //Sottrai valore a riposo e x6
    IntToStr(Xasse, TXT);                   //Trasforma in stringa
    Lcd_Cmd(_LCD_CLEAR);                    //Pulisci LCD
    Lcd_Out(1, 1, " Acc Z");                //Informa che è il dato lungo Z
    Lcd_Out(2, 4, TXT);                     //mostra valore in millesimo di g
    Delay_ms(700);                          //Aspetta 0.7S per visualizzare
  }
}

Prima di tutto si va a configurare la connessione tra il display LCD e il microcontrollore visto che si vuole visualizzare il valore dell’accelerazione su LCD. Poi vengono inizializzate le variabili che contengono il valore dell’ADC quando il sensore è a riposo, ovvero poggiato su un piano perfettamente parallelo all’orizzonte, in questo modo si possono conoscere le forze esterne che sono le successive variabili inizializzate insieme alla stringa che contiene il testo da visualizzare.

Nel programma principale vengono settati gli I/O, viene inizializzato l’LCD e configurato e viene inizializzato anche l’ADC. Infine vi è un ciclo infinito nel quale si va a leggere e visualizzare uno per volta i valori di accelerazione.

Nel ciclo infinito si inizia a leggere il valore lungo l’asse X, poi a questo valore si sottrae il valore a riposo, in questo modo si può sapere se il sensore è stato inclinato oppure se vi è una forza esterna . Si è utilizzata un sensibilità a 1.5g, quindi nel caso massimo, con 1.5g si ha un segnale di 1.2V (800mv * 1.5) che si somma al segnale a riposo ovvero 1.65V circa. Sottraendo però al valore istantaneo di accelerazione il valore a riposo si ottiene un valore minimo di -1.2V e massimo di 1.2V, visto che si ha una alimentazione di 5V si ha un passo di quantizzazione di 4.8875mV quindi 1.2V vengono convertiti con il numero 245. Il valore convertito 245 corrisponde a 1.5g e visto che sul display si visualizzano i valori di accelerazione in millesimo di g, per arrivare a 1500 bisogna moltiplicare 245 per 6.1. Visto che si è deciso di non utilizzare numeri floating, la sottrazione tra il valore attuale e quella a riposo viene moltiplicata solo per 6. Si perde un pò di informazione ma non è un problema visto che si vuole solo visualizzare il valore e non si devono fare operazioni di controllo preciso.

Una volta ottenuto il valore in millesimo di g questo viene trasformato in stringa, poi si va a scrivere sulla prima riga quale accelerazione si sta visualizzando e sulla seconda riga il valore. Infine per la visualizzazione lungo X si inserisce un ritardo per permettere all’operatore di visualizzare il valore dell’accelerazione.

Per gli altri assi si eseguono le stesse operazioni.

 

SCHEMA

Lo schema è il seguente:

NE555

Visto che è una applicazione di prova si è scelto di utilizzare una alimentazione a 5V, provvederà il regolatore interno al modulo a ridurre la tensione a 3.3V. Conviene alimentare tutto a 3.3V quando il sistema è alimentato a batteria, in modo tale da ridurre i consumi. Il modulo ha i pin di self test e g-Select connessi a massa per avere 1.5g di sensibilità e non essere in fase di test. Il pin sleep è connesso a Vcc per non avere il modulo in sleep. All’uscita 0g si può inserire un led blu con resistenza di protezione per visualizzare quando il modulo informa che vi sono 0g. Le uscite X, Y e Z vanno direttamente agli ingressi del PIC18F252, in particolare agli ingressi analogici.

Il circuito di oscillazione può essere formato da un cristallo da 4MHz e due condensatori da 22pF, come visto negli schemi precedenti. L’alimentazione è da 5V e vi è la resistenza R1 da 1K mantiene non resettato il microcontrollore. La resistenza RV1 è la resistenza per il contrasto dell’LCD. I pin di alimentazione del microcontrollore sono i pin 8 e 19 per GND mentre 20 per VCC. Il microcontrollore scelto è il PIC18F25. LCD è connesso al PORTB come da schema e i pin non utilizzati dell’LCD sono connessi a massa.

Lo schema montato su breadboard ha il seguente aspetto:

NE555

 

DOWNLOAD

Per il download del codice, dell’HEX da inserire nel microcontrollore con i fuses già settati e per la simulazione cliccate sul seguente LINK!!!



 

1510 Visite totali 15 Visite di oggi

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *