Hallo zusammen, ich habe aktuell ein Abschlussprojekt am laufen und würde euch gerne mal drüber schauen lassen ob ich nicht irgend etwas vergessen oder nicht beachtet habe.
Hier die Aufgabenstellung:
Ich habe eine Maschine umgebaut bzw. erweitert, sodass man mit der Maschine bohren kann. Gebohrt wird ein 140mm großes Loch in einen Stahlblock.
Nun gilt es, einige Parameter wie Drehzahl und Vorschub anzupassen und zu schauen wie sich die Parameter auf die auftretenden Schwingungen auswirken.
Ich muss also die Schwingungen messen und auswerten.
Ich habe zwei ADXL335 Beschleunigungsaufnehmer und einen Mikrocontroller. Auf Knopfdruck beginnt die Messung. Die Daten werden an CoolTerm übertragen und in einer Textdatei gespeichert. Das klappt soweit.
Soweit ich weiß, messen die Aufnehmer nur bis 1.600Hz (was soll das bedeuten? Sind die bis zu diesen Frequenzen noch „genau“?)
Ich habe in einem ersten Test mit 4.000Hz das Signal abgetastet, sehe teilweise auch peaks im Bereich der Nyquist Frequenz (2.000Hz). Es könnte also durchaus sein, dass Aliasing auftritt.
Nun würde ich im Code einen Tiefpassfilter integrieren damit ich nur bis zu den 1.600Hz Frequenzen aufnehme. Die Baurate ist auf 40.000 eingestellt (sowohl im Arduino Code als auch in CoolTerm).
Seht ihr da noch irgendetwas was mir Probleme macht, machen könnte oder ähnliches was ich evtl nicht berücksichtigt habe?
Vorallem was die Baurate und so angeht habe ich keine Ahnung. Das habe ich von ChatGPT coden lassen.
Hier noch ein Bild der Plots vom Test.
Leerlauf: Maschine läuft, Bohrer bohrt nicht
Bohrdaten: Bohrer hat Kontakt mit Material
Differenz: Differenzmethode
Dazu müsstest du mal noch mehr Detaildaten anliefern.
Über was für eine Art Schnittstelle kommen die Sensordaten in den Arduino?
Ist das analog ? oder I2C? oder SPI?
Falls I2C-Bus oder SPI-Bus , welche Frequenz wird für den Bus benutzt?
Wie lange dauert die Übertragung eines Messwertes?
Wie verhält sich diese Zeitdauer der Messwertübertragung in Bezug auf deine maximale Messfreqruenz?
Wie lange dauert es ein Messwertepaar aus den beiden Sensoren zu übertragen?
Wie verhält sich diese Übertragungsdauer mit der maximalen Mess-Frequenz?
Falls der Sensor Analogausgänge hat wie lange dauert die ADC-Konversion?
Ich habe es nicht gerechnet aber aus dem Bauch heraus schätze ich das bei 1600 Hz 40000 Baud zu langsam ist.
Tja und ohne deinen Code zu sehen kann man dazu gar nix sagen.
Wie wäre es mit Link posten zum Datenblatt des ADXL335 ?
Oder Noch besser Link und dann zusätzlich Screenshots von den Stellen die du im Datenblatt benutzt hast.
Auweia ! KI programmieren lassen kann gut gehen muss aber nicht.
Und noch einmal ohne den Code zu sehen kann man das nicht beurteilen
Ohne Code und ohne Analyse was braucht da wie viel Zeit könnte das alles mögliche zwsichne kompletter Selbstveräpplung und funktioniert einwandfrei sein.
Erstmal danke für die schnelle Antwort. Die Sensoren sind Analog. Hier ein Link von den eingebauten Modulen ... https://www.digikey.com/en/htmldatasheets/production/466599/0/0/1/adxl335 ...
Hier mein Arduino Code:
// Arduino Sketch für Messung von Vibrationen mit zwei ADXL335 Sensoren
int sensor1X = A0; // Pin für den X-Wert von Sensor 1
int sensor1Y = A1; // Pin für den Y-Wert von Sensor 1
int sensor1Z = A2; // Pin für den Z-Wert von Sensor 1
int sensor2X = A3; // Pin für den X-Wert von Sensor 2
int sensor2Y = A4; // Pin für den Y-Wert von Sensor 2
int sensor2Z = A5; // Pin für den Z-Wert von Sensor 2
int buttonPin = 7; // Pin für den Taster (Button)
int ledPin = 13; // Pin für die LED
bool measuring = false; // Status der Messung (läuft oder nicht)
unsigned long lastButtonPress = 0; // Zeitstempel des letzten Tastendrucks
int buttonState = 0; // Aktueller Zustand des Tasters
int lastButtonState = LOW; // Vorheriger Zustand des Tasters
void setup() {
Serial.begin(400000); // Serielle Kommunikation starten
pinMode(buttonPin, INPUT); // Taster als Eingang
pinMode(ledPin, OUTPUT); // LED als Ausgang
}
void loop() {
// Taster abfragen und die Messung starten/stoppen
buttonState = digitalRead(buttonPin);
// Überprüfen, ob der Taster von LOW nach HIGH gewechselt ist (Taster gedrückt)
if (buttonState == HIGH && lastButtonState == LOW && millis() - lastButtonPress > 200) {
lastButtonPress = millis(); // Zeit des letzten Tastendrucks speichern
measuring = !measuring; // Messung starten/stoppen
digitalWrite(ledPin, measuring ? HIGH : LOW); // LED ein/aus
}
lastButtonState = buttonState; // Den letzten Zustand des Tasters speichern
// Wenn Messung läuft, Werte vom Sensor einlesen und an den seriellen Monitor senden
if (measuring) {
int sensor1XVal = analogRead(sensor1X);
int sensor1YVal = analogRead(sensor1Y);
int sensor1ZVal = analogRead(sensor1Z);
int sensor2XVal = analogRead(sensor2X);
int sensor2YVal = analogRead(sensor2Y);
int sensor2ZVal = analogRead(sensor2Z);
// Ausgabe der Sensordaten ohne Zeitstempel
Serial.print("Sensor1_X: ");
Serial.print(sensor1XVal);
Serial.print(", Sensor1_Y: ");
Serial.print(sensor1YVal);
Serial.print(", Sensor1_Z: ");
Serial.print(sensor1ZVal);
Serial.print(", Sensor2_X: ");
Serial.print(sensor2XVal);
Serial.print(", Sensor2_Y: ");
Serial.print(sensor2YVal);
Serial.print(", Sensor2_Z: ");
Serial.println(sensor2ZVal);
delayMicroseconds(250); // 0,25 ms (250 Microseconds) Pause zwischen den Messungen ... 4 kHz Abtastrate
}
}
Wenn die Messung läuft, leuchtet noch eine LED, aber das ist nur eine kleine Spielerei um den Messvorgang zu überwachen.
Ich nutze den AZ-ATmega328 Microkontroller.
ADC-Umwandlung etwa 104 µs pro Messung bei einer Standart Taktfrequenz von 16 MHz.
Programmiere eine Zeitmessung hinzu.
erster Zeitstempel ganz oben in loop()
zweiter Zeitstempel nach dem senden der Daten auf die serielle Schnittstelle
Dann Zeitstempel2 - Zeitstempel1 ausgeben lassen.
Da kommt garantiert mehr als 250 µsec raus.
daraus folgt, dass deine Abtastrate kleiner als 4 kHz ist.
Diese Zeilen geben 90 byte aus
// Ausgabe der Sensordaten ohne Zeitstempel
Serial.print("Sensor1_X: ");
Serial.print(sensor1XVal);
Serial.print(", Sensor1_Y: ");
Serial.print(sensor1YVal);
Serial.print(", Sensor1_Z: ");
Serial.print(sensor1ZVal);
Serial.print(", Sensor2_X: ");
Serial.print(sensor2XVal);
Serial.print(", Sensor2_Y: ");
Serial.print(sensor2YVal);
Serial.print(", Sensor2_Z: ");
Serial.println(sensor2ZVal);
Jedes Byte 10 Bit.
8 Datenbit plus Startbit plus Stopbit
Also 900 Bit mit 40000 bits pro Sekunde.
900 Bit / 40.000 Bits/sec * 1.000.000 µsec/sec = 22500 µsec
plus 250 µsec delay macht dann
t = 22750 µsec oder 0.02275 Sekunden
Abtastfrequenz 1 / 0,02275 = 44,44 Hz
Ich habe noch nicht viel mit den ADC-Wandlern mit hochfrequent messen gemacht. Ich erinnere mich dunkel, das da etwas war mit Konversionszeit und lieber zweimal messen damit sich der ADC-Eingang "beruhigt".
Alles in allem kommt mir das vor als wenn es da besser wäre man würde einen Microcontroller nehmen der AD-Wandler mit möglichst kurzer Wandlungszeit und auch möglichst hohe Taktfrequenz hat.
Und dann die Messdaten mit möglichst hoher Gesschwindigkeit wegspeichern.
Keine Ahnung wie lange du am Stück messen willst.
Ein Teensy 4.1 wird mit 600 MHz getaktet und hat 512 kB RAM.
Da passt einiges rein. Oder du überträgst die Daten per USB auf einen PC
und dann nicht mit 0,04 MBit wie ChatGPT vorgeschlagen hat sondern mit 2 MBit.
owei ... tatsächlich übertrage ich die Daten der USB Kabel auf den Laptop. Vom seriellen Monitor zu CoolTerm. CoolTerm speichert das in einer Textdatei.
Ich würde als erstes mal auf 3200Hz runter gehen was die abtastfrequenz angeht, die Baurate würde ich dann auf 115200 stellen statt 400.000.
Wenn ich unnötigen Text weglasse könnte ich die Datenmenge reduzieren, also einfach nur Zahlen ausgeben.
So sieht es jetzt aus:
Sensor1_X: 352, Sensor1_Y: 347, Sensor1_Z: 426, Sensor2_X: 351, Sensor2_Y: 352, Sensor2_Z: 424
Besser wäre vllt:
352, 347, 426, 351, 352, 424
123, 456, 789, 987, 654, 321
...
würde es vllt auch noch helfen die Werte binär zu übertragen ?
Wie ich das verstehe muss ich sicherstellen dass die Übertragung schnell genug stattfindet, also kleine Datenmengen.
Die einzelnen Messungen sollen eigentlich etwa 10-15min dauern. Ich könnte das aber auch noch kürzen.
ich habe den Zeitstempel mal eingefügt und die Ausgabe etwas gekürzt. Ich bin jetzt mit einer Baurate von 400.000 bei einer Übertragungszeit von 2ms ... also immer noch viel zu langsam.
Hier der neue Code:
// Arduino Sketch für Messung von Vibrationen mit zwei ADXL335 Sensoren
int sensor1X = A0; // Pin für den X-Wert von Sensor 1
int sensor1Y = A1; // Pin für den Y-Wert von Sensor 1
int sensor1Z = A2; // Pin für den Z-Wert von Sensor 1
int sensor2X = A3; // Pin für den X-Wert von Sensor 2
int sensor2Y = A4; // Pin für den Y-Wert von Sensor 2
int sensor2Z = A5; // Pin für den Z-Wert von Sensor 2
int buttonPin = 7; // Pin für den Taster (Button)
int ledPin = 13; // Pin für die LED
bool measuring = false; // Status der Messung (läuft oder nicht)
unsigned long lastButtonPress = 0; // Zeitstempel des letzten Tastendrucks
int buttonState = 0; // Aktueller Zustand des Tasters
int lastButtonState = LOW; // Vorheriger Zustand des Tasters
void setup() {
Serial.begin(400000); // Serielle Kommunikation starten mit Baudrate 115200
pinMode(buttonPin, INPUT); // Taster als Eingang
pinMode(ledPin, OUTPUT); // LED als Ausgang
}
void loop() {
unsigned long timestamp1, timestamp2; // Variablen für Zeitstempel
// Erster Zeitstempel (Start der loop())
timestamp1 = millis();
// Taster abfragen und die Messung starten/stoppen
buttonState = digitalRead(buttonPin);
// Überprüfen, ob der Taster von LOW nach HIGH gewechselt ist (Taster gedrückt)
if (buttonState == HIGH && lastButtonState == LOW && millis() - lastButtonPress > 200) {
lastButtonPress = millis(); // Zeit des letzten Tastendrucks speichern
measuring = !measuring; // Messung starten/stoppen
digitalWrite(ledPin, measuring ? HIGH : LOW); // LED ein/aus
}
lastButtonState = buttonState; // Den letzten Zustand des Tasters speichern
// Wenn Messung läuft, Werte vom Sensor einlesen und an den seriellen Monitor senden
if (measuring) {
int sensor1XVal = analogRead(sensor1X);
int sensor1YVal = analogRead(sensor1Y);
int sensor1ZVal = analogRead(sensor1Z);
int sensor2XVal = analogRead(sensor2X);
int sensor2YVal = analogRead(sensor2Y);
int sensor2ZVal = analogRead(sensor2Z);
// Ausgabe der Sensordaten im gewünschten Format
Serial.print("1X: ");
Serial.print(sensor1XVal);
Serial.print(", 1Y: ");
Serial.print(sensor1YVal);
Serial.print(", 1Z: ");
Serial.print(sensor1ZVal);
Serial.print(", 2X: ");
Serial.print(sensor2XVal);
Serial.print(", 2Y: ");
Serial.print(sensor2YVal);
Serial.print(", 2Z: ");
Serial.println(sensor2ZVal);
// Zweiter Zeitstempel (nach dem Senden der Daten)
timestamp2 = millis();
// Berechnung und Ausgabe der Zeitdifferenz
unsigned long transmissionTime = timestamp2 - timestamp1;
Serial.print("Übertragungszeit: ");
Serial.print(transmissionTime); // Zeit in Millisekunden
Serial.println(" ms");
delayMicroseconds(312); // 3200 Hz Abtastfrequenz, 312 Mikrosekunden Verzögerung
}
}
So sieht die ausgabe aus:
1X: 306, 1Y: 361, 1Z: 314, 2X: 353, 2Y: 416, 2Z: 321
√úbertragungszeit: 2 ms
1X: 306, 1Y: 360, 1Z: 314, 2X: 354, 2Y: 416, 2Z: 321
√úbertragungszeit: 2 ms
1X: 306, 1Y: 360, 1Z: 314, 2X: 354, 2Y: 416, 2Z: 321
√úbertragungszeit: 2 ms
Als nächstes würde ich wohl auf eine andere art der Übertragung zurückgreifen müssen. SPI oder I2C. Da müsste ich mir nen Adapter für kaufen und dann meinen Laptop über den Adapter mit dem Controller verbinden ?
Das ist keine wirklich exakte Angabe. Was ist das ? Ein Arduino-Uno? ein Arduino-Nano?
Hat das Board einen 16 MHz Kristall oder einen x MHz Keramik-Resonator?
Wenn man den Zahlenwert selbst binär überträgt braucht man pro Messwert nur 2 Bytes.
Die Zahlen als int-Variablen speichern (sind auf dem Atmega328P 16 bit)
Der Messwert muss jedoch in Lo-Byte und High-Byte zerlegt werden.
Das ist dann aber wahrscheinlich trotzdem schneller.
High-Byte: 8 bits nach rechts schiften
Low-byte binäre AND-Operation mit 0xFF
und dann mit Serial.write() übertragen.
Und dann wirklich nur ein Startbyte und dann 2 Byte pro Messwert.
Dann bist du bei 13 Bytes.
Die Baudrate kann man noch höher stellen.
Sendedauer bei 1 MBaud = 1.000.000 baud
13 * 10 / 1000000 * 1000 ms/sec = 0,13 ms
Du sendest doch die ganzen Bytes immer in einer festen Reihenfolge und dann kann man das auf der Empfängerseite eindeutig zuordnen.
Die Daten sind dann aber nicht mehr direkt lesbar weil ist ja dann kein ASCII-Code mehr.
Was genau hast du jetzt für einen Microcontroller?
Arduino-Uno?, Arduino-Nano?
Ein Teensy 4.1 kostet ca 45 Euro. Nicht ganz billig aber eben sauschnell.
Der kann auf den seriellen Hardware-UARTS die auf den IO-pins liegen mit 6 MBaud übertragen. Ob das auch für den "Standard"-Serial-Port, also den über den man auch den Code übertragt, gilt habe ich auf die schnelle nicht herausfinden können.
Wenn du beim vorhandenen Microcontroller bleiben willst dann gibt es da diverses Optimierungspotential.
Ich würde mal mit Zeitdifferenzmessung alles ausmessen
wie lange dauert das hier:
buttonState = digitalRead(buttonPin);
digitalRead ist auch vergleichsweise langsam zu direktem Port lesen
wie lange dauert das hier:
Das dient ja wahrscheinlich für Messung Start/Stop
Das könnte man auch per Interrupt machen. Und in der ISR eine boolesche Variable setzen.
Dann reduziert sich die If-bedingung auf
if (tasteGedrueckt) {
}
Kann sein, dass es so etwas gibt. Weiß ich aber nicht.
SPI ist ein sehr schneller Bus aber du brauchst dann tatsächlich einen Adapter SPI auf USB.
mal noch genauer nachgefragt:
Brauchst du jetzt nur die Frequenz der Vibration und sind diese Vibrationen über
einen Versuch konstant?
oder
brauchst du den exakten Verlauf wie das Teil dreidimensional hin und her vibriert?
Also wie Amplitude in X-Richtung, Y-Richtung, Z-Richtung?
und verändern sich die Vibrationen im Verlauf eines Versuchs?
Wenn nur die Frequenz wichtig ist, dann könnte man sich mal das Ausgangssignal der Sensoren auf einem Speicheroszilloskop anschauen um zu sehen wie das in den unterschiedlichen Fällen aussieht und eventuell mit niedriger Messfrequenz die Frequenz ausgeben.
Wenn die Beschleunigungssensoren hochfrequent dreidimensional inklusive Amplitude aufgezeichnet werden sollen, dann würde ich tatsächlich einen Teensy 4.1 nehmen
Den Teensy 4.1 gibt es auch mit Ethernet und dann einen entsprechenden Adapter auf RJ45-Buchse
Auf die Schnelle habe ich aber noch nicht herausgefunden ob die Datenübertragung per Ethernet schneller ist als per USB/Seriell
So ich habe jetzt ein paar Tests mit dem Teensy 4.0 gemacht. Das ist der gleiche Prozessor wie Teensy 4.1 nur weniger IO-pins
6 MBaud als Baudrate
Testcode
unsigned long MyTestTimer = 0; // Timer-variables MUST be of type unsigned long
const byte OnBoard_LED = 13;
unsigned long startTime;
unsigned long EndTime;
void setup() {
Serial.begin(6000000);
Serial.println("Setup-Start");
PrintFileNameDateTime();
}
int ADChannel[6];
const byte pinNrOffset = 14;
void loop() {
BlinkHeartBeatLED(OnBoard_LED, 250);
if ( TimePeriodIsOver(MyTestTimer, 1000) ) {
startTime = micros();
for (byte i = 0; i < 6; i++) {
ADChannel[i] = analogRead(A0 + i);
Serial.print("ADChannel[");
Serial.print(i);
Serial.print("]=");
Serial.println(ADChannel[i]);
}
EndTime = micros();
Serial.print("EndTime - startTime =");
Serial.print(EndTime - startTime);
Serial.println(" micro-seconds");
Serial.println();
}
}
// helper-functions
void PrintFileNameDateTime() {
Serial.println( F("Code running comes from file ") );
Serial.println( F(__FILE__) );
Serial.print( F(" compiled ") );
Serial.print( F(__DATE__) );
Serial.print( F(" ") );
Serial.println( F(__TIME__) );
}
// easy to use helper-function for non-blocking timing
// explanation see here
// https://forum.arduino.cc/t/example-code-for-timing-based-on-millis-easier-to-understand-through-the-use-of-example-numbers-avoiding-delay/974017
boolean TimePeriodIsOver (unsigned long &startOfPeriod, unsigned long TimePeriod) {
unsigned long currentMillis = millis();
if ( currentMillis - startOfPeriod >= TimePeriod ) {
// more time than TimePeriod has elapsed since last time if-condition was true
startOfPeriod = currentMillis; // a new period starts right here so set new starttime
return true;
}
else return false; // actual TimePeriod is NOT yet over
}
void BlinkHeartBeatLED(int IO_Pin, int BlinkPeriod) {
static unsigned long MyBlinkTimer;
pinMode(IO_Pin, OUTPUT);
if ( TimePeriodIsOver(MyBlinkTimer, BlinkPeriod) ) {
digitalWrite(IO_Pin, !digitalRead(IO_Pin) );
}
}
Ausgabe:
22:07:32.524> ADChannel[0]=14
22:07:32.524> ADChannel[1]=7
22:07:32.524> ADChannel[2]=1018
22:07:32.524> ADChannel[3]=1020
22:07:32.524> ADChannel[4]=1016
22:07:32.524> ADChannel[5]=1017
22:07:32.524> EndTime - startTime =112 micro-seconds
22:07:32.524>
Also 6 AD-Kanäle einlesen plus ca. 90 byte Ausgeben
= 112 Microsekunden.
Also selbst auf dem Teensy wäre da ein delay(250) zu viel
250 -112 = 138
delay(138) ergäbe dann 4 kHz Abtastrate
Auch interessant
Ich habe mal ohne ADC einlesen immer gleich 10 kB Fixtext ausgeben lassen.
Da schwankte die Zeit zwischen 177 µsec und 500 µsec.
Am PC eingelesen habe ich mit br@ysTerminal. Wenn es damit geht, geht es vermutlich mit anderen Serial-Terminalprogrammen auch mit 6MBaud einzulesen.
Hi Stafan, erstmal danke für dein engagement und die zeit die du investierst. Das halte ich nicht für selbstverständlich.
Ich versuche mal die Fragen Schritt für Schritt zu beantworten. Verzeih mir wenn die Antworten manchmal zu unpräzise sind, aber ich bin mehr aus der Mechanical Abteilung nicht aus den Mechatronics.
Der Mikrocontroller ist ein Arduino UNO, Clock Speed 16MHz.
Ich glaube die Daten würde ich gerne genau so übertragen wie ich es aktuell mache, also:
1X: 123, 1Y: 456, 1Z: 789, 2X: … ich habe es zuletzt auch mal mit write versucht aber das war ne Katastrophe. Binär war es sogar noch langsamer.
Dass das Auslesen des Zustandes vom Taster Zeit frisst ist ein guter Hinweis. Daran habe ich nicht gedacht. Ich würde das aber gerne beibehalten um mehr Kontrolle über den Messvorgang zu haben. Sonst mache ich vllt Fehler beim Messvorgang stoppen und wenn Daten dann weg kommen sollten, sind die weg, weil wenn ich gebohrt habe ist das Material zerspant und kommt nicht wieder zurück … Taster drücken: Messung starten, Taster drücken: Messung beenden.
Wie würde denn „direktes Port lesen“ funktionieren?
Ich brauche die auftretenden Frequenzen inklusive Amplituden und die Beschleunigungen. Die Amplituden sind besonders wichtig, weil diese den größten Schaden an der Maschine verursachen können. Diese gilt es also durch eine Parameteranpassung zu optimieren. Wenn ich also die Frequenzen bis meinetwegen 1500Hz abgetastet bekomme kann ich mit den gemessenen Spannungen der Sensoren Frequenzen, Amplituden und Beschleunigungen ermitteln.
Die Messungen finden immer nacheinander statt. Insgesamt habe ich 4 Parametereinstellungen. Kontrollmessung und 3 Versuchsreihen. Eine Messung dauert immer 10-15min, kann aber auch kürzer gestaltet werden. Die Vibrationen werden nicht sehr konstant sein, deswegen werde ich primär die Frequenzen mit den großen Amplituden betrachten und sehen wie sich diese ändern mit anderen Parametern. Alle 3-Achsen würde ich auch gerne messen (X,Y,Z). Ich werde also am Ende zB sagen: mit höherer Drehzahl schwing das System schneller, die Amplituden sind aber kleiner. Oder: mit größerem Vorschub sind die Vibrationen in X-Richtung kleiner, weil mehr Druck entsteht und das Spiel im System verringert wird.
Meine Sensoren haben in X und Y Richtung eine Bandbreite von 1600Hz und in Z Richtung von 500Hz. Was bedeutet an dieser Stelle Bandbreite? … Bis zu welcher Frequenz kann ich mit denen überhaut messen? Kann ich dann mit mit 1600 bzw 500Hz abtasten oder kann ich doppelt abtasten und bekomme dann gute ergebnisse für diese 500 bis 1600Hz?
In den Teensy 4.1 würde ich sofort investieren, wenn ich weiss dass es damit klappt und ich meine sensoren damit auch nutzen kann.
Hier noch ein Foto von meiner Schaltung …
Je öfter du wenn Spannungswert einliest desto genauer wird der tatsächliche Spannungsverlauf abgebildet.
Ich bin kein Messtechnik-Experte aber da gibt es bestimmt Definitionen mit welcher Abtastrate man ein schnell veränderliches Signal abtasten muss um eine Mindestqualität zu haben.
Wenn Die Vibration 1599,9 Hz hat und du tastest mit 1600 Hz ab dann wirst du mal die Spitze mal irgendwelche niedrigeren Werte messen. Ich schätze mal, das man für die Erfassung eines 1600 Hz Signals mit der 5-fachen Frequenz abtasten müsste um den Kurvenverlauf mit zu bekommen.
Das Datenblatt des Sensors sagt Versorgungsspannung 1,8 bis 3,6V.
Der Teensy 4.0/4.1 läuft mit 3,3V das passt also.
Beim Teensy kann man die Wandlungszeit des AD-Wandlers verändern.
Vielleicht kann man da noch mehr herausholen.
Zuerst mal wie Du im laufe der Diskussion schreibst:
The user selects the bandwidth of the accelerometer using the
CX, CY, and CZ capacitors at the XOUT, YOUT, and ZOUT pins.
Bandwidths can be selected to suit the application, with a
range of 0.5 Hz to 1600 Hz for the X and Y axes, and a range
of 0.5 Hz to 550 Hz for the Z axis.
Also ist die Bandbreite ohne Kondensatoren 1600Hz bzw 550Hz.
Bandbreite ist definiert die Frequenz bei der das Signal um 50 % abgeschwächt wird. Je weiter die Frequenz von der Grenzfrequenz weg ist desto mehr wird sie abgeschwächt.
Ich sehe diesen Sensor als ungeeignet für die Messung die Du machen willst.
Die niedrigere Grenzfrequenz in Z Achse könnte man mit einem zweiten Sensor der um 90°gedreht montiert wird, sodaß zB die X achse in Z Richtung zu liegen kommt und Du X und Y des ersten Sensors und X des zweiten als Z Achse liest. Also statt 2 Sensoren 4 nimmst. Die Messung bleibt gleich da Du von 6 vorhandenen Signalen der beiden Sensoren nur 3 ausliest.
Grüße Uwe
Ja habe ich auch bereits überlegt, aber ...
die Sensoren haben 2 verschiedene Abstände von der Stelle, die zerspant wird. Einer 30mm entfernt, der andere 500mm weiter weg. Der Anschluss weiterer Sensoren würde ausserdem wieder Mehraufwand bedeuten. Deswegen wollte ich bei zwei Sensoren bleiben.
Sensoren wie der ADXL1002 haben bessere Bandbreiten, messen aber nur eine Achse ...
Gruß Marko
was ist deine Fachrichtung und wie wichtig ist die dargelegte Software für deine Note?
Soll heißen - muss die Software nur "korrekt funktionieren" oder muss sie auch irgendwelchen softwaretechnischen Anforderungen genügen?
Das ist für meine Bachelorarbeit im Maschinenbau.
Dass es korrekt funktioniert ist wichtig. Der Rest ist eig egal.
Mein Prof ist da sehr pragmatisch
dann reicht auch das was die AI rausgespuckt hat 
Der Code funktioniert, aber die Datenübertragung ist halt zu langsam. Ich bekomme die Daten nur im 250Hz Takt. Könnte also nur sehr niedrige Frequenzen auswerten.
Vorschlag: FRAM anschließen (I2C oder schneller SPI) und erst mal die Messreihe dort abspeichern. Nach Ende der Messung zum PC senden. Da hast Du dann ja Zeit.
Gruß Tommy
Messzeit 10 Minuten
10 Min * 60 Sec/min * 1600 Messungen/Sec * 6 Messwerte = 5.760.000 byte = 5,7 Megabyte
Gibt es FRAM mit Megabyteweise Speicher?
Wie im Testprogramm oben gemessen dauert 6 AD-Kanäle einlesen und dann 90 Byte seriell ausgeben 112 µsec.
Du hast noch ein bisschen Code drum herum schätzen wir mal 200 µsec
als Laufzeit für einen Durchlauf von loop()
Das wären dann 5000 Messungen pro Sekunde auf 6 Kanälen
"korrekt funktioniert" ist da viel zu schwammig.
Was muss wie gut funktionieren? Und wie genau?
Du verwendest da Messtechnik. Also solltest du Aussagen:
- zur maximalen Messwert-Frequenz
- zur Messauflösung
- zur Messgenauigkeit
machen.
Wenn denn wenigstens dass wissenschaftlich sauber und detailliert abgehandelt wurde mag es ja OK sein.
Mit dem Arduino Uno und den bis jetzt verwendeten Sensoren kommt da kurz über zwei Daumen geschätzt heraus:
Messwertfrequenz 50 Hz (es sollten wenigstens 5 Messwerte pro Schwingung erfasst werden.
Auf Basis dessen kann man dann eine analysierende Berechnung machen wie groß der maximale Amplitudenfehler ist wenn alle fünf Messwerte gerade nicht die Maximalamplitude erfassen.
Da müsstest du dann als Fazit schreiben
"Die verwendete Messtechnik ist wegen zu geringer Performance ungeeignet."
Das würde mich in der Bachelorarbeit echt wurmen.
Was ist denn deinem Prof wichtiger die rechtzeitige Abgabe in einer Woche (oder wie lange das auch sein mag) ?
Oder eine wirklich erfolgreich arbeitende Messeinrichtung und Messergebnisse die Hand und Fuss haben?
Ich würde da noch einmal Arbeit reinstecken einen Teensy 4.0 und Sensoren die höhere Frequenzen erfassen können verwenden. Auch wenn das noch einmal Umbauarbeiten erfordert.