Patric
Aktiv
Ich würde noch in den Raum werfen beim ansprechen des Nextion Displays auf die Library zu verzichten. Ich hab das Display direkt mit einer kleinen Subroutine angesprochen. Das sieht im Code ziemlich grausam aus, aber die Refreshrate ging erheblich hoch.
Die Abtastrate hab ich glaube ich auf ein Kiloherz gelegt. damit konnte ich dann feststellen wann das Signal die Richtung gewechselt hat. Damit konnte man gut die Drehzahl berechnen. Ich such mal, irgendwo hatte ich noch den Code.
Ach so, ich hab um das Signal zu Filtern eine einfache Funktion gewählt die sich im Arduino bewährt hat. Das Gefilterte Signal ergibt sich aus 0.1 Prozent vom aktuellen Signal +99.9% vom letzten Gefilterten Signal. Bei konstanter Samplingrate kann man an dem Verhältnis spielen um das Signal mehr oder weniger zu Dämpfen. Ich hoffe das erkennt man im Code, gehe noch mal auf die Suche.
Die Abtastrate hab ich glaube ich auf ein Kiloherz gelegt. damit konnte ich dann feststellen wann das Signal die Richtung gewechselt hat. Damit konnte man gut die Drehzahl berechnen. Ich such mal, irgendwo hatte ich noch den Code.
Ach so, ich hab um das Signal zu Filtern eine einfache Funktion gewählt die sich im Arduino bewährt hat. Das Gefilterte Signal ergibt sich aus 0.1 Prozent vom aktuellen Signal +99.9% vom letzten Gefilterten Signal. Bei konstanter Samplingrate kann man an dem Verhältnis spielen um das Signal mehr oder weniger zu Dämpfen. Ich hoffe das erkennt man im Code, gehe noch mal auf die Suche.
Zuletzt bearbeitet:
Patric
Aktiv
Codeaszüge:
Signal Filter:
U_A0_RAW = analogRead(A0);
U_A1_RAW = analogRead(A1);
filtered_U_A0 = 0.997 * filtered_U_A0 + 0.003 * U_A0_RAW; //signal generates a filtered signal from the Analog input Sensor A0
filtered_U_A1 = 0.997 * filtered_U_A1 + 0.003 * U_A1_RAW; //signal generates a filtered signal from the Analog input Sensor A1
Display update code:
void UpdateDisplay() //---------------------------------------------- Display Update SUB -----------------------------------------------
{
float P_LEFT = ((filtered_U_A0 * (5.0 / 1024.0)) * 78) + 750;
float P_RIGHT = ((filtered_U_A1 * (5.0 / 1024.0)) * 78) + 750;
float P_LEFT_No_Filter = ((U_A0_RAW * (5.0 / 1024.0)) * 78) + 750;
float P_RIGHT_No_Filter = ((U_A1_RAW * (5.0 / 1024.0)) * 78) + 750;
P_LEFT_CAL = map(P_LEFT, 750, 1140, 0, 100);
P_RIGHT_CAL = map(P_RIGHT, 750, 1140, 0, 100);
P_DIFF = P_LEFT_CAL - P_RIGHT_CAL;
if (P_DIFF < -20) P_DIFF = -20;
if (P_DIFF > 20) P_DIFF = 20;
SYNCH_DIFF = map (P_DIFF, 20, -20, 100, 0);
int P_LEFT_SCOPE = map(P_LEFT, 750, 1140, 0, 255);
int P_RIGHT_SCOPE = map(P_RIGHT, 750, 1140, 0, 255);
int P_LEFT_SCOPE_No_Filter = map(P_LEFT_No_Filter, 750, 1140, 0, 255);
int P_RIGHT_SCOPE_No_Filter = map(P_RIGHT_No_Filter, 750, 1140, 0, 255);
TX"add 2,0,", P_LEFT_SCOPE);
TX"add 2,1,", P_RIGHT_SCOPE);
TX"h0.val=", SYNCH_DIFF);
TX"j1.val=", P_RIGHT_CAL);
TX"j0.val=", P_LEFT_CAL);
TX"n0.val=", P_LEFT);
TX"n1.val=", P_RIGHT);
}
void TXString address, int value) //-------------------------------- Data transmit to display SUB -------------------------------------
{
String sstring = address + String(value);
int str_len = sstring.length() + 1;
char sendchar[str_len];
sstring.toCharArray(sendchar, str_len);
Serial.print(sendchar);
Serial.write(0xff);
Serial.write(0xff);
Serial.write(0xff);
}
Signal Filter:
U_A0_RAW = analogRead(A0);
U_A1_RAW = analogRead(A1);
filtered_U_A0 = 0.997 * filtered_U_A0 + 0.003 * U_A0_RAW; //signal generates a filtered signal from the Analog input Sensor A0
filtered_U_A1 = 0.997 * filtered_U_A1 + 0.003 * U_A1_RAW; //signal generates a filtered signal from the Analog input Sensor A1
Display update code:
void UpdateDisplay() //---------------------------------------------- Display Update SUB -----------------------------------------------
{
float P_LEFT = ((filtered_U_A0 * (5.0 / 1024.0)) * 78) + 750;
float P_RIGHT = ((filtered_U_A1 * (5.0 / 1024.0)) * 78) + 750;
float P_LEFT_No_Filter = ((U_A0_RAW * (5.0 / 1024.0)) * 78) + 750;
float P_RIGHT_No_Filter = ((U_A1_RAW * (5.0 / 1024.0)) * 78) + 750;
P_LEFT_CAL = map(P_LEFT, 750, 1140, 0, 100);
P_RIGHT_CAL = map(P_RIGHT, 750, 1140, 0, 100);
P_DIFF = P_LEFT_CAL - P_RIGHT_CAL;
if (P_DIFF < -20) P_DIFF = -20;
if (P_DIFF > 20) P_DIFF = 20;
SYNCH_DIFF = map (P_DIFF, 20, -20, 100, 0);
int P_LEFT_SCOPE = map(P_LEFT, 750, 1140, 0, 255);
int P_RIGHT_SCOPE = map(P_RIGHT, 750, 1140, 0, 255);
int P_LEFT_SCOPE_No_Filter = map(P_LEFT_No_Filter, 750, 1140, 0, 255);
int P_RIGHT_SCOPE_No_Filter = map(P_RIGHT_No_Filter, 750, 1140, 0, 255);
TX"add 2,0,", P_LEFT_SCOPE);
TX"add 2,1,", P_RIGHT_SCOPE);
TX"h0.val=", SYNCH_DIFF);
TX"j1.val=", P_RIGHT_CAL);
TX"j0.val=", P_LEFT_CAL);
TX"n0.val=", P_LEFT);
TX"n1.val=", P_RIGHT);
}
void TXString address, int value) //-------------------------------- Data transmit to display SUB -------------------------------------
{
String sstring = address + String(value);
int str_len = sstring.length() + 1;
char sendchar[str_len];
sstring.toCharArray(sendchar, str_len);
Serial.print(sendchar);
Serial.write(0xff);
Serial.write(0xff);
Serial.write(0xff);
}
Zuletzt bearbeitet:
Euklid55
Urgestein
Kommt drauf an, was Du willst.
Eine rein numerische Anzeige ist beim Vergasereinstellen ohnehin sinnfrei, weil wir ja "nur" Gleichlauf suchen (im Gegensatz zum Lambdawert, wo der absolute Wert interessant ist) => beim Bargraph sind mir persönlich 4 Hz zu langsam, ich möchte da gerne das "Zittern der Nadel" sehen.
"spielt dann keine Rolle" ... bei einer Meßfrequenz von 50 Hz?
Hallo,
z.Z. verwende ich ein analogens Meßgerät das digital mit einem Balken anzeigt. In der Mittelpunktlage sind dann die Vergaser synchron. Das Gerät ist nicht schnell, die Auflösung beträgt 1mbar.
Gruß
Walter
yz88
Aktiv
Ich habe noch mal im Netz gesucht und eine gute Erklärung gefunden, was gemessen werden muss.
http://thedigisync.com/why-the-digi-sync-is-simply-better.html
Dort ist auch der Unterschied zwischen einer digitalen Messung und einer analogen Messung mittels Uhr und Schlauchwaage erklärt. Allerdings auf Englisch.
Zusammenfassend kann man sagen, dass nur der Arbeitstakt des Einsaugen zu betrachten ist. Dieser Arbeitstakt hat zu Beginn den niederigsten und zum Ende hin den höchsten (Unter-)Druck. Über die Zeit zwischen zwei Höchstwerten kann auch die Drehzahl des Motors bestimmt werden.
http://thedigisync.com/why-the-digi-sync-is-simply-better.html
Dort ist auch der Unterschied zwischen einer digitalen Messung und einer analogen Messung mittels Uhr und Schlauchwaage erklärt. Allerdings auf Englisch.
Zusammenfassend kann man sagen, dass nur der Arbeitstakt des Einsaugen zu betrachten ist. Dieser Arbeitstakt hat zu Beginn den niederigsten und zum Ende hin den höchsten (Unter-)Druck. Über die Zeit zwischen zwei Höchstwerten kann auch die Drehzahl des Motors bestimmt werden.
yz88
Aktiv
Es geht doch auch um den Spaß am Basteln 
Anbei ein Video zu meiner aktuellen Lösung, provisorisch in einer Kartenspielschachtel untergebracht.
https://youtu.be/9F1sdNfJ73U
Im Moment arbeite ich noch mit den Mittelwert über eine Zeitspanne/Anzahl von Messwerten. Ich werde demnächst noch mal an die Programmierung gehen, und versuchen die Höchstwerte und die Drehzahl zu ermitteln.
Anbei ein Video zu meiner aktuellen Lösung, provisorisch in einer Kartenspielschachtel untergebracht.
https://youtu.be/9F1sdNfJ73U
Im Moment arbeite ich noch mit den Mittelwert über eine Zeitspanne/Anzahl von Messwerten. Ich werde demnächst noch mal an die Programmierung gehen, und versuchen die Höchstwerte und die Drehzahl zu ermitteln.
Wisst Ihr eigentlich wie leicht Synchronisation mit zwei gesunden Ohren und etwas Fingerspitzengefühl ist ?
Grüße
Claus
Gleich mit zwei vollig fremden und unbekannten Begriffen um dich zu werfen - geht gar nicht.
Hans, der "Böhmi"
Spineframe
Profipfuscher
Bei allem Basteldrang, aber sooo schlecht ist der Twinmax nun auch nicht.
Hier gibt es eine Versuchsreihe dazu:
http://www.gs-forum.eu/r-1150-gs-un...93/challange-twinmax-vs-schlauchwaage-146838/
Hier gibt es eine Versuchsreihe dazu:
http://www.gs-forum.eu/r-1150-gs-un...93/challange-twinmax-vs-schlauchwaage-146838/
Jep, ich arbeite auch sehr gern mit dem Twinmax und find den
absolut genau.
Schöner Test, vielen Dank für den Link
absolut genau.
Schöner Test, vielen Dank für den Link
yz88
Aktiv
Im Beitrag #95 habe ich ja einen Link geteilt, wo die Unterdruckkurve sehr gut beschrieben ist. Nun habe ich im ersten Schritt mal nur den Druck über die Sensoren mit den Arduino gemessen, und über den Serial-Plotter der Arduino Anwendung aufgezeichnet.
Zu erst mal nur einen Zylinder, um eine Vorstellung von der (Druck-)Kurve zu bekommen.
Wenn der Motor nicht läuft, dann liefert der Sensor ein Wert von ca. 840 - also Umgebungsdruck. Wenn der Motor läuft, kann man gut die Maximalwerte des Unterdrucks erkennen, liegen hier so um Werte von 370. Über den Abstand zwischen den Maximalwerten kann man die Drehzahl berechnen.
Als nächstes über beide Zylinder:
Man sieht gut, dass die Sensoren in der Ausgangslage Werte um 840 ausgeben und beide auf dem gleichen Level sind. Die Maximalwerte des Unterdrucks - rote und blaue Kurve - zappeln zwar ein wenig, aber grundsätzlich ist das schon sehr Synchron (im Leerlauf).
Zu erst mal nur einen Zylinder, um eine Vorstellung von der (Druck-)Kurve zu bekommen.
Wenn der Motor nicht läuft, dann liefert der Sensor ein Wert von ca. 840 - also Umgebungsdruck. Wenn der Motor läuft, kann man gut die Maximalwerte des Unterdrucks erkennen, liegen hier so um Werte von 370. Über den Abstand zwischen den Maximalwerten kann man die Drehzahl berechnen.
Als nächstes über beide Zylinder:
Man sieht gut, dass die Sensoren in der Ausgangslage Werte um 840 ausgeben und beide auf dem gleichen Level sind. Die Maximalwerte des Unterdrucks - rote und blaue Kurve - zappeln zwar ein wenig, aber grundsätzlich ist das schon sehr Synchron (im Leerlauf).
yz88
Aktiv
Anbei der Code, incl. Angaben zu den Sensoren:
/*
Determine Pressure
Date: 2018-08-12
Version: version 0 revison 0
Author: yz88
BOM:
# 1x Arduino Uno
# 2x Pressure Sensor (MPX4115AP)
*/
#include <stdlib.h>
int PressureRawLeft = 1023;
int PressureRawRight = 1023;
int DifferenzLeft = 0;
int DifferenzRight = 0;
void setup() {
Serial.begin(9600); // open the serial port at 9600 bps
// calibrate sensors
PressureRawLeft += analogRead(A4);
PressureRawRight += analogRead(A5);
if (PressureRawLeft > PressureRawRight){
DifferenzRight = PressureRawLeft - PressureRawRight;
} else {
DifferenzLeft = PressureRawRight - PressureRawLeft;
}
}
void loop() {
delay(2);
PressureRawLeft = analogRead(A4) + DifferenzLeft;
PressureRawRight = analogRead(A5)+ DifferenzRight;
//Serial.print(PressureRawLeft);
//Serial.print(" ");
Serial.println(PressureRawRight);
}
/*
Determine Pressure
Date: 2018-08-12
Version: version 0 revison 0
Author: yz88
BOM:
# 1x Arduino Uno
# 2x Pressure Sensor (MPX4115AP)
*/
#include <stdlib.h>
int PressureRawLeft = 1023;
int PressureRawRight = 1023;
int DifferenzLeft = 0;
int DifferenzRight = 0;
void setup() {
Serial.begin(9600); // open the serial port at 9600 bps
// calibrate sensors
PressureRawLeft += analogRead(A4);
PressureRawRight += analogRead(A5);
if (PressureRawLeft > PressureRawRight){
DifferenzRight = PressureRawLeft - PressureRawRight;
} else {
DifferenzLeft = PressureRawRight - PressureRawLeft;
}
}
void loop() {
delay(2);
PressureRawLeft = analogRead(A4) + DifferenzLeft;
PressureRawRight = analogRead(A5)+ DifferenzRight;
//Serial.print(PressureRawLeft);
//Serial.print(" ");
Serial.println(PressureRawRight);
}
JIMCAT
Urgestein
Hätte nie gedacht das die Synchronisation unserer BMW Vergaser so wissenschaftlich kompliziert sein kann. 
Jetzt frag ich mich schon wie ich es all die Jahre, und das mit relativ einfachen Mitteln, schaffte die Vergaser einzustellen.
Und meine BMW´s laufen top, wie mir schon mehrfach aus berufenem Mund bestätigt wurde.
Jetzt frag ich mich schon wie ich es all die Jahre, und das mit relativ einfachen Mitteln, schaffte die Vergaser einzustellen.
Und meine BMW´s laufen top, wie mir schon mehrfach aus berufenem Mund bestätigt wurde.
Euklid55
Urgestein
Hallo,
ich würde gerne einmal ein Bild sehen in dem die Vergaser nicht synchronisiert sind. Bei diesen Kurven hätte ich ein Problem mit der Mittelwertbildung.
Gruß
Walter
yz88
Aktiv
Ich werde mal eine Messung machen, bei der die Vergaser nicht synchron laufen.
Und nun wird es interessant:
Ich würde eigentlich nur die maximalen Unterdruckwerte betrachten -also die Peaks die nach unten zeigen. Was meinst du mit Mittelwert? Damit das Signal ein bisschen ruhiger wird kann man evtl. einen Mittelwert über mehrere Maximalwerte bilden.
Genau um solche Fragen geht es
, um dann ein vernüftiges Programm zu schreiben.
Wenn die Spitzen der roten und blauen Kurve unten auf einer Linie liegen, dann laufen die Vergaser synchron.
VG Holger
Und nun wird es interessant:
Ich würde eigentlich nur die maximalen Unterdruckwerte betrachten -also die Peaks die nach unten zeigen. Was meinst du mit Mittelwert? Damit das Signal ein bisschen ruhiger wird kann man evtl. einen Mittelwert über mehrere Maximalwerte bilden.
Genau um solche Fragen geht es
, um dann ein vernüftiges Programm zu schreiben.Wenn die Spitzen der roten und blauen Kurve unten auf einer Linie liegen, dann laufen die Vergaser synchron.
VG Holger
yz88
Aktiv
Ich habe den Programmcode überarbeitet und der Arduino mißt jetzt die beiden analog Werte so schnell er kann - Freerunning Mode.
Dann bestimme ich für jeden Einsaug-Takt den minimal-Wert (größter Unterdruck) pro Zylinder und gib diese aus. Aktuell stelle ich alle vier Werte da:
1) Unterdruck erster Zylinder
2) minmal-Wert erster Zylinder
3) Unterdruck zweiter Zylinder
4) minimal-Wert zweiter Zylinder
Ausgewertet wird nur der Einsaug-Takt, und es wird aktuell kein Mittelwert gebildet.
Die folgende Grafik zeigt die Messkurven der beiden Drucksensoren. Die blaue Linie zeigt den ersten Drucksensor (rechter Zylinder), die Grünlinie die zweite (linker Zylinder). Die orangefarbene und rote Linie zeigt die Minimalwerte der einzelnen Zylinder.
Als nächstes werde ich die Darstellung auf den Nextion Display angehen.
Dann bestimme ich für jeden Einsaug-Takt den minimal-Wert (größter Unterdruck) pro Zylinder und gib diese aus. Aktuell stelle ich alle vier Werte da:
1) Unterdruck erster Zylinder
2) minmal-Wert erster Zylinder
3) Unterdruck zweiter Zylinder
4) minimal-Wert zweiter Zylinder
Ausgewertet wird nur der Einsaug-Takt, und es wird aktuell kein Mittelwert gebildet.
Die folgende Grafik zeigt die Messkurven der beiden Drucksensoren. Die blaue Linie zeigt den ersten Drucksensor (rechter Zylinder), die Grünlinie die zweite (linker Zylinder). Die orangefarbene und rote Linie zeigt die Minimalwerte der einzelnen Zylinder.
Als nächstes werde ich die Darstellung auf den Nextion Display angehen.
yz88
Aktiv
Nun läuft die Darstellung wieder auf dem Nextion Display, welches am Arduino angeschlossen ist. Ein Video dazu gibt es auf Youtube https://youtu.be/DKk2O86xgPw.
Mein Projekt habe ich auf Github https://github.com/yz88/arduino-digital-carb-sync/tree/master/part5 dokumentiert. Dort findet man unter anderen auch den Programm-Code und die verwendeten Teile.
Mein Projekt habe ich auf Github https://github.com/yz88/arduino-digital-carb-sync/tree/master/part5 dokumentiert. Dort findet man unter anderen auch den Programm-Code und die verwendeten Teile.
Zuletzt bearbeitet:
austriia
Christian
vielen dank schon mal dafür. ich hab den arduino schon zuhause. im winter möchte ich dieses thema auch angehen. da ist dein projekt natürlich gold wert
yz88
Aktiv
Grundssätzlich sollte es ausreichen nur den Differenzwert auszugeben. Ich persönlich habe gerne einen grafischen Vergleich, da ich diesen schneller beurteilen kann - auch während der Fahrt.
Ich schau mal, ob ich die Differenz noch bei der Darstellung ergänze.
Auf eine Mittellwertbildung habe ich verzichtet, die Werte werden pro Motorumdrehung ausgegeben - also bei 800 1/min alle 75 ms (13,33x/sec). Dadurch zappelt die Anzeige mehr, was manche Leute ja besser finden. Allerdings zappelt dadurch auch der Differenzwert.
VG Holger
Ich hab auch mal ein paar vorhandene Teile "zusammengeworfen":
Ein AVR-Eval-Board mit ATMega 128 (Olimex AVR-MT128), einem LC-Display 16x2 (alphanumerisch, Controller HD44780) und zwei Absolutdrucksensoren MPX 5100.
Die Software wird so ausgelegt, dass maximal 4 Kanäle (4 Sensoren) unterstützt werden.
Vorgesehen ist bis jetzt:
und so die Skala für die Mittenanzeige:
Noch ein paar (geplante) technische Daten:
Sample-Frequenz 1 kHz je Kanal.
Ausgabe der rohen Messwerte per RS-232.
Ermitteln von
Im Moment designe ich die Filter zur Aufbereitung der Messwerte.
Blau ist der Ansaugdruck, gelb der Ausgang eines einstufigen IIR-Tiefpass ("Trockentest" mit Excel).
Das ist sicherlich noch nicht das Optimum. Tests mit Alternativen wie "moving average" oder einem Median-Filter kommen als Nächstes.
Leider hab ich im Moment nur Messdaten eines Motors im Leerlauf.
Und das "Henne-Ei-Problem", denn meine Q ist "zuwendungsbedürftig" und scheidet als Quelle für "gute" Messdaten aus.
Falls also ein Münsterländer (oder Umgebung) mal Zeit und Lust hätte, würde ich gern (bei einem Kaffee, natürlich) hier ein paar Messwerte aufnehmen.
Und jetzt noch der obligate "Blick in die Zukunft":
Das Ganze ist so ausgelegt, dass es im Grunde auf fast jedem Experimentierboard mit einem etwas größeren ATMega (ATMega 128, ATMega 328, ATMega 256x) laufen sollte. Benötigt werden 7 Portleitungen für das Display, 5 für die Taster und 2 bzw. 4 ADC-Kanäle sowie ein UART für die Ausgabe der rohen Messwerte.
Die Software ist komplett in C erstellt, avr-gcc > 4.5.x. Im Moment habe ich ca. 70% des Funktionsumfangs "gebaut".
Die Anpassung an andere Displays (GLCD) und die Erweiterung auf grafische Darstellung des Ansaugdrucks ist als Option vorgesehen.
(Fortsetzung folgt.)
Viele Grüße
Stefan
Ein AVR-Eval-Board mit ATMega 128 (Olimex AVR-MT128), einem LC-Display 16x2 (alphanumerisch, Controller HD44780) und zwei Absolutdrucksensoren MPX 5100.
Die Software wird so ausgelegt, dass maximal 4 Kanäle (4 Sensoren) unterstützt werden.
Vorgesehen ist bis jetzt:
- Parallele Absolutdruckanzeige aller Kanäle als Balkendiagramm (Auflösung 80 Stufen)
- Anzeige des Differenzdrucks zwischen Kanal 0 (Referenz) und einem der anderen Kanäle (Auflösung 75 Stufen)
- Kalibrieren der Kanäle 1 - 3 auf Gleichlauf zu Kanal 0.
- Anzeige der Drehzahl und des maximalen und minimalen Ansaugdrucks
und so die Skala für die Mittenanzeige:
Noch ein paar (geplante) technische Daten:
Sample-Frequenz 1 kHz je Kanal.
Ausgabe der rohen Messwerte per RS-232.
Ermitteln von
- Maximalem Unterdruck (Druckminimum) inkl. Zeitstempel
- Minimalem Unterdruck (Druckmaximum) inkl. Zeitstempel
- tiefpass-gefiltertem Unterdruck (für Abgleich)
- Upm (aus Abstand der Druckminima)
Im Moment designe ich die Filter zur Aufbereitung der Messwerte.
Blau ist der Ansaugdruck, gelb der Ausgang eines einstufigen IIR-Tiefpass ("Trockentest" mit Excel).
Das ist sicherlich noch nicht das Optimum. Tests mit Alternativen wie "moving average" oder einem Median-Filter kommen als Nächstes.
Leider hab ich im Moment nur Messdaten eines Motors im Leerlauf.
Und das "Henne-Ei-Problem", denn meine Q ist "zuwendungsbedürftig" und scheidet als Quelle für "gute" Messdaten aus.
Falls also ein Münsterländer (oder Umgebung) mal Zeit und Lust hätte, würde ich gern (bei einem Kaffee, natürlich) hier ein paar Messwerte aufnehmen.
Und jetzt noch der obligate "Blick in die Zukunft":
Das Ganze ist so ausgelegt, dass es im Grunde auf fast jedem Experimentierboard mit einem etwas größeren ATMega (ATMega 128, ATMega 328, ATMega 256x) laufen sollte. Benötigt werden 7 Portleitungen für das Display, 5 für die Taster und 2 bzw. 4 ADC-Kanäle sowie ein UART für die Ausgabe der rohen Messwerte.
Die Software ist komplett in C erstellt, avr-gcc > 4.5.x. Im Moment habe ich ca. 70% des Funktionsumfangs "gebaut".
Die Anpassung an andere Displays (GLCD) und die Erweiterung auf grafische Darstellung des Ansaugdrucks ist als Option vorgesehen.
(Fortsetzung folgt.)
Viele Grüße
Stefan
Moin Stefan,
... Du bist definitiv ein Geek 
Seeehr hübsch, da könnte ich mich inspirieren
Das wird sportlich. Denk dran, dass der Prozessor gerne niedrige Impedanzen <10 kOhm am Eingang hätte (Quelle), sonst gibts fürchterliches Crosstalk zwischen den Kanälen. Umgekehrt verträgt der Druckwandler nicht viel Ausgangsstrom (maximal 0.5 mA für "meinen" MPXA6115A, d.h. 10 kOhm maximaler Lastwiderstand.
RS232
... Du bist definitiv ein Geek
Zuletzt bearbeitet:
Hatte ich schon seit längerem vor. Jetzt hab ich es einfach mal auf den Tisch geholt, auch weil ich meine Embedded-Programmiererfahrungen nicht weiter einrosten lassen wollte.Seeehr hübsch, da könnte ich mich inspirieren
Beim MPX5100 sind es 0,1 mA, also auch nicht viel anders. Das Datenblatt empfiehlt einen Stützkondensator von 470 pF am Ausgang. Die S&H-Stufe des ATMega 128 wird mit ca. 14 pF angegeben.
Müsste eigentlich ausreichen. Wird die nächsten Tage messtechnisch überprüft. Das einzige, das ich noch nicht sicher weiß ist, wie viel Zeit ich zwischen der Umschaltung des ADC-Kanals und dem Start der nächsten AD-Wandlung wirklich brauche. Aber auch das sollte heraus zu bekommen sein...
Gut, dass du (noch) nicht weißt, dass ich mehrere serielle Protokollanalysatoren besitze... (HP 4951A sowie eine "Laptop-Lösung" mit eine Dual-Port-PCMCIA-Karte und Y-Kabel.)
Aber für den Fall "USB-only" liegen in der entsprechenden Box auch mehrere kleine Boards mit FT232.
Viele Grüße
Stefan
Beim Arduino (also ATmega328P statt "Deinem" 128) sagt die Arduino Reference "It takes about 0.1 ms to read an analog input".
Gemessen habe ich - ohne jede Optimierung - 120 us pro Messung. [Blödsinn gelöscht, ich sollte nicht so kurz vor dem Mittagessen posten
]Wenn Du den Test machst, dann häng die beiden Analogeingänge under Test an stark unterschiedliche Spannungen, aber aben nicht an die Versorgungsspannung, sondern in einen mittelohmigen Spannungsteiler:
/*
ADCcrosstalk - analyse ADC cross-talk during channel switching.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation, provided that the copyright notice remains
intact even in future versions. See the file LICENSE for details.
If you use this program (or any part of it) in another application,
note that the resulting application becomes also GPL. In other words,
GPL is a "contaminating" license.
This program is distributed in the hope that it will be useful,but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
--------------------------------------------------------------------
Modification/history:
2016-07-22, first operational version (JHa)
2016-07-23, better data structures, better loop, no more printing in loop (JHa)
*/
#include "QuickStats.h"
const int NCHAN = 2;
const int NSAMP = 10; // <80 otherwise you'll have memory problems
const char do_plot = 1 ;
void setup() {
pinMode(A0, INPUT);
pinMode(A1, INPUT);
Serial.begin(115200);
Serial.print("Init, N=");
Serial.println(NSAMP);
}
/*
Read two analog inputs, print the result to the serial monitor.
Note: feed the two inputs with very different (!) voltages
(NOT equal to the Arduino supply rails)
*/
void loop() {
int dly[] = { 0, 5, 10, 25 };
int wait[] = { 0, 5, 10, 25 };
int ndly = sizeof(dly) / sizeof(dly[0]);
int nwait = sizeof(wait) / sizeof(wait[0]);
int i, j;
for (j = 0; j < nwait; j++)
for (i = 0; i < ndly; i++)
run_test (dly, wait[j]);
Serial.println("\n========== End of loop ==========\n\n");
}
void run_test (int dly, int wait) {
float ch[NCHAN][NSAMP]; // arrays to hold data points. We use float for the stat library
QuickStats stat[NCHAN];
int i;
String s = "";
s = String("\n# N=" + String(NSAMP, DEC) + ", " + String(wait, DEC) + " ms before, " + String(dly, DEC) + " ms between channels");
Serial.println(s);
for (i = 0; i < NSAMP; i++) {
if (wait) // time to settle
delay(wait);
ch[0] = analogRead(A0);
if (dly) // time between channels
delay(dly);
ch[1] = analogRead(A1);
}
/* only print *after* the loop, since all printing *in* the loop
will slow down data acquisition and falsify results
*/
if (do_plot) { // print only if data are desired
for (i = 0; i < NSAMP; i++) {
Serial.print(i);
Serial.print("\t");
Serial.print(ch[0]);
Serial.print("\t");
Serial.println(ch[1]);
}
}
if (do_plot) {
/* show statistics */
Serial.print("Avg (StdDev): ");
for (i = 0; i < NCHAN; i++)
{
Serial.print(stat.average(ch, NSAMP));
Serial.print(" (");
Serial.print(stat.stdev(ch, NSAMP));
Serial.print(")\t");
}
Serial.print("\nMin/Max: ");
for (i = 0; i < NCHAN; i++)
{
Serial.print(stat.minimum(ch, NSAMP));
Serial.print("/");
Serial.print(stat.maximum(ch, NSAMP));
Serial.print("\t");
}
Serial.print("\nMode: ");
for (i = 0; i < NCHAN; i++)
{
Serial.print(stat.mode(ch, NSAMP));
Serial.print("\t");
}
}
Serial.println("");
}
Zuletzt bearbeitet:
Hallo Jörg,
1 kHz Sampletakt bedeutet 1 ms zwischen den Messungen. Ich rechne mal zusätzliche 30 µs Setup-Zeit nach dem ADC-Kanalwechsel ein.
Es beginnt bei der "vollen ms":
Kanal 0 startet bei +0 µs
Kanal 0 fertig bei +150 µs
Kanal 1 startet bei +150 µs
Kanal 1 fertig bei +300 µs
Kanal 2 startet bei +300 µs
Kanal 2 fertig bei +450 µs
Kanal 3 startet bei +450 µs
Kanal 3 fertig bei +600 µs
Ruhepause von 400 µs bis zur nächsten "Sample-Kette". Dann geht es im gleichen Zeitraster wieder los.
Ergebnis: Die Samplefrequenz je Kanal beträgt für alle Kanäle 1 kHz, der "Sampletakt" der einzelnen Kanäle ist aber phasenverschoben (müsste für die Anwendung "Synchrontester) nichts ausmachen.
Ansonsten hab ich auch MPX 6115 hier. Die sind von den Kennwerten her etwas besser (z.B. etwas mehr Ausgangsstrom), haben aber das "unschönere" Gehäuse (SSOP-8, nur über Pins befestigt, ganz kurzer Schlauchstutzen). Da müsste ich den Anschluss "nach außen" mechanisch anders gestalten. (Kurzes Stück flexibler Schlauch und am Gehäuse befestigte Schlauchkupplung, denke ich.)
Viele Grüße
Stefan
Das erwarte ich auch. Bei 125 kHz ADC-Takt (16 MHz Oszillatortakt und Prescaler 128) ergibt das nach Datenblatt ca. 120 µs.
Rechnen wir unterschiedlich?
1 kHz Sampletakt bedeutet 1 ms zwischen den Messungen. Ich rechne mal zusätzliche 30 µs Setup-Zeit nach dem ADC-Kanalwechsel ein.
Es beginnt bei der "vollen ms":
Kanal 0 startet bei +0 µs
Kanal 0 fertig bei +150 µs
Kanal 1 startet bei +150 µs
Kanal 1 fertig bei +300 µs
Kanal 2 startet bei +300 µs
Kanal 2 fertig bei +450 µs
Kanal 3 startet bei +450 µs
Kanal 3 fertig bei +600 µs
Ruhepause von 400 µs bis zur nächsten "Sample-Kette". Dann geht es im gleichen Zeitraster wieder los.
Ergebnis: Die Samplefrequenz je Kanal beträgt für alle Kanäle 1 kHz, der "Sampletakt" der einzelnen Kanäle ist aber phasenverschoben (müsste für die Anwendung "Synchrontester) nichts ausmachen.
Klar. Überschlägig gerechnet sollte ein 47k-Poti ganz gut passen.
Ansonsten hab ich auch MPX 6115 hier. Die sind von den Kennwerten her etwas besser (z.B. etwas mehr Ausgangsstrom), haben aber das "unschönere" Gehäuse (SSOP-8, nur über Pins befestigt, ganz kurzer Schlauchstutzen). Da müsste ich den Anschluss "nach außen" mechanisch anders gestalten. (Kurzes Stück flexibler Schlauch und am Gehäuse befestigte Schlauchkupplung, denke ich.)
Viele Grüße
Stefan
Hei Stefan,
Mahlzeit
Nein. Du hast vollkommen recht ... und ich sollte nicht so kurz vor dem Mittagsessen noch mit Mikrosekunden herumspielen
Yep, das ist gut für die automatische Serienfertigung mit dem Bestückungsroboter aber grausam in der Handhabung:
Mahlzeit
