Wasserwaage

[Peter(TOO)]

Hallo Jürgen,

Ich möchte statt einer Libelle einer einfachen Wasserwaage eine Gradanzeige und dies für zwei Achsen,
also x- und y-Achse.
Damit soll festgestellt werden ob ein Fahrzeug gerade steht. Also nichts dynamisches.

Ich habe dazu eine App auf dem Handy und der Smartwatch.
Also eine Anzeige in dieser Art?
http://cdn.rftd.de/wp-content/upload...eseAppssi1.png

Besonders die Smartwatch ist recht praktisch, wenn man sie schnell aus dem Gehäuse nimmt. Die Rückseite ist eben:
http://icdn6.digitaltrends.com/image...-1500x1000.jpg

MfG Peter(TOO)

[BMS]

Hallo,
was hier gesucht wird ist ein Beschleunigungssensor bzw. auf Englisch accelerometer.
In Ruhe misst so ein Sensor nämlich die Richtung der Schwerkraft (Gravitation).
Diese Sensroen gibt es üblicherweise ausgeführt mit 3 Achsen schon im Preisbereich 10 Euro.
Als Schnittstelle können z.B. drei analoge Signale oder ein UART, SPI, IIC sein.
Verkauft werden diese z.B. bei watterott, exp-tech, pololuu oder adafruit, die Auswahl ist groß.

Die Beschleunigung muss man dann noch mit trigonometrischen Funktionen umrechnen und erhält dann die Winkel.
Nun die Frage - "wer" rechnet das? Ein Arduino? Wäre wohl am einfachsten, dazu gibt es auch aufsteckbare Displays usw..

Viele Grüße,
Bernhard

[oberallgeier]

.. was hier gesucht wird ist ein Beschleunigungssensor .. mit trigonometrischen Funktionen umrechnen und erhält dann die Winkel .. Nun die Frage - "wer" rechnet das? ..

Vor Jahren wurde so ein Sensor mal im Forum erwähnt (von Andree-HB), dann u.a. getestet von Sternthaler - kplt. mit Code in C. Später hatte ich das auch in Angriff genommen, war aber über das Messrauschen recht betrübt/enttäuscht.

Ob diese Anwendung mit dem Sensor befriedigend gelöst werden kann scheint mir nicht gesichert. Der Gravitationsvektor schwankt ja in Richtung Erd(schwerkraft)mittelpunkt entsprechend dem Cosinus - eine lausige Änderung bei kleinen Winkeln. Das würde eine sehr hohe Auflösung des Sensors fordern, eine entsprechende des ADC und weitergehend natürlich ne entsprechend hohe Auflösung bei der Berechnung. Problem ist aber hier vermutlich/bestimmt, dass gerade bei Werten um Null die Auflösbarkeit trotz langer Mantissen etwas dürftig ist.

Natürlich könnte man auch die tatsächliche Höhe von drei Punkten der Ebene anhand der absoluten Größe des Gravitationsvektors bestimmen - leider auch nicht wirklich ein deutlicher Unterschied.

[Klebwax]

Am schnellsten läßt sich das mit einem Nunchuk einer WII ausprobieren. Da ist unter anderem ein Accelerometer drin. Das kann mit einem 3,3V I2C Bus ausgelesen werden, man muß nur vier Drähte verbinden.

MfG Klebwax

[BMS]

Der Nunchuk Controller liefert scheinbar eine Auflösung von 10 Bit. Je nach Anforderungen könnte das bereits ausreichen.
Ansonsten wären z.B. diese Module hier geeignet:
http://www.exp-tech.de/adafruit-trip...14-bit-mma8451
http://www.exp-tech.de/adafruit-lis3...r-2g-4g-8g-16g
Der erste liegt bei 14 Bit, der zweite bei 16 Bit Auflösung. Um den Wertebereich auszunutzen muss man logischerweise die 2g Skalierung verwenden (Gravitation sind ja 1g). Dann fehlt schon ein Bit, aber mit 13 oder 15 Bit müsste man Zehntel Grad hinbekommen... müsste man mal nachrechnen.
In den verlinkten Modulen sind Analog-Digital-Wandler integriert. Die Werte kann man digital über I2C auslesen.
Falls die Messwerte verrauscht sein sollten, kann man immer noch Mittelwerte bilden. Es werden wohl keine hundert oder tausend Messungen pro Sekunde benötigt, wenn man es von einem Display ablesen möchte... dem entsprechend sind auch die Anforderungen an die Rechengeschwindigkeit niedrig, ein Arduino schafft das

Schönen Abend noch,
Bernhard

[RoboHolIC]

Der Gravitationsvektor schwankt ja

uups, jetzt verstehe ch, warum mir grad so schwindelig ist.

in Richtung Erd(schwerkraft)mittelpunkt entsprechend dem Cosinus - eine lausige Änderung bei kleinen Winkeln.

Wenn man die horizontale Achse nimmt, geht die Winkeländerung mit dem Sinus ein - im Nullpunkt also mit maximaler Empfindlichkeit - und ist für kleine Winkel näherungsweise proportional.[/QUOTE]

[gummi_ente]

Hey,

@BMS, ja so was hatte ich gedacht.

Der Nunchuck würde verm. auch gehen. Aber hat der nicht analoge Ausgänge.

Ehrlich gesagt hatte ich gehofft, sowas schon in annähernd fertig zu bekommen.

Das Problem ist die Messung findet ca. 5-8m entfernt statt.
Zuerst hatte ich angedacht einen kleinen AVR mit der Messung zu betrauen
und dessen Werte dann an einen weiteren AVR mit Anzeige und Umrechnung zu senden.

Da die Module ja I2C haben sollte das aber gehen ohne den ersten Controller.

Gibt es den z.B. für den Arduino LIBs die aus den g-Werten schon Winkel berechnen.
Ist ja für so einen 8-Bitter schon aufwendig solche trigonometrische funktionen zu berechnen.

[i_make_it]

Ich habe das mal schnell mit einem ADXL345 mit +-2g (10 Bit Auflösung) implementiert.
Beim ADXL345 ist die Auflösung nicht besser.
2g - 10Bit
4g - 11Bit
8g - 12Bit
16g - 13Bit

Mit einer Kreditkarte (0,75mm) unter dem Breadboard (85mm) ist die Änderung grade mal 2-3 mal so Groß wie das Sensorrauschen.
Die "----------------" Linien sind nachträglich eingefügt.
Erster Abschnitt, eine Seite 0,75mm erhöht
Zweiter Abschnitt, Beim Rausziehen der Karte
Dritter Abschnitt, Breadboard liegt eben auf dem Tisch
(Ob der Tisch im Wasser steht habe ich nicht geprüft)

h = 0.75mm
Hypotenuse = ca. 85mm

6,3,251
5,3,253
7,3,253
6,3,252
6,2,252
7,3,254
6,3,252
6,4,252
6,3,252
7,3,253
6,3,253
6,4,252
6,4,252
5,4,253
6,5,252
7,4,253
7,4,253
7,4,254
7,4,252
8,3,254
6,4,252
6,4,252
6,3,252
5,5,252
6,3,252
7,4,253
7,3,252
7,3,253
6,5,252
------------------
6,1,254
10,6,252
3,7,250
5,16,243
8,-4,259
4,7,251
13,-3,258
-27,-27,214
3,11,252
4,16,252
5,8,252
4,2,254
5,8,254
5,1,251
5,55,252
6,5,255
2,1,251
1,-1,254
3,3,252
-------------------
4,4,252
5,2,252
4,4,252
4,3,252
3,4,252
4,4,253
4,3,253
4,3,253
3,4,253
3,4,253
3,3,251
4,4,253
5,3,253
4,4,252
4,4,253
3,4,253
4,3,252
5,4,252
3,5,253
4,4,252
3,4,254
3,4,253
3,3,253
4,3,253
2,4,252
4,3,252

Damit wäre eine maximale Auflösung von 3-4mm auf 1 Meter möglich (nahe der Waagerechten).

Und Noch mal der Serial Plott vom Arduino.

Und zum Nachvollziehen:

//Zielplatform Arduino Nano v3
//ADXL345 Modul mit I2C 5V
//I2C SCL ist A5 bei Arduino Nano
//I2C SDA itt A4 bei Arduino Nano
// http://forum.arduino.cc/index.php?topic=100287.0

#include <Wire.h>

byte DEVICE_ADDRESS = 0x53; //This address is fixed for the board we use because pin 12 is fixed to GND

byte POWER_CTRL = 0x2D;    //Power Control Register
// byte BW_RATE = 0x30 // Data Rate Register
byte DATA_FORMAT = 0x31;   //Data Format & Measurement Range Register


byte DATAX0 = 0x32;        //X-Axis Data 0
byte DATAX1 = 0x33;        //X-Axis Data 1
byte DATAY0 = 0x34;        //Y-Axis Data 0
byte DATAY1 = 0x35;        //Y-Axis Data 1
byte DATAZ0 = 0x36;        //Z-Axis Data 0
byte DATAZ1 = 0x37;        //Z-Axis Data 1

byte values[10];
int x,y,z;

unsigned long prev1micros = 0; //Blink LED time
int togglestate = LOW; //Blink LED State

void setup() {
  
pinMode(13, OUTPUT); //Blink LED für Funktionskontrolle

  Wire.begin();    //Initiate the Wire library and join the I2C bus as a master. This is called only once.
  Serial.begin(9600);
//  writeRegister(DEVICE_ADDRESS, BW_RATE, 0x1100); //Put the ADXL345 Output Datarate to 400Hz
  writeRegister(DEVICE_ADDRESS, DATA_FORMAT, 0x00); //Put the ADXL345 into +/- 2G range by writing the value 0x00 to the register.
//  writeRegister(DEVICE_ADDRESS, DATA_FORMAT, 0x01); //Put the ADXL345 into +/- 4G range by writing the value 0x01 to the register.
//  writeRegister(DEVICE_ADDRESS, DATA_FORMAT, 0x10); //Put the ADXL345 into +/- 8G range by writing the value 0x10 to the register.
//  writeRegister(DEVICE_ADDRESS, DATA_FORMAT, 0x11); //Put the ADXL345 into +/- 16G range by writing the value 0x11 to the register.
  writeRegister(DEVICE_ADDRESS, POWER_CTRL, 0x08); //Put the ADXL345 into Measurement Mode by writing the value 0x08 to the register.

/*
  Serial.print("Text - ");  
  readRegister(0x53, 0x32, 4, values);
  Serial.println(values[0]);
  Serial.println(values[1]);
  Serial.println(values[2]);
  Serial.println(values[3]);
*/  
}

void loop() {
  readRegister(DEVICE_ADDRESS, DATAX0, 6, values);

  //The ADXL345 gives 10-bit acceleration values, but they are stored as bytes (8-bits). To get the full value, two bytes must be combined for each axis.
  //The X value is stored in values[0] and values[1].
  x = ((int)values[1]<<8)|(int)values[0];
  //The Y value is stored in values[2] and values[3].
  y = ((int)values[3]<<8)|(int)values[2];
  //The Z value is stored in values[4] and values[5].
  z = ((int)values[5]<<8)|(int)values[4];

  //Below is an optional section, it maps the raw output to a different range.
  //  x = map(x, -150, 150, 0, 255);
  //  y = map(y, -150, 150, 0, 255);
  //  z = map(z, -150, 150, 0, 255);
  //End of optional section.


  Serial.print(x, DEC);
  Serial.print(',');
  Serial.print(y, DEC);
  Serial.print(',');
  Serial.println(z, DEC);
//  Serial.print(',');
//  Serial.println(millis());
 
  //Blink LED für Funktionskkontrolle
  unsigned long cur1micros = millis();
  if (cur1micros - prev1micros >= 200) {
    prev1micros = cur1micros;
    if (togglestate == LOW){
      togglestate = HIGH;
    }else{ 
      togglestate = LOW;
    }
  }  
  digitalWrite(13, togglestate);

}

void writeRegister(byte device, byte registerAddress, byte value) {
  Wire.beginTransmission(device);    //Start transmission to device
  Wire.write(registerAddress);       //Specify the address of the register to be written to
  Wire.write(value);                 //Send the value to be writen to the register
  Wire.endTransmission();            //End transmission
}

void readRegister(byte device, byte registerAddress, int numBytes, byte *values) {

  byte address = 0x80|registerAddress;
  if (numBytes > 1) address = address|0x40;

  Wire.beginTransmission(device);
  Wire.write(address);
  Wire.endTransmission();

  Wire.beginTransmission(device);    
  Wire.requestFrom(device, numBytes);  //Request 6 bytes from device

  int i = 0;
  while (Wire.available()) {          //Device may send less than requested
    values[i] = Wire.read();          //Receive a byte from device and put it into the buffer
    i++;
  }
  Wire.endTransmission();
}

[BMS]

@i_make_it:
Damit lässt sich doch schon einiges anfangen.

Damit wäre eine maximale Auflösung von 3-4mm auf 1 Meter möglich (nahe der Waagerechten).

Das sind etwa 0,23° (Rechnung: Winkel=arctan(4mm/1000mm) ).
Frage an gummi_ente: Welche Genauigkeit und Auflösung sind denn notwendig?

Und noch ein Kommentar zu I2C:
Dieser Bus wurde von den Entwicklern nur für kurze Übertragungsstrecken entworfen,
und war eigentlich für die Übertragung zwischen ICs auf der gleichen Platine gedacht.
Für lange Übertragungsstrecken wird I2C störanfällig, bei 5-8 Metern würde ich es nicht einsetzen.
Dann doch lieber die Übertragung mit zwei Arduinos, z.B. über RS232...
Mit RS232 hat man dann auch die Option, das an einem PC auszulesen (über USB-RS232 Adapter).

Oder wie wäre es kabellos über Bluetooth? Dafür gibt es günstige Module...

Grüße,
Bernhard

[gummi_ente]

i_make_it,
toll. Danke.
Deine Messung ergeben ja eine Genauigkeit von 4mm. 1Grad wären bei 1000mm eine Höhe von 17mm.
Also wäre die Auflösung ja etwa 20-30 zehntel Grad.
Was hat so eine Standardwasserwaage für eine Auflösung wenn die Libelle an den markierten Rand stößt?

Würde man den mit I2C im Fahrzeug ( Motor läuft evtl.) so 5 -8 m überbrücken können?