-

hey viewer, we're moving!

We are currently transitioning to a new web system, so we are not updating this wikisite anymore.

The public part of the new web system is available at http://www.ira.disco.unimib.it


INFIND2011/12 Analog Intertial Measurement Unit

From Irawiki

Jump to: navigation, search

Students working on this project:


Contents

Introduzione

L'obiettivo del progetto è quello di configurare e leggere i dati dall'integrato L3G4200D interfacciando il microcontrollore con il sensore utilizzando il bus SPI, il tutto servendoci del sistema operativo ChibiOS.

Nel nostro componente abbiamo un giroscopio a 3 assi.

Relazione

Sensori/attuatori utilizzati

Giroscopio:

Il giroscopio è un dispositivo fisico usato per misurare la velocità angolare. Esso funziona secondo il principio fisico per la quale un oggetto vibrante tende a vibrare sullo stesso piano finchè il suo supporto ruota. Il sensore è quindi formato da oggetti vibranti attraverso la quale se ne ricavano i termini di Coriolis dell'equazione del moto, ottenendo quindi le velocità angolari del sensore. L'output di questo sensore è composto da tre valori: beccheggio, rollio e imbardata che si riferiscono alla rotazione del sensore rispetto gli assi: X, Y e Z.

Periferiche utilizzate

Serial Peripheral Interface (SPI):

Bus SPI: connessioni tra un master e un singolo slave (nostro caso).

Il Serial Peripheral Interface è un sistema di comunicazione tra un microcontrollore e altri circuiti integrati o tra più microcontrollori.

La trasmissione avviene tra un dispositivo detto master e uno o più slave, nel nostro specifico STM32F10x è da configurare come l'SPI master e L3G4200D è da configurare come un SPI slave. Il master controlla il bus, emettendo il segnale di clock, decidendo quando iniziare e terminare la comunicazione.

Il bus SPI si definisce:

  • seriale, ovvero le informazioni sono comunicate una di seguito all'altra e giungono sequenzialmente al ricevente nello stesso ordine in cui le ha trasmesse il mittente;
  • sincrono, per la presenza di un clock che coordina la trasmissione e ricezione dei singoli bit e determina la velocità di trasmissione;
  • full-duplex, in quanto lo scambio di dati può avvenire contemporaneamente in trasmissione e ricezione.

Per quanto riguarda la velocità di scambio dei dati (in pratica la frequenza del clock) non vi è un limite minimo, ma vi è un limite massimo che va determinato dai datasheet dei singoli dispositivi connessi, che nel nostro caso (L3G4200D) è di 10 MHz.

Il sistema è comunemente definito a quattro fili. Con questo si intende che le linee di connessione che portano i segnali sono in genere quattro:

  • SCLK - SCK: Serial Clock (emesso dal master);
  • SDI – MISO: Serial Data Input, Master Input Slave Output (ingresso per il master ed uscita dallo slave);
  • SDO – MOSI: Serial Data Output, Master Output Slave Input (uscita dal master ed ingresso per lo slave);
  • CS – SS: Chip Select, Slave Select, emesso dal master per scegliere con quale dispositivo slave vuole comunicare.

Nel nostro caso specifco, abbiamo a disposizione 3 controller SPI a bordo dell'STM32F10x e andiamo ad utilizzare SPI1 per interfacciarci con L3G4200D, con la seguente configurazione di pin:

  • SCLK - SCK: PA5;
  • SDI - MISO: PA6;
  • SDO - MOSI: PA7;
  • CS - SS: PB0.


Universal Synchronous/Asynchronous Receiver/Transmitter (USART):

Connessioni del nostro microcontrollore.

L'Universal Synchronous/Asynchronous Receiver/Transmitter è un dispositivo hardware di uso generale o dedicato. Converte flussi di bit di dati da un formato parallelo a un formato seriale sincrono o asincrono o viceversa.

Il bus USART si definisce:

  • seriale, ovvero le informazioni sono comunicate una di seguito all'altra e giungono sequenzialmente al ricevente nello stesso ordine in cui le ha trasmesse il mittente;
  • sincrono o asincrono, per la presenza o l'assenza di un clock che coordina la trasmissione e ricezione dei singoli bit;
  • full-duplex, in quanto lo scambio di dati può avvenire contemporaneamente in trasmissione e ricezione.

Il sistema è definito a tre fili. Con questo si intende che le linee di connessione che portano i segnali sono in genere tre:

  • RX: Receive Data Input (linea di ricezione);
  • TX: Transmit Data Output (linea di trasmissione);
  • CK: Transmitter Clock Output (clock necessario per la comunicazione sincrona, linea non utilzzata per la comunicazione asincrona).

Nel nostro caso specifico, abbiamo a disposizione 5 controller USART a bordo dell'STM32F10x e andiamo ad utilizzare USART1 per comunicare i dati letti in board, dal giroscopio, al pc con la seguente configurazione di pin:

  • TX: PA9;
  • RX: PA10.


External Interrupt/Event Controller (EXTI):

L'External Interrupt/Event Controller consiste di un insieme di edge detectors per la generazione di interrupt ed eventi date le richieste sulle linee d'ascolto.

Ogni linea d'input può essere configurata in modo indipendente per selezionare il tipo (pulse o pending) e il corrispondente evento d'attivazione (rising, falling o entrambi). Ogni linea può essere anche mascherata in modo indipendente.

Nel nostro caso specifico abbiamo a disposizione la gestione di 2 interrupt da parte dell'L3G4200D, della quale andiamo ad utilizzare GYRO_INT2 come data ready, per venire a conoscenza di quando son pronti i nuovi dati da leggere dal giroscopio. Il tutto segue la seguente configurazione dei pin:

  • GYRO_INT1: PB10;
  • GYRO_INT2: PB1.

Struttura del firmware

Per quanto riguarda il codice è impostato secondo la struttura di ChibiOS, con il codice del progetto principalmente in main.c, con l'ausilio del file l3g4200d.h, e le configurazioni nei file: board.h, chconf.h, halconf.h, mcuconf.h.

Di seguito descriviamo le configurazioni apportate a ChibiOs per il funzionamento del progetto e il codice scritto nei file prima elencati.


board.h

Questo file contiene la configurazione dei pin di input/output del microcontrollore e può contenere anche settaggi dipendenti dalla board.

Configurazione dei pin di I/O:

/*
 * Port A setup:
 * Everything input with pull-up except:
 * PA5  - Alternate output  (SPI1_SCK).
 * PA6  - Digital Input     (SPI1_MISO).
 * PA7  - Alternate output  (SPI1_MOSI).
 * PA9  - Alternate output  (USART1 TX).
 * PA10 - Normal input      (USART1 RX).
 */
#define VAL_GPIOACRL            0xB4B88888      /*  PA7...PA0 */
#define VAL_GPIOACRH            0x888884B8      /* PA15...PA8 */
/*
 * Port B setup:
 * Everything input with pull-up except:
 * PB0  - Push Pull output  (SPI1_CS -> GYRO_CS).
 * PB1  - Digital Input     (GYRO_INT2).
 * PB10 - Digital Input     (GYRO_INT1).
 * PB12 - Push Pull output  (LED1).
 * PB13 - Push Pull output  (LED2).
 * PB14 - Push Pull output  (LED3).
 * PB15 - Push Pull output  (LED4).
 */
#define VAL_GPIOBCRL            0x88888843      /*  PB7...PB0 */
#define VAL_GPIOBCRH            0x33338488      /* PB15...PB8 */

Definizione di alcuni nomi:

#define GYRO_GPIO         GPIOB
#define GYRO_CS           0
#define LED_GPIO          GPIOB
#define LED1              12
#define LED2              13
#define LED3              14
#define LED4              15


chconf.h

Questo file contiene la configurazione dei parametri e delle opzioni del kernel di ChibiOS, opzioni di performance, opzioni dei sottosistemi e le opzioni di debug.

Nel nostro caso in questo file siamo solo andati ad attivare delle opzioni di debug al fine di sviluppare il progetto:

/**
 * @brief   Debug option, system state check.
 * @details If enabled the correct call protocol for system APIs is checked
 *          at runtime.
 *
 * @note    The default is @p FALSE.
 */
#if !defined(CH_DBG_SYSTEM_STATE_CHECK) || defined(__DOXYGEN__)
#define CH_DBG_SYSTEM_STATE_CHECK       TRUE
#endif
/**
 * @brief   Debug option, parameters checks.
 * @details If enabled then the checks on the API functions input
 *          parameters are activated.
 *
 * @note    The default is @p FALSE.
 */
#if !defined(CH_DBG_ENABLE_CHECKS) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_CHECKS            TRUE
#endif
/**
 * @brief   Debug option, consistency checks.
 * @details If enabled then all the assertions in the kernel code are
 *          activated. This includes consistency checks inside the kernel,
 *          runtime anomalies and port-defined checks.
 *
 * @note    The default is @p FALSE.
 */
#if !defined(CH_DBG_ENABLE_ASSERTS) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_ASSERTS           TRUE
#endif
/**
 * @brief   Debug option, trace buffer.
 * @details If enabled then the context switch circular trace buffer is
 *          activated.
 *
 * @note    The default is @p FALSE.
 */
#if !defined(CH_DBG_ENABLE_TRACE) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_TRACE             TRUE
#endif
/**
 * @brief   Debug option, stack checks.
 * @details If enabled then a runtime stack check is performed.
 *
 * @note    The default is @p FALSE.
 * @note    The stack check is performed in a architecture/port dependent way.
 *          It may not be implemented or some ports.
 * @note    The default failure mode is to halt the system with the global
 *          @p panic_msg variable set to @p NULL.
 */
#if !defined(CH_DBG_ENABLE_STACK_CHECK) || defined(__DOXYGEN__)
#define CH_DBG_ENABLE_STACK_CHECK       TRUE
#endif

halconf.h

Questo è il file di configurazione dell'HAL (Hardware Abstraction Layer), questo file permette di attivare e disattivare le varie periferiche.

Nel nostro caso siamo andati ad attivare i seguenti driver:

  • Driver SPI, per la lettura dei dati dal giroscopio:
/**
 * @brief   Enables the SPI subsystem.
 */
#if !defined(HAL_USE_SPI) || defined(__DOXYGEN__)
#define HAL_USE_SPI                 TRUE
#endif
  • Driver Seriale, per la comunicazione seriale dei dati da board a pc:
/**
 * @brief   Enables the SERIAL subsystem.
 */
#if !defined(HAL_USE_SERIAL) || defined(__DOXYGEN__)
#define HAL_USE_SERIAL              TRUE
#endif
  • Driver EXTI, per la gestione degli interrupt generati dall'L3G4200D:
/**
 * @brief   Enables the EXT subsystem.
 */
#if !defined(HAL_USE_EXT) || defined(__DOXYGEN__)
#define HAL_USE_EXT                 TRUE
#endif


mcuconf.h

Questo è il file di configurazione dei driver del nostro particolare microcontrollore (STM32F103).

I settaggi di ogni driver hanno effetto solo se il driver intero è stato attivato nel file halconf.h.

Nel nostro caso siamo andati a configurare i seguenti driver:

  • Per quanto riguarda il driver dell'SPI, siamo andati ad abilitare SPI1 per la lettura dei dati da L3G4200D e abbiamo lasciato inalterate le priorità:
/*
 * SPI driver system settings.
 */
#define STM32_SPI_USE_SPI1                  TRUE
#define STM32_SPI_USE_SPI2                  FALSE
#define STM32_SPI_USE_SPI3                  FALSE
#define STM32_SPI_SPI1_DMA_PRIORITY         1
#define STM32_SPI_SPI2_DMA_PRIORITY         1
#define STM32_SPI_SPI3_DMA_PRIORITY         1
#define STM32_SPI_SPI1_IRQ_PRIORITY         10
#define STM32_SPI_SPI2_IRQ_PRIORITY         10
#define STM32_SPI_SPI3_IRQ_PRIORITY         10
#define STM32_SPI_DMA_ERROR_HOOK(spip)      chSysHalt()
  • Per quanto riguarda il driver seriale, siamo andati ad abilitare solo la USART1 per la comunicazione dei dati letti dalla board al pc e abbiamo lasciato inalterate le priorità:
/*
 * SERIAL driver system settings.
 */
#define STM32_SERIAL_USE_USART1             TRUE
#define STM32_SERIAL_USE_USART2             FALSE
#define STM32_SERIAL_USE_USART3             FALSE
#define STM32_SERIAL_USE_UART4              FALSE
#define STM32_SERIAL_USE_UART5              FALSE
#define STM32_SERIAL_USART1_PRIORITY        12
#define STM32_SERIAL_USART2_PRIORITY        12
#define STM32_SERIAL_USART3_PRIORITY        12
#define STM32_SERIAL_UART4_PRIORITY         12
#define STM32_SERIAL_UART5_PRIORITY         12
  • Il driver EXTI l'abbiamo lasciato con la configurazione di default, lasciando inalterate le priorità di interrupt request:
/*
 * EXT driver system settings.
 */
#define STM32_EXT_EXTI0_IRQ_PRIORITY        6
#define STM32_EXT_EXTI1_IRQ_PRIORITY        6
#define STM32_EXT_EXTI2_IRQ_PRIORITY        6
#define STM32_EXT_EXTI3_IRQ_PRIORITY        6
#define STM32_EXT_EXTI4_IRQ_PRIORITY        6
#define STM32_EXT_EXTI5_9_IRQ_PRIORITY      6
#define STM32_EXT_EXTI10_15_IRQ_PRIORITY    6
#define STM32_EXT_EXTI16_IRQ_PRIORITY       6
#define STM32_EXT_EXTI17_IRQ_PRIORITY       6
#define STM32_EXT_EXTI18_IRQ_PRIORITY       6
#define STM32_EXT_EXTI19_IRQ_PRIORITY       6


main.c

Questo è il file che contiene effettivamente il codice che descrive il comportamento del progetto, suddiviso in varie sezioni.

Ora andremo a descrivere passo per passo cosa accade in questo file.

int main()

  1. Puntatore alla shell inizializzato a null.
  2. Inizializzazione dell'HAL.
  3. Inizializzaione del Kernel d ChibiOs.
  4. Semaforo contatore (sem) inizializzato a 0.
  5. Attivazione del driver seriale 1 con configurazione di default.
  6. Inizializzazione dello shell manager.
  7. Attivazione del driver EXTI 1 con la nostra configurazione (extcfg).
  8. Acquisizione del bus di SPI 1.
  9. Attivazione del LED 1.
  10. Inizializzazione di SPI 1 con la nostra configurazione (spicfg).
  11. Inizializzazione di L3G4200D (spiStartup).
  12. Disattivazione del LED 1.
  13. Avvio del thread di lettura dei dati da L3G4200D (readingThread), risvegliato nell'handler di GYRO_INT2.
  14. Ciclo infinito di gestione della shell.

SPIConfig spicfg

  • Nessuna callback a operazione completata.
  • Porta di slave select: GYRO_GPIO (GPIOB).
  • Linea di slave select: GYRO_CS (0).
  • Configurazione di SPI_CR1: Velocità massima 9MHz (BR[2:0] = 001).

uint8_t spiRead(SPIDriver *spip, uint8_t regAddress)

  1. Attivazione dello Slave Select.
  2. Attivazione del bit di read nell'indirizzo del registro da leggere (regAddress).
  3. Invio dell'indirizzo del registro da leggere (regAddress + ReadBit).
  4. Ricezione del contenuto del registro richiesto.
  5. Disabilitazione dello Slave Select.
  6. Ritorno del contenuto del registro da leggere.

spiWrite(SPIDriver *spip, uint8_t regAddress, uint8_t data)

  1. Attivazione dello Slave Select.
  2. Invio dell'indirizzo del registro da scrivere (regAddress).
  3. Invio del dato da scrivere (data).
  4. Disabilitazione dello Slave Select.

spiStartup(SPIDriver *spip)

  1. Scrittura di CTRL_REG3:
    • Abilitazione del Data Ready su GYRO_INT2.
  2. Scrittura di CTRL_REG4:
    • Abilitazione del Block Data Update in modo tale che i registr di output non siano aggiornati fino alla lettura di MSB e LSB.
  3. Scrittura di CTRL_REG5:
    • Abilitazione del filtro passabasso sulla generazione dei dati di output.
    • Abilitazione del filtro passabasso sulla generazione dei dati d'interrupt.
  4. Scrittura di CTRL_REG1:
    • Abilitazione della Normal Mode.
    • Abilitazione dell'asse Z.
    • Abilitazione dell'asse Y.
    • Abilitazione dell'asse X.

EXTConfig extcfg

  • Configurazione in ascolto su PB1 (GYRO_INT 2) sul fronte di salita, con chiamata alla rispettiva callback (extcb_int2).

extcb_int2(EXTDriver *extp, expchannel_t channel)

  1. System Lock.
  2. Incremento del semaforo contatore (sem).
  3. System Unlock.

msg_t readingThread(void *arg)

  1. Configurazione del nome del thread.
  2. Abilitazione del canale 1 di EXTI (GYRO_INT2 su PB1).
  3. Ciclo infinito:
    1. Lettura di L3G4200D_OUT_X_L.
    2. Lettura di L3G4200D_OUT_X_H.
    3. Composizione di L3G4200D_OUT_X_L e L3G4200D_OUT_X_H.
    4. Lettura di L3G4200D_OUT_Y_L.
    5. Lettura di L3G4200D_OUT_Y_H.
    6. Composizione di L3G4200D_OUT_Y_L e L3G4200D_OUT_Y_H.
    7. Lettura di L3G4200D_OUT_Z_L.
    8. Lettura di L3G4200D_OUT_Z_H.
    9. Composizione di L3G4200D_OUT_Z_L e L3G4200D_OUT_Z_H.
    10. Stampa su seriale dei dati letti.
    11. Attesa di interrupt con timeout attraverso il semaforo contatore (sem).
    12. Se viene raggiunto il timeout:
      1. Attivazione del LED 4.
      2. Ritorno di valore d'errore.
  4. Ritorno del valore d'ok.

cmd_prova(BaseSequentialStream *chp, int argc, char *argv[])

  1. Se ci son parametri passati al comando:
    1. Stampa su seriale dell'uso del comando.
    2. Return.
  2. Lettura di L3G4200D_WHO_AM_I.
  3. Stampa su seriale di L3G4200D_WHO_AM_I.
  4. Lettura di L3G4200D_STATUS_REG.
  5. Stampa su seriale di L3G4200D_STATUS_REG.
  6. Lettura di L3G4200D_OUT_X_L.
  7. Lettura di L3G4200D_OUT_X_H.
  8. Composizione di L3G4200D_OUT_X_L e L3G4200D_OUT_X_H.
  9. Stampa su seriale dell'asse x.
  10. Lettura di L3G4200D_OUT_Y_L.
  11. Lettura di L3G4200D_OUT_Y_H.
  12. Composizione di L3G4200D_OUT_Y_L e L3G4200D_OUT_Y_H.
  13. Stampa su seriale dell'asse y.
  14. Lettura di L3G4200D_OUT_Z_L.
  15. Lettura di L3G4200D_OUT_Z_H.
  16. Composizione di L3G4200D_OUT_Z_L e L3G4200D_OUT_Z_H.
  17. Stampa su seriale dell'asse z.


l3g4200d.h

Questo è un file di supporto che contiene le definizioni dei nomi dei registri dell'L3G4200D dati gli indirizzi esadecimali.

#ifndef _L3G4200D_H_
#define _L3G4200D_H_

/*
 * Bit 0: RW bit.
 * When 0, the data DI(7:0) is written to the device.
 * When 1, the data DO(7:0) is read from the device.
 */
#define L3G4200D_RW                     0x80
/*
 * Bit 1: MS bit.
 * When 0, the address remains unchanged in multiple read/write commands.
 * When 1, the address is auto-incremented in multiple read/write commands.
 */
#define L3G4200D_MS                     0x40

/*
 * L3G4200D register names.
 */
#define L3G4200D_WHO_AM_I               0x0F
#define L3G4200D_CTRL_REG1              0x20
#define L3G4200D_CTRL_REG2              0x21
#define L3G4200D_CTRL_REG3              0x22
#define L3G4200D_CTRL_REG4              0x23
#define L3G4200D_CTRL_REG5              0x24
#define L3G4200D_REFERENCE		0x25
#define L3G4200D_OUT_TEMP		0x26
#define L3G4200D_STATUS_REG             0x27
#define L3G4200D_OUT_X_L		0x28
#define L3G4200D_OUT_X_H		0x29
#define L3G4200D_OUT_Y_L		0x2A
#define L3G4200D_OUT_Y_H		0x2B
#define L3G4200D_OUT_Z_L		0x2C
#define L3G4200D_OUT_Z_H		0x2D
#define L3G4200D_FIFO_CTRL_REG		0x2E
#define L3G4200D_FIFO_SRC_REG		0x2F
#define L3G4200D_INT1_CFG	        0x30
#define L3G4200D_INT1_SRC		0x31
#define L3G4200D_INT1_TSH_XH		0x32
#define L3G4200D_INT1_TSH_XL		0x33
#define L3G4200D_INT1_TSH_YH		0x34
#define L3G4200D_INT1_TSH_YL		0x35
#define L3G4200D_INT1_TSH_ZH		0x36
#define L3G4200D_INT1_TSH_ZL		0x37
#define L3G4200D_INT1_DURATION		0x38

#define L3G4200D_AXIS_X			0
#define L3G4200D_AXIS_Y			1
#define L3G4200D_AXIS_Z			2

#endif /* _L3G4200D_H_ */

Protocollo di comunicazione seriale

Grazie al driver seriale utilizzato in ChibiOS abbiamo a disposizione una comunicazione full duplex.

La comunicazione essenzialmente è utilizzata in modo unidirezionale, cioè dal microcontrollore verso il pc, per la comunicazione dei dati letti dal giroscopio, attraverso la seriale, a pc. I dati comunicati in questa modalità son stampati nel seguente formato:

L3G4200D_OUT: asse x, asse y, asse z

Esiste però la possibilità di comunicare con il microcontrollore, attraverso una shell, che si affida al canale seriale. Di default nella shell sono implementati alcuni comandi:

  • help, di default, con la quale è possibile osservare i comandi riconosciuti dalla sell e come è possibile utilizzarli.
  • mem, di default, che stampa informazioni relative alla memoria del microcontrollore.
  • threads, di default, che stampa informazioni riguardanti i thread del microcontrollore.
  • test, di default, che stampa il risultato di una serie di test eseguiti sul microcontrollore.
  • prova, di nostra implementazione, che stampa una serie d'informazioni provenianti dall'L3G4200D.

Nel dettaglio il comando prova stampa diverse informazioni nel seguente formato:

L3G4200D_WHO_AM_I: l3g4200d_who_am_i
L3G4200D_STATUS_REG: l3g4200d_status_reg
L3G4200D_OUT_X: Asse x
L3G4200D_OUT_Y: Asse y
L3G4200D_OUT_Z: Asse z

Per quanto questo comando non risulti utilizzabile durante il funzionamento del thread di lettura da L3G4200D, risvegliato dal Data Ready su GYRO_INT2, è stato implementato al fine di poter verificare lo stato del giroscopio qualora il thread di lettura terminasse in errore dopo aver raggiunto il timeout senza la lettura di nuovi dati.

Il giroscopio, per quanto riguarda le rotazioni rispetto ogni asse, suddivide il dato, a 16 bit, in due porzioni ad 8 bit, rispettivamente High and Low. Quindi per ogni asse: x, y e z, abbiamo in realtà due registri: x_h, x_l, y_h, y_l, z_h e z_l.

Per ricomporre il dato è quindi necessario eseguire la seguente operazione: (High << 8) | Low.

Prove sperimentali

La lettura dei dati del giroscopio viene visualizzata in numeri decimali e appare in questa forma:

File:Rotazione X.png

Nell'esempio sopra riportato possiamo notare una maggiore rotazione positiva sull'asse delle X.

Attraverso l'applicazione 3DVisualizator la lettura dei dati permette di ruotare un oggetto 3D a monitor in questo modo:

Nell'esempio sopra riportato possiamo notare una maggiore rotazione positiva sull'asse delle x (in quanto è possibile osservare maggiormente il lato rosso che è la faccia inferiore dell'oggetto 3D).

Gli assi di rotazione rispetto la board sono orientati nel seguente modo:

Risultati e conclusioni

I risultati ottenuti dal giroscopio sono buoni, anche se molto sensibili nonostante l'attivazione del filtro passabasso.

Son stati riscontrati alcuni problemi con la lettura dei dati attraverso l'interrupt di Data Ready, infatti il thread di lettura era risvegliato attraverso la generazione di un evento asincrono e non si notava il fatto che alcuni interrupt venivano persi. Quando poi è stato riscritto il metodo per risvegliare il thread di lettura dei dati attraverso messaggi sincroni, si è ottenuto che dopo qualche lettura il tutto si fermava, perchè la seriale non era abbastanza veloce per stampare i dati letti e una volta perso un segnale d'interrupt si perdeva la generazione dei successivi. Questo problema è stato risolto risvegliando il thread di lettura dei dati attraverso un semaforo contatore, incrementato nella funzione handler di GYRO_INT2, permettendo quindi di non perdere nessun segnale d'interrupt e andando a stampare appena possibile i dati pronti.

Manuale utente

Per poter utilizzare il nostro progetto bisogna:

  1. Effettuare i collegamenti hardware.
  2. Avviare uno strumento per la lettura di caratteri ascii da seriale (Come ad esempio il terminale di ChibiOS Studio) con la seguente configurazione:
    • Codifica: ISO-8859-1.
    • Tipo di connessione: Seriale.
    • Porta: COM3.
    • Baud Rate: 115200.
    • Data Bit: 8.
    • Stop Bit: 1.
    • Parità: No.
    • Controllo di flusso: No.
    • Timeout > 4 secondi.

Collegamenti hardware

Partendo dalla board:

  1. Collegare l'alimentazione ad una porta usb:
  2. Collegare il JTAG per poter leggere i dati da seriale attraverso l'usb:

Procedura di accensione

Per accendere la board è sufficiente effettuare i collegamenti hardware.

Allegati

Codice sorgente

http://irawiki.disco.unimib.it/irawiki/images/4/4a/Prova.zip

Codice sorgente di eventuali applicazioni lato PC

http://irawiki.disco.unimib.it/irawiki/images/e/eb/3DVisualizator.zip

Materiale utile

Collegamenti della board: http://irawiki.disco.unimib.it/irawiki/images/b/b4/IMU.pdf

STM32F103xx reference manual: http://www.st.com/web/en/resource/technical/document/reference_manual/CD00171190.pdf

L3G4200D datasheet: http://www.pololu.com/file/0J491/L3G4200D.pdf

L3G4200D application note: http://www.parallax.com/sites/default/files/downloads/27911-L3G4200D-Gyroscope-Application-Note.pdf

Personal tools