2 Sensoren auf einem Arduino

Hallo einmal an alle ich bin neu hier da ich mit meinem wissen am ende bin...
Ich habe einen Arduino und 2 Differenzdrucksensoren daran angeschlossen.

Mein Problem besteht darin das der eine Sensor permanent 100Bit zuviel anzeigt (von 1024 falls das wichtig ist) Also hat er selbst wenn keine Strömung anliegt eine Druckdifferenz von 50Pa. Jetzt will ich nicht gleich sagen blöder Sensor schon kaputt.
Kann es vllt. sein das man beim Arduino mit mehreren auszulesenen Objekten Wiederstände oder ähnliches dazwischen schalten muss?

Beste Grüße Twinky

Wie hast Du die Sensoren angeschlossen?

Und welche Sensoren sind das?

Vielen Dank erst einmal für die schnellen Antworten!!

Die Sensoren werden beide vom Arduino versorgt sprich von den 5V, Sie laufen auch beide auf GND zurück Und dann haben die Sensoren auch jeweils ihren Datenplatz der eine auf A0 und der andere auf A1 Das ganze ist mit kleinen kabeln verbunden.
Ich hoffe das war die richtige Antwort zu dem verbinden?!

Bei den Sonsoren handelt es sich um Sensoren von Sensortechnics die einem den Über bzw auch Unterdruck angeben. genaue bezeichnun ist LBS500B bzw der andere 2te der den fehler aufweißt LBS500U

B steht für Bidirektional also von -500 bis +500 jeweils Pa
U steht für Unidirektional also von 0-500 jeweils Pa

Sollten meine Antworten nicht das gelbe vom Ei sein bitte ich das zu entschuldigen ich könnte evtl anbieten von den angeschlossenen sensoren mit dem Arduino ein Bild zu mache und hochladen. Falls es helfen sollte. Sonst versuche ich natürlich so weit eure geduld das zulässt alle fragen dazu zu beantworten!

Grüße Twinky

Hallo,
ein Bild sagt meistens mehr als 1000 Worte, aber hier wäre auch der Code interessant.
Vielleicht kannste den mit einem Bild/Link des Sensors posten.

Du bist aber wirklich geizig mit Informationen!

Die Beschreibung deiner Schaltung klingt erstmal richtig, aber sicher kann man das erst sagen, wenn es Bilder gibt

Deine beiden Sensoren haben also unterschiedliche Messbereiche.
Der eine löst 1000Pa in 4V auf (-500 - +500), der andere 500Pa auf 4V.
Du schreibst, der eine hätte 100bit "zuviel".
Welcher Sensor gibt welchen Wert aus?
Wie wird das berechnet? (CODE!!!)
Sind die Sensoren verbaut?

usw.

gibt uns mal mehr Informationen.
Anwendungszweck, Aufbau, Bilder davon , und, vor allem: deinen CODE!

Tur mir leid das mit den Infos das ist nicht gewollt ich weiß nur leider nicht ganz genau welche Daten extrem wichtig sind! Also jetzt kommt erst mal das Bild. Dazu muss ich sagen da ich gerade leider keine Kamera dabei habe. Das der abgebildete Sensor der B Sensor ist also -500----+500 allerdings habe ich nicht mit dem, sondern dem anderen dem U Sensor 0-500 das Problem. Aufbau ist aber 1 zu 1 der selbe.

Wenn es nur darum geht, dass einer der Sensoren STÄNDIG niedrigere/höhere Werte anzeigt kannst Du einen von beiden mit einer Art TARA-Wert anpassen (oder Kalibrierungswert).
D.h., Du ziehst vom Ergebnis z.B. 500 ab um beide anzugleichen wenn sie beide exakt an der derselben Position sind.

Habe ich z.B. mit 2 DHT11-Sensoren gemacht, da wich der Luftdruck auch um einige Hundert ab - waren immer derselbe Wert :slight_smile:

Sind auf dem Board BEIDE an demselben Pin angeschlossen ? Das wäre ein Bus....

Das Nötigste zuerst: Code zeigen :stuck_out_tongue:

Tur mir leid das mit den Infos das ist nicht gewollt ich weiß nur leider nicht ganz genau welche Daten extrem wichtig sind!

Nur die Ruhe, kein Problem - bisher ist nur die Kappe vom Zielfernrohr abgenommen :grin:

So und nun gleich noch den Code. Also geschrieben mit MATLAB aber ich hoffe das sollte nicht so schlimm sein.

%% Positionierung
% Achsenbezeichnung (Rotationsachse: 2)
achse = 2;
% Richtung vorgeben
richtung = 0;
% Schrittzahl
schritte = 32 * (messbereich_rot / 2);
% Anzahl der Durchläufe der for-Schleife
schleifenzahl_rot = messbereich_rot/schrittweite_rot;
%% Hauptschleife
% Vorbelegung
% Zeilenvektor vorbelegen
av_m_1 = zeros(1,schleifenzahl_rot+1);
av_m_2 = zeros(1,schleifenzahl_rot+1);
av_1 = zeros(1,n_messungen);
av_2 = zeros(1,n_messungen);
% av_3 = zeros(1,schleifenzahl_rot+1);
U_1 = zeros(1,n_messungen);
U_2 = zeros(1,n_messungen);
U_m_1 = zeros(1,schleifenzahl_rot+1);
U_m_2 = zeros(1,schleifenzahl_rot+1);
% U_3 = zeros(1,schleifenzahl_rot+1);
p_1 = zeros(1,schleifenzahl_rot+1);
p_2 = zeros(1,schleifenzahl_rot+1);
% p_3 = zeros(1,schleifenzahl_rot+1);

% Schalter für Initialisierung
init_status = 0;

% Nutzereingabe
disp('SCHLAUCHANSCHLUSS PRÜFEN!!!')
wahl = input('Messfahrt starten? [j/n]','s');
if strcmp(wahl, 'j') == 1
% Rotation zur Startposition
disp('Sonde wird positioniert.')
motor(dio,achse,richtung,schritte)
% von nun an sind Takt- und Richtungspins festgelegt und brauchen nicht
% erneut initialisiert werden
init_status = 1;
% Abfrage aktueller Winkel
winkel_aktuell = messbereich_rot/2;
% Ausgabe aktueller Winkel
disp('aktueller Winkel in °: ')
disp(winkel_aktuell)
disp('Messfahrt wird gestartet')
for i = 1:n_messungen
% Auslesen der Analogen Inputs 0..2
av_1(i)= com_arduino.analogRead(0);
av_2(i)= com_arduino.analogRead(1);
% av_3(i)= com_arduino.analogRead(2);
% Umwandeln in Spannungswerte
% Unidirektional
U_1(i) = 0.5 + av_1(i)/1024 * 4;
% Bidirektional
U_2(i) = 0.5 + av_2(i)/1024 * 4;
% U_3(i) = 0.5 + av_3(i)/1024 * 4;
end

% Mittelwerte bilden
av_m_1(1) = mean(av_1);
av_m_2(1) = mean(av_2);
U_m_1(1) = mean(U_1);
U_m_2(1) = mean(U_2);
% U_m_3 = mean(U_3);

% Umrechnung in Drücke (ACHTUNG: SENSORMESSBEREICH ANPASSEN!)
% Unidirektional
p_1(1) = (U_m_1(1) - 0.5)/4 * 500;
% Bidirektional
p_2(1) = (U_m_2(1) - 2.5)/2 * 500;
% p_3(1) = (U_m_3 - 2.5)/2 * 500;

% Plot vorbereiten
figure(1)

% Messfahrt
for n = 2:(schleifenzahl_rot + 1)

% Abfrage und Ausgabe des aktuellen Winkels
winkel_aktuell = winkel_aktuell - schrittweite_rot;
disp(winkel_aktuell)
disp('Messfahrt')
% Richtung umkehren
richtung = 1;
% Schrittzahl bestimmen
schritte = 32 * schrittweite_rot;
motor(dio,achse,richtung,schritte)
pause(0.5)
% Messung
for i = 1:n_messungen
% Auslesen der Analogen Inputs 0..2
av_1(i)= com_arduino.analogRead(0);
av_2(i)= com_arduino.analogRead(1);
% av_3(i)= com_arduino.analogRead(2);
% Umwandeln in Spannungswerte
% Undidirektional
U_1(i) = 0.5 + av_1(i)/1024 * 4;
% Bidirektional
U_2(i) = 0.5 + av_2(i)/1024 * 4;
% U_3(i) = 0.5 + av_3(i)/1024 * 4;
end

% Mittelwerte bilden
av_m_1(n) = mean(av_1);
av_m_2(n) = mean(av_2);
U_m_1(n) = mean(U_1);
U_m_2(n) = mean(U_2);
% U_m_3 = mean(U_3);

% Umrechnung in Drücke (ACHTUNG: SENSORMESSBEREICH ANPASSEN!)
% Unidirektional
p_1(n) = (U_m_1(n) - 0.5)/4 * 500;
% Bidirrektional
p_2(n) = (U_m_2(n) - 2.5)/2 * 500;
% p_3(n) = (U_m_3 - 2.5)/2 * 500;

Du hast über dem Editor-Fenster ein Symbol mit der RAUTE (#): dort kannst Du Code einfügen, der dann schön schwarz auf weiss zu lesen ist :slight_smile:

Also geschrieben mit MATLAB aber ich hoffe das sollte nicht so schlimm sein

Schau'n wa mal ...

Höhö man lernt eben doch nie aus :smiley:
Danke für den Tip

Aber @ A.R.Ty du hattest eben so etwas schönes geschrieben du hattest auch nur ganz einfach mal das Problem das der eine Sensor immer wieder den exakten wert zuviel hatte. Habe das eben mal mit drei verschieden gebläsestufen durchexerziert und naja jedes mal wieder die 50 Pa oder auch 100 Bit zuviel. Vllt war es ja doch wirklich so einfach. Aufjeden fall schon einmal ein riesen Danke dafür!

%% Positionierung
% Achsenbezeichnung (Rotationsachse: 2)
achse = 2;
% Richtung vorgeben
richtung = 0;
% Schrittzahl
schritte = 32 * (messbereich_rot / 2);
% Anzahl der Durchläufe der for-Schleife
schleifenzahl_rot = messbereich_rot/schrittweite_rot;
%% Hauptschleife
% Vorbelegung
% Zeilenvektor vorbelegen
av_m_1 = zeros(1,schleifenzahl_rot+1);
av_m_2 = zeros(1,schleifenzahl_rot+1);
av_1 = zeros(1,n_messungen);
av_2 = zeros(1,n_messungen);
% av_3 = zeros(1,schleifenzahl_rot+1);
U_1 = zeros(1,n_messungen);
U_2 = zeros(1,n_messungen);
U_m_1 = zeros(1,schleifenzahl_rot+1);
U_m_2 = zeros(1,schleifenzahl_rot+1);
% U_3 = zeros(1,schleifenzahl_rot+1);
p_1 = zeros(1,schleifenzahl_rot+1);
p_2 = zeros(1,schleifenzahl_rot+1);
% p_3 = zeros(1,schleifenzahl_rot+1);


% Schalter für Initialisierung
init_status = 0;

% Nutzereingabe
disp('SCHLAUCHANSCHLUSS PRÜFEN!!!')
wahl = input('Messfahrt starten? [j/n]','s');
if strcmp(wahl, 'j') == 1
    % Rotation zur Startposition
    disp('Sonde wird positioniert.')
    motor(dio,achse,richtung,schritte)
    % von nun an sind Takt- und Richtungspins festgelegt und brauchen nicht
    % erneut initialisiert werden
    init_status = 1;
    % Abfrage aktueller Winkel
    winkel_aktuell = messbereich_rot/2;
    % Ausgabe aktueller Winkel
    disp('aktueller Winkel in °: ')
    disp(winkel_aktuell)
    disp('Messfahrt wird gestartet')
    for i = 1:n_messungen
       % Auslesen der Analogen Inputs 0..2
        av_1(i)= com_arduino.analogRead(0);
        av_2(i)= com_arduino.analogRead(1);
        % av_3(i)= com_arduino.analogRead(2);
        % Umwandeln in Spannungswerte
        % Unidirektional
        U_1(i) = 0.5 +  av_1(i)/1024 * 4;
        % Bidirektional
        U_2(i) = 0.5 +  av_2(i)/1024 * 4; 
        % U_3(i) = 0.5 +  av_3(i)/1024 * 4; 
    end
       
    % Mittelwerte bilden
    av_m_1(1) = mean(av_1);
    av_m_2(1) = mean(av_2);
    U_m_1(1) = mean(U_1);
    U_m_2(1) = mean(U_2);
    % U_m_3 = mean(U_3);

    % Umrechnung in Drücke (ACHTUNG: SENSORMESSBEREICH ANPASSEN!)
    % Unidirektional
    p_1(1) = ((U_m_1(1) - 0.5)/4 * 500)-50;
    % Bidirektional
    p_2(1) = (U_m_2(1) - 2.5)/2 * 500;
    % p_3(1) = (U_m_3 - 2.5)/2 * 500;
    
    % Plot vorbereiten
    figure(1)
    
    % Messfahrt
        for n = 2:(schleifenzahl_rot + 1)
            
            % Abfrage und Ausgabe des aktuellen Winkels
            winkel_aktuell = winkel_aktuell - schrittweite_rot;
            disp(winkel_aktuell)
            disp('Messfahrt')
            % Richtung umkehren
            richtung = 1;
            % Schrittzahl bestimmen
            schritte = 32 * schrittweite_rot;
            motor(dio,achse,richtung,schritte)
            pause(0.5)
            % Messung
            for i = 1:n_messungen
               % Auslesen der Analogen Inputs 0..2
                av_1(i)= com_arduino.analogRead(0);
                av_2(i)= com_arduino.analogRead(1);
                % av_3(i)= com_arduino.analogRead(2);
                % Umwandeln in Spannungswerte
                % Undidirektional
                U_1(i) = 0.5 +  av_1(i)/1024 * 4;
                % Bidirektional
                U_2(i) = 0.5 +  av_2(i)/1024 * 4; 
                % U_3(i) = 0.5 +  av_3(i)/1024 * 4; 
            end

            % Mittelwerte bilden
            av_m_1(n) = mean(av_1);
            av_m_2(n) = mean(av_2);
            U_m_1(n) = mean(U_1);
            U_m_2(n) = mean(U_2);
            % U_m_3 = mean(U_3);
          

            % Umrechnung in Drücke (ACHTUNG: SENSORMESSBEREICH ANPASSEN!)
            % Unidirektional
            p_1(n) = ((U_m_1(n) - 0.5)/4 * 500)-50;
            % Bidirrektional
            p_2(n) = (U_m_2(n) - 2.5)/2 * 500;
            % p_3(n) = (U_m_3 - 2.5)/2 * 500;

Höhö man lernt eben doch nie aus

Gott sei Dank niemals - sonst wird's ja langweilig :smiley:

Wegen der Anpassung sah ich das genau so - anstatt lange Algorithmen zu coden einfach den genauest verfügbaren Mittelwert abziehen / addieren.

Wenn die schwankungen etwas ungenauer sind hilft manchmal, das Ergebniss z.B. durch 10, 100 oder 1000 (je nach Messergebniswert) zu teilen, dann fallen die "echten" Einer, Zehner oder Hunderter-Stellen der Zahlen weg.
Hängt halt viel von der gewünschten Genauigkeit ab.