BNO055: modalità di alimentazione, accelerometro e interrupt di movimento – 4
In questo articolo, esploreremo le modalità di alimentazione del BON055 e ci concentreremo sulle funzionalità e sulla gestione dell’accelerometro.
Il BNO055 è un System in Package (SiP), che integra un accelerometro triassiale a 14 bit, un giroscopio triassiale a 16 bit con un intervallo di ±2000 gradi al secondo, un sensore geomagnetico triassiale e un microcontrollore Cortex M0+ a 32 bit con sistema Bosch Software di fusione dei sensori Sensortec, in un unico pacchetto.
Architettura
Prendo questa immagine dal datasheet per ricordare che questo sensore ha 3 sensori e un microcontrollore con un “software di fusione” per gestire i dati e darti una posizione assoluta.
Piedinatura BNO055
Esistono molti moduli diversi di questo sensore, io scelgo il più piccolo ed economico.
Ecco i moduli Aliexpress
Tutti questi moduli hanno le stesse funzionalità, ma per abilitarli è necessario eseguire operazioni diverse.
Questo è il clone che uso:
Ed ecco quello di Adafruit:
Il sensore supporta un livello logico 3.3v, ma il modulo può essere alimentato da 5v.
Modalità di alimentazione
Il BNO055 supporta tre diverse modalità di alimentazione: modalità normale, modalità a basso consumo e modalità sospensione.
Modalità normale
In modalità normale, tutti i sensori necessari per la modalità operativa selezionata sono sempre accesi. La mappa dei registri dell’MCU e le periferiche interne sono sempre operative in questa modalità.
Gli esempi sopra sono tutti in questa modalità predefinita.
Modalità di sospensione
In modalità di sospensione, il sistema viene messo in pausa e tutti i sensori e il microcontrollore vengono messi in modalità di sospensione. Nessun valore nella mappa registro verrà aggiornato in questa modalità.
Ecco un semplice sketch che mette in modalità sospensione
bno055_set_powermode(POWER_MODE_SUSPEND);
e quindi ripristinare lo stato normale.
bno055_set_powermode(POWER_MODE_NORMAL);
//Configuration to NDoF mode
bno055_set_operation_mode(OPERATION_MODE_NDOF);
Lo sketch completo:
/**
* An example that start bno055 in normal mode
* than suspend It and restore after 5 secs
*
* by Renzo Mischianti <www.mischianti.org>
*
* https://mischianti.org/
*/
#include "BNO055_support.h" //Contains the bridge code between the API and Arduino
#include <Wire.h>
//The device address is set to BNO055_I2C_ADDR2 in this example. You can change this in the BNO055.h file in the code segment shown below.
// /* bno055 I2C Address */
// #define BNO055_I2C_ADDR1 0x28
// #define BNO055_I2C_ADDR2 0x29
// #define BNO055_I2C_ADDR BNO055_I2C_ADDR2
//Pin assignments as tested on the Arduino Due.
//Vdd,Vddio : 3.3V
//GND : GND
//SDA/SCL : SDA/SCL
//PSO/PS1 : GND/GND (I2C mode)
//This structure contains the details of the BNO055 device that is connected. (Updated after initialization)
struct bno055_t myBNO;
struct bno055_euler myEulerData; //Structure to hold the Euler data
unsigned char accelCalibStatus = 0; //Variable to hold the calibration status of the Accelerometer
unsigned char magCalibStatus = 0; //Variable to hold the calibration status of the Magnetometer
unsigned char gyroCalibStatus = 0; //Variable to hold the calibration status of the Gyroscope
unsigned char sysCalibStatus = 0; //Variable to hold the calibration status of the System (BNO055's MCU)
unsigned long lastTime = 0;
/* Set the delay between fresh samples */
#define BNO055_SAMPLERATE_DELAY_MS (1000)
void setup() //This code is executed once
{
//Initialize I2C communication
Wire.begin();
//Initialization of the BNO055
BNO_Init(&myBNO); //Assigning the structure to hold information about the device
//Configuration to NDoF mode
bno055_set_operation_mode(OPERATION_MODE_NDOF);
delay(1);
//Initialize the Serial Port to view information on the Serial Monitor
Serial.begin(115200);
}
bool suspended = false;
bool reactivated = false;
void loop() //This code is looped forever
{
if ((millis() - lastTime) >= BNO055_SAMPLERATE_DELAY_MS) //To stream at 10Hz without using additional timers
{
lastTime = millis();
bno055_read_euler_hrp(&myEulerData); //Update Euler data into the structure
/* The WebSerial 3D Model Viewer expects data as heading, pitch, roll */
Serial.print(F("Orientation: "));
Serial.print(360-(float(myEulerData.h) / 16.00));
Serial.print(F(", "));
Serial.print(360-(float(myEulerData.p) / 16.00));
Serial.print(F(", "));
Serial.print(360-(float(myEulerData.r) / 16.00));
Serial.println(F(""));
bno055_get_accelcalib_status(&accelCalibStatus);
bno055_get_gyrocalib_status(&gyroCalibStatus);
bno055_get_syscalib_status(&sysCalibStatus);
bno055_get_magcalib_status(&magCalibStatus);
Serial.print(F("Calibration: "));
Serial.print(sysCalibStatus, DEC);
Serial.print(F(", "));
Serial.print(gyroCalibStatus, DEC);
Serial.print(F(", "));
Serial.print(accelCalibStatus, DEC);
Serial.print(F(", "));
Serial.print(magCalibStatus, DEC);
Serial.println(F(""));
}
if (millis() > 10000 && suspended == false) {
Serial.println("SUSPENDED!");
bno055_set_powermode(POWER_MODE_SUSPEND);
suspended = true;
}
if (millis() > 15000 && reactivated == false) {
Serial.println("REACTIVATED!");
bno055_set_powermode(POWER_MODE_NORMAL);
//Configuration to NDoF mode
bno055_set_operation_mode(OPERATION_MODE_NDOF);
reactivated = true;
}
}
E questo è il risultato:
Orientation: 280.37, 344.56, 325.44
Calibration: 0, 3, 3, 3
Orientation: 265.69, 334.94, 399.44
Calibration: 0, 3, 3, 3
Orientation: 285.50, 364.25, 326.12
Calibration: 0, 3, 3, 3
Orientation: 272.62, 327.37, 422.31
Calibration: 0, 3, 3, 3
Orientation: 272.37, 333.19, 420.56
Calibration: 0, 3, 3, 3
Orientation: 272.75, 335.37, 419.87
Calibration: 0, 3, 3, 3
Orientation: 276.62, 356.37, 344.31
Calibration: 0, 3, 3, 3
SUSPENDED!
Orientation: 360.00, 360.00, 360.00
Calibration: 0, 0, 0, 0
Orientation: 360.00, 360.00, 360.00
Calibration: 0, 0, 0, 0
Orientation: 360.00, 360.00, 360.00
Calibration: 0, 0, 0, 0
Orientation: 360.00, 360.00, 360.00
Calibration: 0, 0, 0, 0
Orientation: 360.00, 360.00, 360.00
Calibration: 0, 0, 0, 0
REACTIVATED!
Orientation: 276.87, 358.00, 357.69
Calibration: 0, 3, 3, 3
Orientation: 274.69, 343.81, 393.12
Calibration: 0, 3, 3, 3
Orientation: 277.25, 345.75, 412.94
Modalità a basso consumo
Se non viene rilevata alcuna attività (cioè nessun movimento) per una durata configurabile (predefinita 5 secondi), il BNO055 entra in modalità a basso consumo. In questa modalità è attivo solo l’accelerometro. Una volta rilevato il movimento (ovvero l’accelerometro segnala un’interruzione di qualsiasi movimento), il sistema viene riattivato e viene attivata la modalità normale . Sono possibili le seguenti impostazioni.
| Descrizione | Parametro | Valore |
|---|---|---|
| Entrare in modalità di sospensione: NESSUNA interruzione del movimento | Detection Type | No Motion |
| Detection Axis | ||
| Params | Duration | |
| Threshold |
| Descrizione | Parametro | Valore |
|---|---|---|
| Sveglia: qualsiasi interruzione del movimento | Detection Type | Detection Axis |
| Params | Duration | |
| Threshold |
Inoltre, i pin di interrupt possono anche essere configurati per fornire interrupt HW all’host.
Il BNO055 è, per impostazione predefinita, configurato per avere valori ottimali per entrare in modalità di sospensione e svegliarsi. Per ripristinare questi valori, attivare un ripristino del sistema mediante un ripristino del software.
Ci sono alcune limitazioni per ottenere le prestazioni della modalità a basso consumo:
- Sono applicabili solo gli interrupt di movimento No e Any e gli interrupt High-G e slow motion non sono applicabili in modalità a basso consumo.
- La modalità a basso consumo non è applicabile se l’accelerometro non è utilizzato.
Interrupts
bno055 interrupts
INT è configurato come pin di interruzione per segnalare un’interruzione all’host. Il trigger di interrupt è configurato come raising edge ed è agganciato al pin INT. Una volta che si verifica un’interruzione, il pin INT viene impostato su alto e rimarrà alto fino a quando non verrà ripristinato dall’host. Questo può essere fatto impostando RST_INT nel registro SYS_TRIGGER.
bno055_set_reset_int(1);
Gli interrupt possono essere abilitati impostando il bit corrispondente nel registro di abilitazione degli interrupt (INT_EN) e disabilitati quando viene azzerato.
bno055_get_int_gyro_anymotion(&gyro_am);
bno055_set_int_gyro_anymotion(1);
bno055_get_int_gyro_highrate(&gyro_hr);
bno055_set_int_gyro_highrate(1);
bno055_get_int_accel_high_g(&accel_hg);
bno055_set_int_accel_high_g(1);
bno055_get_int_accel_anymotion(&accel_am);
bno055_set_int_accel_anymotion(1);
bno055_get_int_accel_nomotion(&accel_nm);
bno055_set_int_accel_nomotion(1);
Mascheramento dei pin di interruzione
bno055_get_intmsk_gyro_anymotion(1);
bno055_set_intmsk_gyro_anymotion(1);
bno055_get_intmsk_gyro_highrate(1);
bno055_set_intmsk_gyro_highrate(1);
bno055_get_intmsk_accel_high_g(1);
bno055_set_intmsk_accel_high_g(1);
bno055_get_intmsk_accel_anymotion(1);
bno055_set_intmsk_accel_anymotion(1);
bno055_get_intmsk_accel_nomotion(1);
bno055_set_intmsk_accel_nomotion(1);
Gli interrupt possono essere indirizzati al pin INT impostando il corrispondente bit di interrupt nel registro INT_MSK.
Stato dell’interrupt
Le occorrenze di interrupt vengono memorizzate nel registro di stato dell’interrupt (INT_STA). Tutti i bit in questo registro vengono cancellati durante la lettura.
bno055_get_interrupt_status_gyro_anymotion(&gyr_anymotion);
bno055_get_interrupt_status_gyro_highrate(&gyr_highrate);
bno055_get_interrupt_status_accel_highg(&acc_highg);
bno055_get_interrupt_status_accel_anymotion(&acc_anymotion);
bno055_get_interrupt_status_accel_nomotion(&acc_nomotion);
Impostazioni di interruzione
Interruzione dati pronti (DRDY INT)
Data Ready Interrupt è un segnale all’host sulla disponibilità dei dati nella mappa del registro, in modo che l’host possa leggere immediatamente i dati del sensore quando i dati del sensore sono disponibili nella mappa del registro.
Sono disponibili i seguenti interrupt pronti per i dati,
- Accelerometro o interruzione dei dati di fusione pronti (ACC_BSX_DRDY)
- Interrupt dati pronti magnetometro (MAG_DRDY)
- Interruzione dati giroscopio pronti (GYR_DRDY)
In modalità non fusione:
- In modalità non fusione, l’interruzione dati pronti viene segnalata in base alle velocità dati dei singoli sensori configurate per i sensori.
- L’interrupt dati pronti “ACC_BSX_DRDY” viene impostato/attivato quando i dati dell’accelerometro sono disponibili nella mappa dei registri alla velocità dati configurata del sensore nella modalità operativa in cui l’accelerometro è attivo.
- L’interrupt dati pronti “MAG_DRDY” viene impostato/attivato quando i dati del magnetometro sono disponibili nella mappa del registro alla velocità dati configurata del sensore nella modalità operativa in cui il magnetometro è attivo.
In modalità fusione:
- In modalità fusione, l’interrupt data-ready viene segnalato in base alla velocità dati del sensore primario. L’interrupt dati pronti “ACC_BSX_DRDY” viene impostato/attivato quando i dati calibrati/di fusione sono disponibili nella mappa di registro alla frequenza primaria del sensore.
Comportamento dell’interruzione dei dati pronti:
Una volta che si verifica un’interruzione, il pin INT viene impostato su alto e rimarrà alto fino a quando non verrà ripristinato o letto dall’host. L’INT è impostato su basso e alto immediatamente quando si verificano più interruzioni prima che l’host venga reimpostato o letto.
Accelerometro Slow/No Motion Interrupt
| Parametri | Valori |
|---|---|
| Detection Type | No Motion |
| Slow Motion | |
| Interrupt Parameters | Threshold |
| Duration | |
| Axis selection | X-axis |
| Y-axis | |
| Z-axis |
Lo slow-motion/no-motion interrupt engine può essere configurato in due modalità.
Puoi selezionare slow-motion con questo comando:
bno055_set_accel_slow_no_motion_enable(0);
o no-motion con questo:
bno055_set_accel_slow_no_motion_enable(1);
L’interruzione slow-motion viene attivata quando la pendenza misurata di almeno un asse abilitato supera la soglia di pendenza programmabile per un numero programmabile di campioni.
Per ottenere il valore corrente della soglia
unsigned char accel_slow_no_thr = 0;
bno055_get_accel_slow_no_threshold(&accel_slow_no_thr);
o da impostare
bno055_set_accel_slow_no_threshold(10);
Quindi il motore si comporta in modo simile all’interruzione di qualsiasi movimento ma con un diverso insieme di parametri. Per sopprimere i falsi trigger, l’interruzione viene generata (cancellata) solo se un certo numero di punti dati di pendenza consecutivi è maggiore (minore) della soglia di pendenza data dal numero = + 1.
In modalità senza movimento, viene generato un interrupt se la pendenza su tutti gli assi selezionati rimane inferiore a una soglia programmabile per un tempo di ritardo programmabile .
La scalatura del valore di soglia è identica a quella slow-motion interrupt.
Per ottenere la durata, puoi usare questo comando:
unsigned char accel_am_dur = 0;
bno055_get_accel_anymotion_duration(&accel_am_dur);
e per impostare, puoi usare
bno055_set_accel_anymotion_duration(3); // to set 4secs
Tuttavia, in modalità no-motion, il registro slo_no_mot_dur definisce il tempo di ritardo prima che venga attivato l’interrupt no-motion.
| Valore | Ritardo |
|---|---|
| 0 | 1 s |
| 1 | 2 s |
| 2 | 3 s |
| … | … |
| 14 | 15 s |
| 15 | 16 s |
| 16 | 40 s |
| 17 | 48 s |
| 18 | 56 s |
| 19 | 64 s. |
| 20 | 72 s |
| 21 | 80 s |
| 32 | 88 s |
| 33 | 96 s |
| 34 | 104 s |
| … | … |
| 62 | 328 s |
| 63 | 336 s |
Accelerometro qualsiasi interruzione di movimento
| Parametri | Valori |
|---|---|
| Interrupt Parameters | Threshold |
| Duration | |
| Axis selection | X-axis |
| Y-axis | |
| Z-axis |
L’any-motion interrupt utilizza la pendenza tra segnali di accelerazione successivi per rilevare i cambiamenti nel movimento. Viene generato un interrupt quando la pendenza (valore assoluto della differenza di accelerazione) supera una soglia preimpostata. Viene liberato non appena la pendenza scende sotto la soglia.
Qualsiasi rilevamento del movimento può essere abilitato (disabilitato) per ciascun asse separatamente. I criteri per qualsiasi rilevamento del movimento sono soddisfatti e l’interruzione della pendenza viene generata se la pendenza di uno qualsiasi degli assi abilitati supera la soglia per un insieme di volte consecutive. Non appena le pendenze di tutti gli assi abilitati scendono o rimangono al di sotto di questa soglia per un insieme di volte consecutive, l’interruzione viene cancellata a meno che il segnale di interruzione non sia bloccato.
Come descritto, gli interrupt senza movimento sono l’interrupt di base in modalità LOW POWER; per impostazione predefinita, no-motion e any motion sono abilitati per impostazione predefinita, ma non l’interrupt bit mask per reindirizzare anche l’interrupt sul pin INT .
Interrupts sui registri
Quindi, se eseguiremo questo semplice sketch:
/**
* bno055 simple interrupt management
* enable only register interrupt for any motion and
* no motion in LOW POWER mode
* no bit mask for interrupt pin
*
* by Renzo Mischianti <www.mischianti.org>
*
* https://mischianti.org/
*/
#include "BNO055_support.h" //Contains the bridge code between the API and Arduino
#include <Wire.h>
//The device address is set to BNO055_I2C_ADDR2 in this example. You can change this in the BNO055.h file in the code segment shown below.
// /* bno055 I2C Address */
// #define BNO055_I2C_ADDR1 0x28
// #define BNO055_I2C_ADDR2 0x29
// #define BNO055_I2C_ADDR BNO055_I2C_ADDR2
//Pin assignments as tested on the Arduino Due.
//Vdd,Vddio : 3.3V
//GND : GND
//SDA/SCL : SDA/SCL
//PSO/PS1 : GND/GND (I2C mode)
//This structure contains the details of the BNO055 device that is connected. (Updated after initialization)
struct bno055_t myBNO;
struct bno055_euler myEulerData; //Structure to hold the Euler data
unsigned long lastTime = 0;
/* Set the delay between fresh samples */
#define BNO055_SAMPLERATE_DELAY_MS (1000)
void getIntInterruptEnabled();
void getIntInterruptBitMaskEnabled();
void getInterruptStatusEnabled(bool synthetic = false);
void printSlowMotionNoMotionParameters();
void setup() //This code is executed once
{
//Initialize I2C communication
Wire.begin();
//Initialization of the BNO055
BNO_Init(&myBNO); //Assigning the structure to hold information about the device
// bno055_set_reset_sys(1);
delay(1500);
bno055_set_powermode(POWER_MODE_LOW_POWER);
//Configuration to NDoF mode
bno055_set_operation_mode(OPERATION_MODE_NDOF);
// Activate SLOW MOTION
// bno055_set_accel_slow_no_motion_enable(0);
// Activate NO MOTION (default)
bno055_set_accel_slow_no_motion_enable(1);
delay(1);
//Initialize the Serial Port to view information on the Serial Monitor
Serial.begin(115200);
delay(1000);
getIntInterruptEnabled();
getIntInterruptBitMaskEnabled();
printSlowMotionNoMotionParameters();
}
bool suspended = false;
bool reactivated = false;
void loop() //This code is looped forever
{
if ((millis() - lastTime) >= BNO055_SAMPLERATE_DELAY_MS) //To stream at 10Hz without using additional timers
{
lastTime = millis();
bno055_read_euler_hrp(&myEulerData); //Update Euler data into the structure
Serial.print(millis()/1000); Serial.print("Secs - ");
/* The WebSerial 3D Model Viewer expects data as heading, pitch, roll */
Serial.print(F("Orientation: "));
Serial.print(360-(float(myEulerData.h) / 16.00));
Serial.print(F(", "));
Serial.print(360-(float(myEulerData.p) / 16.00));
Serial.print(F(", "));
Serial.print(360-(float(myEulerData.r) / 16.00));
Serial.print(F(" - "));
getInterruptStatusEnabled(true);
}
}
/*
* Print the interrupt enabled
*/
void getIntInterruptEnabled() {
unsigned char gyro_am = 0;
unsigned char gyro_hr = 0;
unsigned char accel_hg = 0;
unsigned char accel_am = 0;
unsigned char accel_nm = 0;
bno055_get_int_gyro_anymotion(&gyro_am);
bno055_get_int_gyro_highrate(&gyro_hr);
bno055_get_int_accel_high_g(&accel_hg);
bno055_get_int_accel_anymotion(&accel_am);
bno055_get_int_accel_nomotion(&accel_nm);
Serial.println( "---- Interrupt enabled ----" );
Serial.print( "Gyro Any Motion " );
Serial.println( gyro_am );
Serial.print( "Gyro High Rate " );
Serial.println( gyro_hr );
Serial.print( "Accel High G " );
Serial.println( accel_hg );
Serial.print( "Accel Any Motion " );
Serial.println( accel_am );
Serial.print( "Accel No Motion " );
Serial.println( accel_nm );
Serial.println( "---------------------------" );
}
/*
* Print the interrupt to send on interrupt pin
*/
void getIntInterruptBitMaskEnabled() {
unsigned char gyro_am = 0;
unsigned char gyro_hr = 0;
unsigned char accel_hg = 0;
unsigned char accel_am = 0;
unsigned char accel_nm = 0;
bno055_get_intmsk_gyro_anymotion(&gyro_am);
bno055_get_intmsk_gyro_highrate(&gyro_hr);
bno055_get_intmsk_accel_high_g(&accel_hg);
bno055_get_intmsk_accel_anymotion(&accel_am);
bno055_get_intmsk_accel_nomotion(&accel_nm);
Serial.println( "---- Interrupt bitmask ----" );
Serial.print( "Gyro Any Motion " );
Serial.println( gyro_am );
Serial.print( "Gyro High Rate " );
Serial.println( gyro_hr );
Serial.print( "Accel High G " );
Serial.println( accel_hg );
Serial.print( "Accel Any Motion " );
Serial.println( accel_am );
Serial.print( "Accel No Motion " );
Serial.println( accel_nm );
Serial.println( "---------------------------" );
}
/*
* Print the interrupt status
*/
void getInterruptStatusEnabled(bool synthetic) {
// 37 INT_STA 0x00 ACC_NM ACC_AM ACC_HIGH_G GYR_DRDY GYR_HIGH_RATE GYRO_AM MAG_DRDY ACC_BSX_DRDY
#pragma pack(push, 1)
struct StatusInterrupt {
byte accel_bsx_drdy : 1;
byte mag_drdy : 1;
byte gyro_am : 1;
byte gyro_high_rate : 1;
byte gyro_drdy : 1;
byte accel_high_g : 1;
byte accel_am : 1;
byte accel_nm : 1;
};
#pragma pack(pop)
StatusInterrupt registerByte = {0};
// Read all tht INT_STA addr to get all interrupt status in one read
// after the read the register is cleared
BNO055_RETURN_FUNCTION_TYPE res = bno055_read_register(BNO055_INT_STA_ADDR, (unsigned char *)(®isterByte), 1);
if (res == 0) {
if (synthetic){
Serial.print("Anm Aam Ahg Grd Ggr Gam Mrd Abr --> ");
Serial.print( registerByte.accel_nm );
Serial.print( registerByte.accel_am );
Serial.print( registerByte.accel_high_g );
Serial.print( registerByte.gyro_drdy );
Serial.print( registerByte.gyro_high_rate );
Serial.print( registerByte.gyro_am );
Serial.print( registerByte.mag_drdy );
Serial.println( registerByte.accel_bsx_drdy );
}else{
Serial.print( "Gyro Any Motion " );
Serial.println( registerByte.gyro_am );
Serial.print( "Gyro High Rate " );
Serial.println( registerByte.gyro_high_rate );
Serial.print( "Accel High G " );
Serial.println( registerByte.accel_high_g );
Serial.print( "Accel Any Motion " );
Serial.println( registerByte.accel_am );
Serial.print( "Accel No Motion " );
Serial.println( registerByte.accel_nm );
}
} else {
Serial.println("Error status!");
}
}
void printSlowMotionNoMotionParameters(){
unsigned char accel_slow_no_thr = 0;
bno055_get_accel_slow_no_threshold(&accel_slow_no_thr);
Serial.print("Slow motion/no motion threshold: ");
Serial.println(accel_slow_no_thr);
unsigned char accel_am_dur = 0;
bno055_get_accel_anymotion_duration(&accel_am_dur);
Serial.print("Slow motion/no motion duration: ");
Serial.println(accel_am_dur);
}
Ecco l’output seriale; gli interrupt abilitati su POWER_MODE_LOW_POWER sono Any motion e No Motion come scritto nel paragrafo che descrive la modalità a basso consumo.
---- Interrupt enabled ----
Gyro Any Motion 0
Gyro High Rate 0
Accel High G 0
Accel Any Motion 1
Accel No Motion 1
---------------------------
---- Interrupt bitmask ----
Gyro Any Motion 0
Gyro High Rate 0
Accel High G 0
Accel Any Motion 0
Accel No Motion 0
---------------------------
Slow motion/no motion threshold: 10
Slow motion/no motion duration: 3
2Secs - Orientation: 168.00, 363.25, 354.19 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
3Secs - Orientation: 168.00, 363.19, 354.12 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
4Secs - Orientation: 168.00, 363.19, 354.12 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
5Secs - Orientation: 173.62, 363.00, 353.94 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 01000000
6Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 01000000
7Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
8Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
9Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
10Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
11Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
12Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
13Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 10000000
14Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
15Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
16Secs - Orientation: 163.19, 362.94, 353.25 - Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 00000000
Quando scuoto il bno055, solleva il perno di qualsiasi movimento 2 volte,
Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 01000000
quindi smetto di spostarlo e, dopo 6 secondi, non viene generata alcuna interruzione del movimento.
Anm Aam Ahg Grd Ggr Gam Mrd Abr --> 10000000
The sketch was very simple, but as you can see, I must redò the function that read the status of interrupt, the implementation of the library
bno055_get_interrupt_status_gyro_anymotion(&gyr_anymotion);
bno055_get_interrupt_status_gyro_highrate(&gyr_highrate);
bno055_get_interrupt_status_accel_highg(&acc_highg);
bno055_get_interrupt_status_accel_anymotion(&acc_anymotion);
bno055_get_interrupt_status_accel_nomotion(&acc_nomotion);
Non risulta molto efficiente perché puoi solo leggere un parametro di interrupt; dopo la prima lettura del registro, tutti i dati vengono cancellati e non puoi sapere se vengono sollevati altri interrupt, quindi ottengo tutti i bit in una lettura e poi stampo lo stato di tutti gli interrupt .
Grazie
- BNO055 accelerometro, giroscopio, magnetometro con la semplice libreria Adafruit
- BNO055 per esp32, esp8266 e Arduino: cablaggio e libreria Bosch avanzata
- BNO055 per esp32, esp8266 e Arduino: caratteristiche, configurazione e rimappatura assi
- BNO055: modalità di alimentazione, accelerometro e interrupt di movimento
- BNO055 per esp32, esp8266 e Arduino: abilitare il pin INT e High G Interrupt dell’accelerometro
- BNO055 per esp32, esp8266 e Arduino: giroscopio ad alta velocità e interrupt per ogni movimento
