Ich habe keinen gefunden. SD hätte genug Speicher, die Geschwindigkeit müsste man austesten, aber nicht mit Billigkarten.
Evtl. ist das Vorhaben für Amateurtechnik auch zu hoch in den Anforderungen.
Es gibt (gab zumindest anfang der 90er) mal spezielle PC-Steckkarten, die die AD-Signale schnell genug aufnehmen können. Auf Platte Speichern ist dann nicht das Problem.
Gruß Tommy
Das bringt mich auf eine neue Idee: Ein externes Gerät mit dem man normalerweise Audio-Signale aufzeichnet. Die haben ja mindestens 44,1 kHz Abtastrate bei 24 Bit.
In Semi-professioneller Ausführung müsste es so etwas auch für mehrere Kanäle geben.
Im Datenblatt
steht
Bandbreite 11 kHz (3 dB) das bedeutet bei 11 kHz nimmt die ausgegebene Signalamplitude um 3 dB ab.
Du misst an zwei verschiedenen Punkten. Ich habe keine Ahnung wie die Maschine aussieht. Aber vermutlich lässt sich da eine Art "Klotz" an dem dann drei Stück
einachsige ADXL1002-Sensoren in X-, Y- und Z-Richtung montiert sind schon an deiner Maschine anbringen.
Mechanisch so fest angebracht, dass der Klotz die Schwingungen der Maschine 1 zu 1 mitmacht und keine Relativebewegungen gegenüber der Maschine ausführt.
Zum Beispiel mit 4 Stück M8er Schrauben festgeschraubt oder auch angeschweißt.
Eine Alternative wäre dieser USB-AD-Meßwert-Adapter
6 Kanäle 16 bit 225 kHz-Abtastrate.
16 bit bei 5V sind bei maximaler Amplitude von 3,3V 3,3/5*16 = 10 bit.
Der wäre schnell genug. Tja und Leistung hat nun mal seinen Preis 891 Flocken.
(Die 749 sind der nettopreis excl. MwSt)
Das ist das erst beste Fundstück was ich gefunden habe.
Gibt es wahrscheinlich auch preiswerter.
So jetzt habe ich dir so einiges an Basisarbeit abgenommen.
Jetzt wäre es an der Zeit, dass du dich mal in die Messtechnik wenigstens so weit rein kniehst mal die minimal erforderliche Messwerterfassungsrate in Messwerte pro Sekunde festzulegen und wenn die Zahl steht kann man ein geeignetes Messgerät entweder fertig kaufen oder geeignete Komponenten aussuchen.
So viel kann man bei einer Bachelorarbeit mindestens erwarten.
Was willste denn nach dem Maschinenbaustudium machen?
Wenn die Tätigkeit eines Ingenieurs wirklich würdig ist, dann haste in der täglichen Arbeit auch solche Auslegungen zu machen. Spezifikationen festlegen, von allen möglichen Komponenten die Datenblätter studieren um dann auf der Basis wirklich zu wissen welche Komponenten geeignet sind Entscheidungen zu treffen.
Frequenzen bis 1600Hz für X, Y und 500Hz für Z sind ausreichend. Ich kann auch nur die niedrigen Frequenzen betrachten und sehen welche Auswirkungen die Parameter darauf haben. Die hohen Frequenzen werden vermutlich eher kleinere Amplituden haben, deswegen sind die sowieso eher uninteressant und da ich mit nur 30-40 U/min bohre, sollten die „niedrigen“ Frequenzen dominanter sein.
Mein Problem ist ja momentan eigentlich nur, dass ich die Daten offensichtlich nicht schnell genug übertragen bekomme. Wenn ich mit 3200Hz abtaste und einen TP Filter integriere, der alles oberhalb 1600Hz nicht durchlässt, könnte ich auch aliasing verhindern. Ich muss also nur sehen dass ich die Daten mit mindestens 3200Hz übertragen bekomme, sonst bringt mir ja das schnelle abtasten nichts.
An der Baurate liegt es nicht, die habe ich hoch und runter geschraubt. Komme nicht unter 2ms.
An CoolTerm liegt es auch nicht, habe direkt über ein Python Skript die Daten aufgezeichnet, auch 2ms.
Irgendwo ist also ein Flaschenhals. Sollte das der Mikrocontroller sein, dann sollte doch ein Teensy 4.1 helfen das Problem zu beheben, bevor ich mir für 20-30€ pro Stück neue Sensoren zulege.
Die Z-Achse wird dann meinetwegen mit 1000Hz abgetastet und ein TP bis 500Hz programmiert. Dann habe ich X,Y bis 1600Hz und Z bis 500Hz.
Solange die gemessenen Werte korrekt sind, ist das gut. Ob die bis 500/1600Hz oder bis 20.000Hz gehen ist dann nicht mehr so relevant.
Aber Frequenzen bis 250Hz für alle drei Achsen wäre schon eher Mau …
Messfrequenz, Genauigkeit und Auflösung sind nicht vorgegeben.
Das kann ich von der Sensorik abhängig machen, die ich habe.
3 Achsen pro Sensor mit 500 und 1600Hz ist i.O.
Also abtasten mit 1000 und 3200Hz und einen TP um nur bis zu den Grenzfrequenzen der Sensoren durchzulassen und Aliasing zu verhindern.
Ich habe natürlich den Anspruch an mich selbst, aussagekräftige Daten zu erfassen. Ich möchte nicht bewusst alles falsch/schlecht machen um am Ende zu sagen wo überall Verbesserungen gemacht werden müssten nur damit ich schnellst möglich fertig bin.
Ich habe bewusst noch nicht angemeldet. Das mache ich erst wenn ich die Daten erfasst habe. Dann habe ich noch maximal 6 Wochen Zeit um alles auszuwerten und zu schreiben.
Ich habe noch den ADXL356 Beschleunigungssensor herausgesucht. Der hat laut Datasheet eine Bandbreite von 2.4kHz und misst ebenfalls 3 Achsen. Da bin ich zwar bei 50€ für einen Sensor, würde dann aber evtl. auf den zweiten verzichten. Dann messe ich eben nur an einer Stelle.
Hier ist das Datasheet:
Den vllt in Kombi mit dem Teensy 4.1?
Wenn ich dann was vernünftiges habe um bis 2.4kHz zu messen, könnte ich das später für meine Masterarbeit verwenden. Da werde ich vermutlich wieder eine Werkzeugmaschine auf Schwingungen untersuchen.
Kommt auf den wert der Resonanzfrequenz an. Wenn das Teil mit der anfängt zu schwingen ist die Amplitude schon ziemlich kräftig.
Grüße Uwe
Der Teensy 4.1 kann die Daten mit 6 MBaud raushauen.
Die AD-Wandler des Teensy 4.1 können unterschiedlich konfiguriert werden.
Man kann da einstellen wie oft der AD-Wandler sampeln soll.
In einem Beitrag im Teensy-Forum habe ich da was von 32 samples gelesen.
Ich habe mit einem Mini-Progrämmchen getestet das keine Veränderungen an diesen Einstellmöglichkeiten der AD-Wandler vornimmt.
Da du ja eine sich schnell verändernde Spannung messen willst kann man durch heruntersetzen der Sample-Zahl die Einlesegeschwindigkeit des AD-Wandlers vermutlich noch steigern.
Schätze ich das richtig ein, dass deine Bachelorarbeit sich schwerpunktmäßig mit Umbau der Werkzeugmaschine beschäftig? Oder geht es schwerpunktmäßig um Vibrationsmessungen?
Sollst du eine Vibrationsmess-Einrichtung entwickeln oder Vibrationen messen?
Wenn Vibrationen messen müsste doch OK sein, wenn fertig verwendbare Vibrationsmesstechnik verwendet wird.
Hast du denn mal mit deinem Prof gesprochen ob sein Institut den 900 Euro 6-Kanal 225 kHz AD-Wandler kaufen würde? Der lässt sich ja vielseitig verwenden.
Oder andere Idee: Gibt es an deiner Uni auch ein Institut, dass sowieso viel mit Messtechnik macht? Vielleicht kann man bei denen so etwas ähnliches ausleihen?
Oder vielleicht gibt es auch ein hochwertiges Speicher-Oszilloskop mit USB-Schnittstelle über das man die Messwerte ausgeben kann.
Bei einem USB-Oszilloskop halte ich das für sehr wahrscheinlich.
USB-Oszilloskop bedeutet es ist ein Oszilloskop ohne eigenen Bildschirm.
Die Messwerte werden über die USB-Schnittstelle an einen PC übertragen und dann durch eine PC-Software auf dem PC-Bildschirm dargestellt.
Und wenn man schon mal Messwerte in den PC einliest, dann kann man das auch gleich Gigabyte-Weise machen.
Wenn dein Prof das Werkzeugmaschinen-Institut leitet will er wahrscheinlich keine
2300 bis 17.000 Euro für ein 6-Kanal Speicher-Oszi ausgeben. Aber am Elektronik-Institut ist so was vielleicht vorhanden.
8-Kanal USB
6-Kanal mit Bildschirm
Das Werkzeug-Maschineninstitut müsste doch ganz allgemein an Vibrationsmessung interessiert sein und hat vielleicht Profi-Sensoren so wie diesen hier
Bandbreite 4500 Hz IEPE-Schnittstelle
Die BA läuft über ein kleines Unternehmen, die haben nicht wirklich Interesse Geld dafür auszugeben, auch wenn ich es ziemlich cool und hilfreich für die Zukunft finde.
Alle Teile die ich brauche kaufe ich selber. Wenn ich insgesamt bis 200€ ausgebe dann passt das schon.
Die Messtechnik aus der Uni hatte ich auch dran gedacht, allerdings gehört die Zusammenstellung und Codierung teilweise dazu, deswegen soll ich die Messtechnik selber zusammenstellen und programmieren.
Das eigentliche Hauptthema ist die Untersuchung der Auswirkungen unterschiedlicher Parameter auf die auftretenden Schwingungen an meiner Vorrichtung.
Was heißt denn in diesem Fall "teilweise" ?
Entweder es gehört dazu oder nicht. Wie kann man das denn "teilweise" dazu haben wollen.
Programmzeile 1 bis 50 oder wie?
Gehört tatsächlich dazu, kann mir vorstellen dass mein Prof darauf verzichten könnte, aber das gibt sicherlich Abzüge in der b Note. Ausserdem würde ich die Messeinrichtung gerne später bei der Masterarbeit wieder verwenden und bei der Arbeit nutzen für die Entwicklung von unseren eigenen Maschinen, dann wird man nicht direkt teure Messtechnik kaufen, das ist zu teuer und eigentlich auch nicht wirklich notwendig. Da kann ich nicht tiefer ins Detail gehen, das wäre jetzt hier zu viel unnötige Info.
In Messtechnik haben wir damals mit DasyLab gearbeitet und teure Piezo Sensoren, Thermoelemente etc verwendet um unterschiedlichste Sachen zu messen. Würde es gerne einfacher und kompakter haben, deswegen der Ansatz über den Mikrocontroller.
In erster Linie will ich gute Vergleichswerte haben, zB Vorrichtung a vs Vorrichtung b, die gemessenen Schwingungen müssen nicht Haar genau der Realität entsprechen, man soll sie aber miteinander vergleichen können. Kleine Fehler, die in beiden Messungen gleich vorkommen sind also akzeptabel, solange man erkennt welche der Vorrichtungen die "bessere" ist, bezogen auf auftretende Schwingungen.
Ja also dann einen Teensy 4.0
Oder wenn du die Messdaten auf einer SD-Karte speichern willst ein Teensy 4.1
Der Teensy 4.1 kann * 1x SDIO (4 Bit) nativ SD
Ich habe schon mal Daten auf SD gespeichert aber nicht gemessen wie schnell das geht.
Aber native SD müsste schnell genug sein.
Jetzt kenne ich ja die näheren Umstände nicht und du musst sie auch nicht erzählen
aber wenn ich der Chef wäre und Vibrationen genau zu kennen wäre wichtig dann wäre mir das schon ein paar tausend Euro wert. Aber das muss der Chef selber wissen.
Teensy 4.0 30 Euro Teensy 4.1 mit SD-Karten-Slot gleich mit drauf 42 Euro ist ja nicht die Welt.
Teile sind jetzt alle angekommen und die Schaltung steht.
Teensy4.1 und ein LSM6DSOX Sensor. Der Sensor kann mit maximal 6.66 kHz abtasten und misst X,Y,Z + drei Rotationsachsen über ein Gyroskop + Temperatur, mehr als ursprünglich erwartet, aber das gibt glaube ich später gute und wichtige zusätzliche Erkenntnisse und extra Punkte in der Bewertung.
Hab ihn jetzt erstmal auf die zweit höchste Stufe (3.33 kHz) eingestellt.
Ich habe im Code versucht einen Zeitstempel zu integrieren und habe die Werte in Arrays ablegen lassen bevor ich die Daten ausgebe.
Momentan Arrays mit maximal 6660 Plätzen, also bei 3.33 kHz wird 2 Sekunden lang gemessen (dann sind die Arrays voll).
Zeitstempel soll messen wie lange es dauert die Arrays zu füllen. dann ist ja die Ausgabegeschwindigkeit egal.
Mein Zeitstempel zeigt mit 1.997 Sekunden für 6660 Werte. Soweit so gut!
Als nächstes müsste ich das ganz dann mit seiner SD Karte testen. Das wird ja nicht so schnell sein wie die Abspeicherung in den Arrays aber vllt trotzdem schnell genug um auf 2 Sekunden zu kommen. Dann könnte ich danach eine 5 minütige Messung ausprobieren.
Übertragung läuft über SPI.
Hier der Code:
#include <Adafruit_LSM6DSOX.h>
#define LSM_CS 10
#define LSM_SCK 13
#define LSM_MISO 12
#define LSM_MOSI 11
// Maximale Anzahl an Messwerten als Konstante definieren
const int maxMeasurements = 6660;
Adafruit_LSM6DSOX sox;
unsigned long startMicros;
unsigned long currentMicros;
bool measurementActive = false; // Flag für Messungsstatus
String input = ""; // Variable für die Eingabe
int measurementIndex = 0; // Zähler für die Messungen
// Arrays mit fester Größe, die nun während der Kompilierung bekannt sind
float accelX[maxMeasurements];
float accelY[maxMeasurements];
float accelZ[maxMeasurements];
float tempValues[maxMeasurements];
// Zeitstempel für die Gesamtdauer der Messung
unsigned long startTime;
unsigned long endTime;
unsigned long elapsedTime; // Variable für die Gesamtdauer in Mikrosekunden
void setup() {
Serial.begin(115200);
while (!Serial) delay(10);
Serial.println("Adafruit LSM6DSOX test!");
// SPI Initialisierung des Sensors
if (!sox.begin_SPI(LSM_CS, LSM_SCK, LSM_MISO, LSM_MOSI)) {
Serial.println("Failed to find LSM6DSOX chip!");
while (1) {
delay(10);
}
}
Serial.println("LSM6DSOX Found!");
// Beschleunigungsbereich setzen
sox.setAccelDataRate(LSM6DS_RATE_3_33K_HZ);
Serial.println("Accelerometer data rate set to: 3.33 KHz");
Serial.println("\nGeben Sie 'start' ein und drücken Sie Enter, um die Messung zu starten.");
}
void loop() {
if (!measurementActive) {
if (Serial.available()) {
char receivedChar = Serial.read(); // Einzelnen Buchstaben einlesen
if (receivedChar == '\n') { // Wenn Enter gedrückt wurde
input.trim(); // Eingabe trimmen (Leerzeichen und Steuerzeichen entfernen)
// Eingabe anzeigen
Serial.print("Eingabe: '");
Serial.print(input);
Serial.println("'");
// Vergleiche die Eingabe mit "start"
if (input.equals("start")) {
measurementActive = true;
measurementIndex = 0; // Reset Index für neue Messung
startTime = micros(); // Startzeit speichern
Serial.println("Messung gestartet...");
} else {
Serial.println("Ungültige Eingabe. Geben Sie 'start' ein und drücken Sie Enter.");
}
input = ""; // Eingabe zurücksetzen
} else {
input += receivedChar; // Eingabe dynamisch anzeigen
Serial.print(receivedChar); // Zeigt den eingegebenen Buchstaben an
}
}
return; // Kehrt zur Eingabeprüfung zurück
}
// Messung stoppen, wenn 6660 Messwerte erreicht sind
if (measurementIndex < maxMeasurements) {
// Messung läuft noch, Daten sammeln und im Array speichern
sensors_event_t accel;
sensors_event_t gyro;
sensors_event_t temp;
sox.getEvent(&accel, &gyro, &temp);
// Daten im Array speichern
accelX[measurementIndex] = accel.acceleration.x;
accelY[measurementIndex] = accel.acceleration.y;
accelZ[measurementIndex] = accel.acceleration.z;
tempValues[measurementIndex] = temp.temperature;
measurementIndex++; // Index für die nächste Messung erhöhen
// Sicherstellen, dass 1 Messwert alle 300 Mikrosekunden erfolgt (3,33 kHz)
while (micros() - currentMicros < 300) {
// Warten, bis 300 Mikrosekunden vergangen sind
}
currentMicros = micros(); // Aktuellen Zeitpunkt aktualisieren
} else {
// Messung beenden, wenn 6660 Messwerte erreicht sind
if (measurementActive) {
endTime = micros(); // Endzeit nach der Datensammlung speichern
elapsedTime = endTime - startTime; // Gesamtdauer der Messung berechnen
Serial.println("Messung beendet. 6660 Messwerte erreicht.");
Serial.print("Gesamtdauer der Datensammlung: ");
Serial.print(elapsedTime);
Serial.println(" Mikrosekunden");
measurementActive = false;
// Alle Messwerte auf einmal ausgeben
Serial.println("Messwerte:");
for (int i = 0; i < maxMeasurements; i++) {
Serial.print(i); // Laufende Nummer der Messung
Serial.print(",");
Serial.print(tempValues[i]); // Temperatur
Serial.print(",");
Serial.print(accelX[i]); // Accel X
Serial.print(",");
Serial.print(accelY[i]); // Accel Y
Serial.print(",");
Serial.print(accelZ[i]); // Accel Z
Serial.println();
}
Serial.print("Gesamtdauer der Datensammlung: ");
Serial.print(elapsedTime);
Serial.println(" Mikrosekunden");
Serial.println("Geben Sie 'start' ein und drücken Sie Enter, um die Messung erneut zu starten.");
}
}
}
Schaut doch bitte mal drüber und vor allem über den Zeitstempel, nicht dass der mir da was total falsches ausgibt und die 1.997s totaler Zufall sind.
Du willst ja die Messzeit erfassen also den Zeitstempel wirklich erst unmittelbar vor der ersten Messung speichern
if (input.equals("start")) {
measurementActive = true;
measurementIndex = 0; // Reset Index für neue Messung
Serial.println("Messung gestartet...");
// als letztes den Zeitstempel
startTime = micros(); // Startzeit speichern
} else {
oder noch besser hier
// solange noch nicht maxmaxMeasurements erreicht ist
if (measurementIndex < maxMeasurements) {
// wenn Index 0 ist dann
if (measurementIndex == 0) {
startTime = micros(); // Startzeit speichern
}
// Messung läuft noch, Daten sammeln und im Array speichern
sensors_event_t accel;
sensors_event_t gyro;
sensors_event_t temp;
sox.getEvent(&accel, &gyro, &temp);
Der Teensy 4.1 hat ja einen Micro-SD-Slot auf der Platine. Und wenn ich das richtig verstanden habe dann benutzt der SDIO (4 bit data) das dürfte die schnelle Datenübertragung sein.
passend googeln
https://www.google.com/search?as_q=teensy+4.1+maximum+writespeed+with+SDIO
Hier gibt es infos dazu
Die benutzen eine bestimmte libary
Und hier ein Beginner-Tutorial
Die Zeitmessung ist aktuell total random nachdem ich versucht habe ein double buffering einzubauen. Bin jetzt nochmal paar Schritte zurück mit dem Code ...
Folgendes habe ich noch gelesen im Datasheet des Sensors:
Der Sensor verfügt über mehrere Modi, darunter High Performance. High Performance sollte man aktivieren im mit höheren Datenraten zu arbeiten. In meinem Fall, bei 3.33kHz oder vllt sogar 6.66kHz, sollte das auf jeden Fall gemacht werden.
In der Bibliothek die ich verwende ( " Adafruit_LSM6DSOX.h " ) sehe ich leider keine Funktion, das direkt einzustellen.
Laut Datasheet geht das wiefolgt:
The operating mode selected depends on the value of the XL_HM_MODE bit in CTRL6_C (15h). If XL_HM_MODE is set to 0, high-performance mode is valid for all ODRs (from 12.5 Hz up to 6.66 kHz).
Link zum Datasheet: https://www.st.com/resource/en/datasheet/lsm6dsox.pdf
Ich glaube das sind die wichtigsten Tabellen dafür:
Auf meinem Rechner habe ich das gefunden:
Dann müsste ich mit dieser Bibliothek irgendwie über CTRL1_XL 0x10 die Bits anpassen um den Sensor in den High Performance Modus zu versetzen oder?
Allerdings steht oben etwas von I2C Driver for the Adafruit LSM6DSOX ...
Ich kommuniziere aber über SPI.
Macht das einen unterschied und wie ändere ich jetzt die Bits entsprechend der Tabelle um den gewünschten Modus zu aktivieren ?
Ich würde dann erstmal versuchen den High Performance Modus zu aktivieren, und dann einen Tiefpassfilter aktivieren um alle Signale unterhalb der Nyqvist Frequenz zu blockieren. Dann könnte ich zB bis 1600Hz noch gute Signale erhalten und auswerten (mit ODR auf 3.33kHz).
Das würde mir reichen.
Danach werde ich mich dann der Speicherung auf der SD Karte widmen. Das habe ich schon geschafft aber glaube dass ich da ein double buffering anwenden muss damit das schnell genug geht.
Gruss Marko
// Basic demo for accelerometer & gyro readings from Adafruit
// LSM6DSOX sensor
#include <Adafruit_LSM6DSOX.h>
// For SPI mode, we need a CS pin
#define LSM_CS 10
// For software-SPI mode we need SCK/MOSI/MISO pins
#define LSM_SCK 13
#define LSM_MISO 12
#define LSM_MOSI 11
Adafruit_LSM6DSOX sox;
// Index für die Messreihe
unsigned long lfdNr = 1;
void setup(void) {
Serial.begin(115200);
while (!Serial)
delay(10); // will pause Zero, Leonardo, etc until serial console opens
Serial.println("Adafruit LSM6DSOX test!");
// if (!sox.begin_I2C()) {
// if (!sox.begin_SPI(LSM_CS)) {
if (!sox.begin_SPI(LSM_CS, LSM_SCK, LSM_MISO, LSM_MOSI)) {
Serial.println("Failed to find LSM6DSOX chip");
while (1) {
delay(10);
}
}
Serial.println("LSM6DSOX Found!");
sox.setAccelRange(LSM6DS_ACCEL_RANGE_4_G);
Serial.print("Accelerometer range set to: ");
switch (sox.getAccelRange()) {
case LSM6DS_ACCEL_RANGE_2_G:
Serial.println("+-2G");
break;
case LSM6DS_ACCEL_RANGE_4_G:
Serial.println("+-4G");
break;
case LSM6DS_ACCEL_RANGE_8_G:
Serial.println("+-8G");
break;
case LSM6DS_ACCEL_RANGE_16_G:
Serial.println("+-16G");
break;
}
sox.setGyroRange(LSM6DS_GYRO_RANGE_2000_DPS );
Serial.print("Gyro range set to: ");
switch (sox.getGyroRange()) {
case LSM6DS_GYRO_RANGE_125_DPS:
Serial.println("125 degrees/s");
break;
case LSM6DS_GYRO_RANGE_250_DPS:
Serial.println("250 degrees/s");
break;
case LSM6DS_GYRO_RANGE_500_DPS:
Serial.println("500 degrees/s");
break;
case LSM6DS_GYRO_RANGE_1000_DPS:
Serial.println("1000 degrees/s");
break;
case LSM6DS_GYRO_RANGE_2000_DPS:
Serial.println("2000 degrees/s");
break;
case ISM330DHCX_GYRO_RANGE_4000_DPS:
break; // unsupported range for the DSOX
}
sox.setAccelDataRate(LSM6DS_RATE_3_33K_HZ);
Serial.print("Accelerometer data rate set to: ");
switch (sox.getAccelDataRate()) {
case LSM6DS_RATE_SHUTDOWN:
Serial.println("0 Hz");
break;
case LSM6DS_RATE_12_5_HZ:
Serial.println("12.5 Hz");
break;
case LSM6DS_RATE_26_HZ:
Serial.println("26 Hz");
break;
case LSM6DS_RATE_52_HZ:
Serial.println("52 Hz");
break;
case LSM6DS_RATE_104_HZ:
Serial.println("104 Hz");
break;
case LSM6DS_RATE_208_HZ:
Serial.println("208 Hz");
break;
case LSM6DS_RATE_416_HZ:
Serial.println("416 Hz");
break;
case LSM6DS_RATE_833_HZ:
Serial.println("833 Hz");
break;
case LSM6DS_RATE_1_66K_HZ:
Serial.println("1.66 KHz");
break;
case LSM6DS_RATE_3_33K_HZ:
Serial.println("3.33 KHz");
break;
case LSM6DS_RATE_6_66K_HZ:
Serial.println("6.66 KHz");
break;
}
sox.setGyroDataRate(LSM6DS_RATE_3_33K_HZ);
Serial.print("Gyro data rate set to: ");
switch (sox.getGyroDataRate()) {
case LSM6DS_RATE_SHUTDOWN:
Serial.println("0 Hz");
break;
case LSM6DS_RATE_12_5_HZ:
Serial.println("12.5 Hz");
break;
case LSM6DS_RATE_26_HZ:
Serial.println("26 Hz");
break;
case LSM6DS_RATE_52_HZ:
Serial.println("52 Hz");
break;
case LSM6DS_RATE_104_HZ:
Serial.println("104 Hz");
break;
case LSM6DS_RATE_208_HZ:
Serial.println("208 Hz");
break;
case LSM6DS_RATE_416_HZ:
Serial.println("416 Hz");
break;
case LSM6DS_RATE_833_HZ:
Serial.println("833 Hz");
break;
case LSM6DS_RATE_1_66K_HZ:
Serial.println("1.66 KHz");
break;
case LSM6DS_RATE_3_33K_HZ:
Serial.println("3.33 KHz");
break;
case LSM6DS_RATE_6_66K_HZ:
Serial.println("6.66 KHz");
break;
}
}
void loop() {
// /* Get a new normalized sensor event */
sensors_event_t accel;
sensors_event_t gyro;
sensors_event_t temp;
sox.getEvent(&accel, &gyro, &temp);
//Serial.print("\t\tTemperature ");
//Serial.print(temp.temperature);
//Serial.println(" deg C");
/* Display the results (acceleration is measured in m/s^2) */
//Serial.print("\t\tAccel X: ");
//Serial.print(accel.acceleration.x);
//Serial.print(" \tY: ");
//Serial.print(accel.acceleration.y);
//Serial.print(" \tZ: ");
//Serial.print(accel.acceleration.z);
//Serial.println(" m/s^2 ");
/* Display the results (rotation is measured in rad/s) */
//Serial.print("\t\tGyro X: ");
//Serial.print(gyro.gyro.x);
//Serial.print(" \tY: ");
//Serial.print(gyro.gyro.y);
//Serial.print(" \tZ: ");
//Serial.print(gyro.gyro.z);
//Serial.println(" radians/s ");
//Serial.println();
//delayMicroseconds(300);
// serial plotter friendly format
Serial.print(lfdNr);
Serial.print(": ");
Serial.print(temp.temperature);
Serial.print(", ");
Serial.print(accel.acceleration.x);
Serial.print(", ");
Serial.print(accel.acceleration.y);
Serial.print(", ");
Serial.print(accel.acceleration.z);
Serial.print(", ");
Serial.print(gyro.gyro.x);
Serial.print(", ");
Serial.print(gyro.gyro.y);
Serial.print(", ");
Serial.print(gyro.gyro.z);
Serial.println();
// Erhöhe den Index für die nächste Messreihe
lfdNr++;
delayMicroseconds(300);
}
sehe gerade in der zweiten Tabelle (9.20), dass XL_HM_MODE ein default 0 hat. Also ist der High Performance Mode bereits aktiv. Das vereinfacht das ganze!
Update:
Output-Data-Rate (ODR) vom Sensor auf 6664 Hz, Daten werden mit 2 Buffern abwechselnd auf die SD Karte geschrieben.
Abtasten erfolgt durch den Code mit einem Delay von 127 micros (150 micros [6664 Hz] - 23 micros [get.event-Dauer]).
Ein Buffer nimmt 6664 Werte auf, Zeitstempel gibt ca. 1 Sekunde fürs Füllen eines Buffers aus. Das sieht also gut aus!
Messung stoppt wenn eine bestimmte Anzahl an daten gesammelt wurde. Hier 66640 Werte, also 10s Messung.
Der Plot deutet darauf hin, dass ein TP-Filter bei ODR/2 (3332 Hz) aktiv ist.
Plot:
Hier der aktuelle Code:
#include <Adafruit_LSM6DSOX.h>
#include <SD.h> // SD Speicherung
// For SPI mode, we need a CS pin
#define LSM_CS 10
#define LSM_SCK 13
#define LSM_MISO 12
#define LSM_MOSI 11
const size_t BUFFER_SIZE = 6664; // Anzahl Messreihen pro Buffer
const size_t TOTAL_MEASUREMENTS = 66640; // Gesamtanzahl Messreihen
Adafruit_LSM6DSOX sox;
// Zwei Puffer für Double Buffering
float buffer1[BUFFER_SIZE][7]; // 7 Werte: Temp, Accel X/Y/Z, Gyro X/Y/Z
float buffer2[BUFFER_SIZE][7];
bool useBuffer1 = true; // Aktiver Puffer
size_t bufferIndex = 0; // Aktueller Index im aktiven Puffer
size_t totalMeasurements = 0;
bool measurementActive = false; // Messung aktiv?
String input = ""; // Eingabe speichern
unsigned long startTime = 0; // Startzeit speichern
unsigned long fillStartTime = 0; // Zeitstempel vor dem Füllen des Buffers
unsigned long fillEndTime = 0; // Zeitstempel nach dem Füllen des Buffers
unsigned long fillDuration = 0; // Dauer in Mikrosekunden, um den Buffer zu füllen
unsigned long totalStartTime = 0; // Gesamtstartzeit der Messung
unsigned long totalEndTime = 0; // Gesamtendzeit der Messung
unsigned long totalDuration = 0; // Gesamtzeit der Messung
size_t measurementIndex = 0; // Messindex
File dataFile; // Dateiobjekt für SD-Karte
String filename = "Messdaten.csv"; // SD Speicherdatei, initialer Standardname
void requestFilename() {
Serial.println("Bitte Dateinamen eingeben und mit ENTER bestaetigen:");
while (true) {
if (Serial.available()) {
char receivedChar = Serial.read();
if (receivedChar == '\n') { // Wenn Enter gedrückt wurde
input.trim(); // Eingabe trimmen (Leerzeichen und Steuerzeichen entfernen)
// Falls keine Endung angegeben, ".csv" anhängen
if (!input.endsWith(".csv")) {
input += ".csv";
}
// Eingabe anzeigen
Serial.print("Dateiname: '");
Serial.print(input);
Serial.println("'");
filename = input; // Dateiname setzen
input = ""; // Eingabe zurücksetzen
break; // Schleife beenden
} else {
input += receivedChar; // Eingabe dynamisch anzeigen
Serial.print(receivedChar); // Zeigt den eingegebenen Buchstaben an
}
}
}
}
void waitForStartCommand() {
Serial.println("Bitte 'start' eingeben und mit 'ENTER' bestaetigen um Messung zu starten!");
while (!measurementActive) {
if (Serial.available()) {
char receivedChar = Serial.read(); // Einzelnen Buchstaben einlesen
if (receivedChar == '\n') { // Wenn Enter gedrückt wurde
input.trim(); // Eingabe trimmen (Leerzeichen und Steuerzeichen entfernen)
// Eingabe anzeigen
Serial.print("Eingabe: '");
Serial.print(input);
Serial.println("'");
// Vergleiche die Eingabe mit "start"
if (input.equals("start")) {
measurementActive = true;
measurementIndex = 0; // Reset Index für neue Messung
startTime = micros(); // Startzeit speichern
totalStartTime = micros(); // Gesamtstartzeit speichern
Serial.println("Messung gestartet...");
} else {
Serial.println("Ungueltige Eingabe. Geben Sie 'start' ein und druecken Sie Enter.");
}
input = ""; // Eingabe zurücksetzen
} else {
input += receivedChar; // Eingabe dynamisch anzeigen
Serial.print(receivedChar); // Zeigt den eingegebenen Buchstaben an
}
}
}
}
void setup() {
Serial.begin(115200);
while (!Serial) delay(10);
Serial.println("Adafruit LSM6DSOX test!");
Serial.println("SD-Karten-Test");
// Sensor initialisieren
if (!sox.begin_SPI(LSM_CS, LSM_SCK, LSM_MISO, LSM_MOSI)) {
Serial.println("Failed to find LSM6DSOX chip");
while (1) delay(10);
}
Serial.println("LSM6DSOX Found!");
// SD-Karte initialisieren
if (!SD.begin(BUILTIN_SDCARD)) {
Serial.println("SD-Karte nicht erkannt!");
while (1);
}
Serial.println("SD-Karte erfolgreich erkannt!");
// Benutzer auffordern, einen Dateinamen einzugeben
requestFilename();
// Datei öffnen oder erstellen
dataFile = SD.open(filename.c_str(), FILE_WRITE);
if (!dataFile) {
Serial.println("Fehler beim Oeffnen der Datei!");
while (1);
}
// Spaltenüberschriften in die Datei schreiben
dataFile.println("Temp,Accel_X,Accel_Y,Accel_Z,Gyro_X,Gyro_Y,Gyro_Z");
dataFile.flush();
// Sensoreinstellungen
sox.setAccelRange(LSM6DS_ACCEL_RANGE_4_G);
sox.setGyroRange(LSM6DS_GYRO_RANGE_2000_DPS);
sox.setAccelDataRate(LSM6DS_RATE_6_66K_HZ);
sox.setGyroDataRate(LSM6DS_RATE_6_66K_HZ);
// Warten, bis der Benutzer "start" eingibt
waitForStartCommand();
Serial.println("Messung beginnt...");
}
void loop() {
if (measurementActive) {
sensors_event_t accel, gyro, temp;
// Startzeit vor dem Füllen des Buffers
if (bufferIndex == 0) {
fillStartTime = micros();
}
sox.getEvent(&accel, &gyro, &temp);
// Daten in den aktiven Puffer schreiben
float (*currentBuffer)[7] = useBuffer1 ? buffer1 : buffer2;
currentBuffer[bufferIndex][0] = temp.temperature;
currentBuffer[bufferIndex][1] = accel.acceleration.x;
currentBuffer[bufferIndex][2] = accel.acceleration.y;
currentBuffer[bufferIndex][3] = accel.acceleration.z;
currentBuffer[bufferIndex][4] = gyro.gyro.x;
currentBuffer[bufferIndex][5] = gyro.gyro.y;
currentBuffer[bufferIndex][6] = gyro.gyro.z;
bufferIndex++;
totalMeasurements++;
// Buffer voll? In SD-Karte schreiben und Puffer wechseln
if (bufferIndex >= BUFFER_SIZE || totalMeasurements >= TOTAL_MEASUREMENTS) {
// Zeitstempel nach dem Füllen des Buffers
fillEndTime = micros();
fillDuration = fillEndTime - fillStartTime; // Berechnung der Zeit, um den Buffer zu füllen
// Ausgabe der Zeit im seriellen Monitor
Serial.print("Zeit zum Fuellen des Buffers (in Mikrosekunden): ");
Serial.println(fillDuration);
float (*writeBuffer)[7] = useBuffer1 ? buffer1 : buffer2;
useBuffer1 = !useBuffer1; // Puffer wechseln
bufferIndex = 0;
Serial.println("Messung aktiv ...");
for (size_t i = 0; i < BUFFER_SIZE && totalMeasurements <= TOTAL_MEASUREMENTS; i++) {
dataFile.print(writeBuffer[i][0], 4); dataFile.print(",");
dataFile.print(writeBuffer[i][1], 4); dataFile.print(",");
dataFile.print(writeBuffer[i][2], 4); dataFile.print(",");
dataFile.print(writeBuffer[i][3], 4); dataFile.print(",");
dataFile.print(writeBuffer[i][4], 4); dataFile.print(",");
dataFile.print(writeBuffer[i][5], 4); dataFile.print(",");
dataFile.println(writeBuffer[i][6], 4); // 4 Nachkommastellen für alle Werte
}
dataFile.flush(); // Daten in Datei schreiben
}
// Messung stoppen, wenn alle Messreihen gesammelt
if (totalMeasurements >= TOTAL_MEASUREMENTS) {
totalEndTime = micros(); // Gesamtendzeit speichern
totalDuration = totalEndTime - totalStartTime; // Berechnung der Gesamtzeit
Serial.print("Gesamtzeit der Messung (in Mikrosekunden): ");
Serial.println(totalDuration);
Serial.println("Messung beendet");
dataFile.close(); // Datei schließen
while (1); // Endlosschleife
}
// Verzögerung, um die Abtastrate von 6664 Hz zu erreichen (0.127 ms), 0.15 ms abzüglich get.event delay von 23 Micros
delayMicroseconds(127); // ca. 0.127 Millisekunden
}
}
Ich taste also mit 6664 Hz ab, was auch der Output-Data-Rate meines Sensors entspricht und habe laut Zeitstempel einen Fehler von ca. 2000 micros auf eine Sekunde (0,2 %).
Keine Ahnung ob ich hier noch irgendwo einen Denkfehler habe, aber es scheint im ersten Moment gut zu funktionieren.
Ja cool man !
Jetzt bin ich nebenbei neugierig wie lange das Schreiben der 6664 Werte auf SD-Karte dauert.