Détecter les collisions avec un accéléromètre

Je cherche un moyen de détecter les chocs lorsqu'un robot est en mouvement.

Détecter si le robot a buté sur un obstacle et agir en conséquence.

J'ai testé avec un NBO055. Je prend les valeurs brut de l'accéléromètre. Très simplement, j'arrive à obtenir les dépassement de seuils fixés arbitrairement. Là, j'ai cherché sur l'axe X. C'est la même chose sur l'axe Y. Au final, j'aurai besoin des 2 pour obtenir un vecteur sur le plan XY. Jusque là, pas de pb.

Le code de mon test :

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>

#define BNO055_SAMPLERATE_DELAY_MS (100)

Adafruit_BNO055 bno = Adafruit_BNO055();

#define LED_AVANT 8
#define LED_ARRIERE 7

void setup(void)
{
  Serial.begin(115200);
 
  /* Initialise the sensor */
  if(!bno.begin())
  {
    /* There was a problem detecting the BNO055 ... check your connections */
    Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }

  pinMode(LED_AVANT, OUTPUT);
  pinMode(LED_ARRIERE, OUTPUT);
 
  delay(1000);
}

#define SEUIL 2.0
double lastVal = 0;
double integrale = 0;

void loop(void)
{
  // Possible vector values can be:
  // - VECTOR_ACCELEROMETER - m/s^2
  // - VECTOR_LINEARACCEL   - m/s^2
  // - VECTOR_GRAVITY       - m/s^2
  imu::Vector<3> euler = bno.getVector(Adafruit_BNO055::VECTOR_LINEARACCEL);
  double accel = euler.x();
  double derivee = accel-lastVal;
  integrale += accel;
  lastVal = accel;
  if(accel > SEUIL) {
    digitalWrite(LED_AVANT, HIGH);
    delay(100);
    digitalWrite(LED_AVANT, LOW);
  }
  if(accel < -1*SEUIL) {
    digitalWrite(LED_ARRIERE, HIGH);
    delay(100);
    digitalWrite(LED_ARRIERE, LOW);
  }
  /* Display the floating point data */
  Serial.print(accel);
  Serial.print(",");
  //Serial.print(derivee);
  //Serial.print(",");
  //Serial.print(integrale);
  Serial.print(",");
  Serial.print(SEUIL);
  Serial.print(",");
  Serial.print(-1*SEUIL);
  Serial.println("");
  
  delay(BNO055_SAMPLERATE_DELAY_MS);
}

 IMG_4310 2.jpg   134,55 Ko   26 téléchargement(s)

En dehors de la video, j'ai testé de bouger le BNO le long d'une règle avec une butée massive. A l'oeil, j'ai appliqué une vitesse toujours la même.  Mais je n'arrive pas à obtenir un cas reproductible. Je déclenche un choc pour une certaine vitesse. Et l'essai d'après, en allant plus vite, pas de dépassement du seuil au moment du choc ... J'ai testé des seuils sur la valeur d'accélération, sa dérivée , son intégrale, l'intégrale de la dérivée ... ne sachant plus quoi tester.

Je crois que je m'y prend mal. Vous auriez une solution simple pour donner un mouvement uniforme rectiligne que je pourrait stopper brutalement ?

Peut-être que j'aurai facilement ce mouvement uniforme sur le robot final. Mais je voudrait valider que la technique de détection des chocs est la bonne.

Un code que j'utilise perso pour ce genre de chose : 

void Accelerometer(int xaxis, int yaxis, int zaxis)
{
  static int oldx,oldy,oldz,vibration;                        // local variables used for impact detection
   
  vibration--;                                                // loop counter prevents false triggering cause by impact vibration
  if(vibration<0) vibration=0;                                // as robot vibrates due to impact
  
  if(vibration>0) return;                                     // until vibration has subsided no further calculations required
  
  deltx=xaxis-oldx;                                           // difference between old and new axis readings
  delty=yaxis-oldy;
  deltz=zaxis-oldz;
  magnitude=sqrt(sq(deltx)+sq(delty)+sq(deltz));              // magnitude of delta x,y,z using Pythagorus's Theorum
  
  oldx = xaxis;
  oldy = yaxis;
  oldz = zaxis;

  if (magnitude>sensitivity)                                  // has a new impact occured
  {
    vibration=devibrate;                                      // reset anti-vibration counter
    return;
  }
  else
  {
    magnitude=0;                                              // no impact detected
    deltx=0;
    delty=0;
    deltz=0;
  }
}
  

Tu devrais mettre ton module sur ton robot et voir ce que tu as comme bruit. 

Merci tous les 2 ^^

Ashira, en effet, ça me paraît plus simple pour observer le comportement réel.

Mike, si je comprend bien l'algo, on a 2 constantes à trouver pour le faire fonctionner :

- devibrate : il exprime un délai entre une collision et le test suivant de magnitude.

- sensitivity : c'est le seuil de magnitude qui détermine la collision.

Je vais tester ça

Apres y a aussi les détecteurs de vibration... liens

Salut,

Moi je travaillerais sur l'axe des Z, c'est plus simple. Après si ca marche sur un axe ça devrait être applicable facilement sur les autres.

Pourquoi sur Z, parce que tu peux choisir de faire "tomber" le module d'une hauteur fixe pour rester dans des conditions similaires. Ou autre possibilité, tu mets le capteur fixé dans une petite boite "dure" et tu fais tomber qqc dessus (genre boulon/ecrou) toujours d'une hauteur fixée, ça a l'avantage de ne pas risquer d'abimer ton module.

Merci tous les 2 ^^

 

Ashira, en effet, ça me paraît plus simple pour observer le comportement réel.

 

Mike, si je comprend bien l'algo, on a 2 constantes à trouver pour le faire fonctionner :

- devibrate : il exprime un délai entre une collision et le test suivant de magnitude.

- sensitivity : c'est le seuil de magnitude qui détermine la collision.

 

Je vais tester ça

Oui exactement =)

Apres y a aussi les détecteurs de vibration... liens

Au début, j'ai pensé à faire un capteur d'accélération avec un pendule et utiliser un joystick tête en bas pour avoir la mesure sur le plan XY.

Si ça fonctionne, je trouve l'accéléromètre électronique plus facile à mettre en pratique

Pour ta solution, j'ai pas vraiment compris comment ça fonctionne.

 

 

 

Pour ta solution, j'ai pas vraiment compris comment ça fonctionne.

 

le code que j'ai proposé?

@Mike, je répondais à Melmet

Sisi, je pense avoir compris Voilà le code que j'en ai fait. Je l'ai placé dans une méthode qui peut être appelée en boucle.

Je testerai sur le robot directement.

#ifndef BNOSensor_h
#define BNOSensor_h

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>

#define SENSITIVITY 2.0
#define DEVIBRATE 5
#define BNO055_SAMPLERATE_DELAY_MS 10

Adafruit_BNO055 bno = Adafruit_BNO055();

class BNOSensor {
  public:
    BNOSensor();
    void init();
    boolean detectImpact();
  private:
    double oldAccelX;
    double oldAccelY;
    int vibration;
    unsigned long lastSampleTime;
};

BNOSensor::BNOSensor() {

}

void BNOSensor::init() {
  if (!bno.begin()) {
    /* There was a problem detecting the BNO055 ... check your connections */
    Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!");
    while (1);
  }
  bno.setExtCrystalUse(true);
  lastSampleTime = millis();
}

boolean BNOSensor::detectImpact() {
  
  if(millis() - lastSampleTime < BNO055_SAMPLERATE_DELAY_MS) return false;
  lastSampleTime = millis();
  vibration--;                                                // loop counter prevents false triggering cause by impact vibration
  if(vibration<0) vibration=0;                                // as robot vibrates due to impact
  
  if(vibration>0) return false;                                     // until vibration has subsided no further calculations required

  // Possible vector values can be:
  // - VECTOR_ACCELEROMETER - m/s^2
  // - VECTOR_LINEARACCEL   - m/s^2
  // - VECTOR_GRAVITY       - m/s^2
  imu::Vector<3> vector = bno.getVector(Adafruit_BNO055::VECTOR_LINEARACCEL);
  double accelX = vector.x();
  double accelY = vector.y();
  
  double magnitude = sqrt( sq(accelX - oldAccelX) + sq(accelY - oldAccelY) );
  
  oldAccelX = accelX;                                              // store previous accelerometer readings for comparison
  oldAccelY = accelY;

  if (magnitude > SENSITIVITY) {           // has a new impact occured
    vibration=DEVIBRATE;                                      // reset anti-vibration counter
    return true;
  }

  return false;
}

#endif

Super ! Hâte de voir si ça répond à ton besoin

Apres y a aussi les détecteurs de vibration... liens

Ce détecteur est moins pratique qu'un accéléromètre. Il ne s'agit que d'une boite contenant une bille métallique en contact avec une (ou deux peut-être) des quatre broches. Selon la position de la bille, telle ou telle broche est conductrice ou pas. Le nombre de possibilités est beaucoup plus restreint qu'avec un accélérateur. Donc on peut régler beaucoup moins finement la sensibilité. D'autre détecteurs sont encore plus simples en étant juste un tube contenant une bille encore qui ne donnera que deux valeurs, selon le côté où elle se trouve. Maintenant que les prix des accéléromètres ont beaucoup baissé et coûtent pratiquement le même prix que ces boites rudimentaires, il serait dommage de s'en priver.