INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Mehrere HX711 an einem Arduino Nano
13.09.2017, 20:17 (Dieser Beitrag wurde zuletzt bearbeitet: 13.09.2017 20:41 von Lambacher.)
Beitrag #1
Question Mehrere HX711 an einem Arduino Nano
Hi, ich sitze schon seit mehreren Tagen am folgenden Problem und habe auch schon alles mögliche gelesen und ausprobiert, aber wahrscheinlich reichen meine bisherigen Programmierkenntnisse nicht aus.

Ich möchte gerne 4x DMS-Vollbrücken an 4x HX711 an einem Arduino Nano benutzen. Meine Library habe ich von GitHub https://github.com/bogde/HX711
Momentan funktioniert mein Programm wenn ich nur einen HX711 verwende. Nach der tarrierung und skallierung habe ich sogar recht genaue Werte.

Erweitere ich allerdings mein Programm um ein zusätzliches HX711 ist der zweite Messwert trotz Tarrierung und Skallierung nicht brauchbar. Egal wie herum ich das anschließe der immer an zweiter Stelle im Programm liegende Hx711 misst nicht richtig.
Ich habe es auch schon mit einer Library von GitHub die für mehrere Hx711 ausgelegt sein soll, aber die kann ich komplett nicht nachvollziehen und ein tarrieren und skallieren ist mir leider nicht möglich.

Im folgen kommt mein Quellcode und hoffentlich kann mir einer helfen.

Code:
#include <HX711.h>                          // Bibliothek fuer HX711    

#define CLK A0                              // clock pin fuer alle HX711

#define DOUT1 A1                            // data pin fuer erster HX711
#define DOUT2 A2                            // data pin fuer zweiter HX711

HX711 scale(DOUT1, CLK);                    // Klasse fuer den ersten HX711
HX711 scale2(DOUT2, CLK);                   // Klasse fuer den ersten HX711

char Befehlseingabe;                        //Variable fuer die Befehlseingabe

long Tara;    
float Scale;

long Tara2;   //Zweiter AD-Wandler
float Scale2; //Zweiter AD-Wandler

long Gewicht = 999999;                      
long LetztesGewicht = 0;

long Gewicht2 = 999999;    //Zweiter AD-Wandler                      
long LetztesGewicht2 = 0;  //Zweiter AD-Wandler

long Gesammtgewicht;

void setup(){
  Serial.begin(115200);
  delay(1000);

  Serial.println(F("Zur Kalibrierung bitte den Anweisungen folgen!"));
  Serial.println();  
  Serial.println(F("Waage ohne Gewicht - Kalibrierung mit '1' und 'Enter' starten!"));
  Serial.println();
  while (Befehlseingabe!='1')                   //Solange keine '1' in die Zeile eingegeben und mit Enter bestaetigt wird, bleibt das Programm an dieser Stelle
    {
      Befehlseingabe = Serial.read();
    }    
  Befehlseingabe='x';
  
  Serial.println(F("Kalibriere ... "));
  Serial.println();
  
  scale.set_scale();
  scale.read_average(10);
  Tara = scale.read_average(10);

  delay(1000);
  
  scale2.set_scale();               //Zweiter AD-Wandler
  scale2.read_average(10);          //Zweiter AD-Wandler
  Tara2 = scale.read_average(10);   //Zweiter AD-Wandler
  
  Serial.println(F("Waage mit genau 1 Kg beschweren - Kalibrierung mit '2' und 'Enter' starten!"));
  Serial.println();
  
  while (Befehlseingabe!='2')
    {
      Befehlseingabe = Serial.read();
    }
  
  Serial.println(F("Kalibriere ... "));
  Serial.println();
  
  scale.set_offset(Tara);
  scale.get_units(10);
  Scale = ((scale.get_units(10))/1000);   // Durch 1000 wegen 1kg Pruefgewicht
  scale.set_scale(Scale);

  scale2.set_offset(Tara2);               //Zweiter AD-Wandler
  scale2.get_units(10);                   //Zweiter AD-Wandler  
  Scale2 = ((scale2.get_units(10))/1000); //Zweiter AD-Wandler.Durch 1000 wegen 1kg Pruefgewicht
  scale2.set_scale(Scale2);               //Zweiter AD-Wandler

  Serial.println(scale.get_units(10));
  Serial.println(scale2.get_units(10));
  Serial.println();
    
  Serial.print(F("Pruefe Gewicht: "));
  Serial.println(scale.get_units(10), 1);
  Serial.print(F("Pruefe Gewicht2: "));
  Serial.println(scale2.get_units(10), 1);  //Zweiter AD-Wandler
  Serial.println();
  Serial.print(F("Taragewicht: "));
  Serial.println(Tara);
  Serial.println(Tara2);                    //Zweiter AD-Wandler            
  Serial.println();
  Serial.print(F("Skalierung: "));
  Serial.println(Scale);
  Serial.println(Scale2);                   //Zweiter AD-Wandler
  Serial.println();

  Serial.println(F("Wiegen - mit '3' und 'Enter' starten!"));
  Serial.println();
  while (Befehlseingabe!='3') {Befehlseingabe = Serial.read();};
  Serial.println(F("Warte... "));
  Serial.println();



long Taragewicht = Tara;    // Hier wird der Wert aus der Kalibrierung automatisch eingetragen
float Skalierung = Scale;   // Hier wird der Wert aus der Kalibrierung automatisch eingetragen

long Taragewicht2 = Tara2;    // Zweiter AD-Wandler
float Skalierung2 = Scale2;   // Zweiter AD-Wandler


  
    scale.set_offset(Taragewicht);  
    scale.set_scale(Skalierung);
    scale2.set_offset(Taragewicht2); //Zweiter AD-Wandler  
    scale2.set_scale(Skalierung2);   //Zweiter AD-Wandler


}
void loop() {
  
  
    delay(500);
    Gewicht= scale.get_units(1);
    
    Gewicht2= scale2.get_units(); //Zweiter AD-Wandler
  
    delay(500);
    Gesammtgewicht=Gewicht+Gewicht2;

    
    Serial.print("Gewicht: " );
    Serial.print(Gewicht);      //Ausgabe erster AD-Wandler
    Serial.print("  ");
  
    Serial.print(Gewicht2);     //Ausgabe zweiter AD-Wandler
    Serial.print("  ");
    Serial.print("Mittelwert:  ");
    Serial.print(Gesammtgewicht/2); //Ausgabe Mittelwert
    Serial.println(" g");
  
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
13.09.2017, 20:29
Beitrag #2
RE: Mehrere HX711 an einem Arduino Nano
Die Lib habe ich von Github idt eine Nullaussage. Dort gibt es viele Libs.

Es ist besser, Du gibst den Link zur Lib mit an, dann haben alle Beteiligten die gleiche Information.

Ohne den Sketch komplett zu checken, bin ich der Meinung, Du hast einen Copy&Paste-Fehler drin:

Code:
Tara2 = scale.read_average(10);
// das sollte wohl eher heißen: Tara2 = scale2.read_average(10);
Ich kenne diese HX711 nicht, kann also nur allgemein mitreden.

Wenn Die Grundfunktion mit 2 Wägezellen funktioniert, würde ich Dir eine Umorganisation zur Erhöhung der Übersichtlichkeit empfehlen. Beschäftige Dich mal mit struct und Arrays aus diesen.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
13.09.2017, 20:49
Beitrag #3
RE: Mehrere HX711 an einem Arduino Nano
(13.09.2017 20:29)Tommy56 schrieb:  Die Lib habe ich von Github idt eine Nullaussage. Dort gibt es viele Libs.

Es ist besser, Du gibst den Link zur Lib mit an, dann haben alle Beteiligten die gleiche Information.

Ohne den Sketch komplett zu checken, bin ich der Meinung, Du hast einen Copy&Paste-Fehler drin:

Code:
Tara2 = scale.read_average(10);
// das sollte wohl eher heißen: Tara2 = scale2.read_average(10);
Ich kenne diese HX711 nicht, kann also nur allgemein mitreden.

Wenn Die Grundfunktion mit 2 Wägezellen funktioniert, würde ich Dir eine Umorganisation zur Erhöhung der Übersichtlichkeit empfehlen. Beschäftige Dich mal mit struct und Arrays aus diesen.

Gruß Tommy

Vielen Dank für die Hilfe. Diesen Fehler habe ich echt einfach übersehen Dodgy
Struct und Arrays sagt mir im entferntesten Sinne noch was, werde ich mir mal anschauen wenn ich alle 4 am laufen habe und ich es dann nur noch in schön haben will.

Eine Verständnisfrage habe ich doch noch:
Der HX711 ist ja ein AD-Wandler, wieso ist es am Arduino möglich diesen ohne weitere Probleme an den analog Eingängen anzuschließen ? Habe mir natürlich das Datenblatt zum Bauteil schon angeschaut und bin da nicht viel schlauer geworden. Wenn ich das richtig verstanden habe, wird die Zeit von der steigenden und fallenden Flanke gemessen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
13.09.2017, 20:56
Beitrag #4
RE: Mehrere HX711 an einem Arduino Nano
(13.09.2017 20:49)Lambacher schrieb:  Vielen Dank für die Hilfe. Diesen Fehler habe ich echt einfach übersehen Dodgy
Struct und Arrays sagt mir im entferntesten Sinne noch was, werde ich mir mal anschauen wenn ich alle 4 am laufen habe und ich es dann nur noch in schön haben will.

Eine Verständnisfrage habe ich doch noch:
Der HX711 ist ja ein AD-Wandler, wieso ist es am Arduino möglich diesen ohne weitere Probleme an den analog Eingängen anzuschließen ? Habe mir natürlich das Datenblatt zum Bauteil schon angeschaut und bin da nicht viel schlauer geworden. Wenn ich das richtig verstanden habe, wird die Zeit von der steigenden und fallenden Flanke gemessen.
Die analogen Eingänge sind gleichzeitig auch digitale Eingänge. Die Funktion analogRead ist bei denen zusätzlich vorhanden.

Ich würde nicht erst 4 Zellen aufbauen und es dann umbauen, sondern gleich, wenn es mit 2 Zellen funktioniert. Da sparst Du Dir einiges an Arbeit und es ist bei 2 Zellen übersichtlicher.
Das ist aber nur eine Empfehlung aus der Erfahrung heraus.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.09.2017, 09:26 (Dieser Beitrag wurde zuletzt bearbeitet: 15.09.2017 09:31 von Lambacher.)
Beitrag #5
RE: Mehrere HX711 an einem Arduino Nano
Hier ist nun der aktualisierte Quelltext und hoffe nun etwas übersichtlicher. Der Code wurde schon auf die kommenden 4xhx711 aber noch nicht getestet.
Da im Quelltext die Kalibrierung und Messung zusammen sind, ist es möglich die Kalibrierungswerte fest zu speichern, damit beim Stromausfall die Werte nicht verloren gehen oder müsste ich 2 seperate Programme haben?
Die interne EEPROM möchte ich dafür nicht verwenden, da die Messung über eine längere Zeit laufen könnte und die häufigkeit der Speichervorgänge begrenzt ist.
Ich habe hier noch einen DS3231 und ESP8266 rumliegen, könnte man die vllt. zum speichern benutzen?

Für weitere anregungen im Quelltext wäre ich dankbar
Code:
#include <HX711.h>                               // Bibliothek fuer HX711    

#define CLK A0                                   // clock pin fuer alle HX711
#define DOUT1 A1                                 // data pin fuer ersten HX711
#define DOUT2 A2                                 // data pin fuer zweiten HX711
//#define DOUT3 A3                               // data pin fuer dritten HX711
//#define DOUT4 A4                               // data pin fuer vierten HX711


HX711 hx711ErsteMessbruecke(DOUT1, CLK);         // Klasse fuer den ersten HX711
HX711 hx711ZweiteMessbruecke(DOUT2, CLK);        // Klasse fuer den zweiten HX711
//HX711 hx711DritteMessbruecke(DOUT3, CLK);      // Klasse fuer den dritten HX711
//HX711 hx711VierteMessbruecke(DOUT4, CLK);      // Klasse fuer den vierten HX711

char Befehlseingabe;                             // Variable fuer die Befehlseingabe
float Gesamtgewicht;                             // Variable fuer das Gesamtgewicht in float fuer Kommastellenausgabe

typedef struct                                   // Klasse Messung erstellt um Variablen uebersichtlicher zu haben
  {
    long Tara;
    long Taragewicht;
    long Skalierung;
    float Gewicht= 999999.0;
    long LetztesGewicht= 0;
    float Scale;
  }Messung;


Messung ErsteMessbruecke;                       // Variable der Klasse Messung für die jeweiligen Messbruecken
Messung ZweiteMessbruecke;
//Messung DritteMessbruecke;
//Messung VierteMessbruecke;

void setup(){
  Serial.begin(115200);
  delay(1000);  
  
  Serial.println(F("Zur Kalibrierung bitte den Anweisungen folgen!"));
  Serial.println();  
  Serial.println(F("Waage ohne Gewicht - Kalibrierung mit '1' und 'Enter' starten!"));
  Serial.println();
  
  while (Befehlseingabe!='1')                   //Solange keine '1' in die Zeile eingegeben und mit Enter bestaetigt wird, bleibt das Programm an dieser Stelle
    {
      Befehlseingabe = Serial.read();
    }    
  Befehlseingabe='x';
  
  Serial.println(F("Kalibriere ... "));
  Serial.println();
  
  hx711ErsteMessbruecke.set_scale();                                  //Erste AD-Wandler
  hx711ErsteMessbruecke.read_average(10);                             //Erste AD-Wandler
  ErsteMessbruecke.Tara = hx711ErsteMessbruecke.read_average(10);     //Erste AD-Wandler

  delay(1000);
  
  hx711ZweiteMessbruecke.set_scale();                                 //Zweiter AD-Wandler
  hx711ZweiteMessbruecke.read_average(10);                            //Zweiter AD-Wandler
  ZweiteMessbruecke.Tara = hx711ZweiteMessbruecke.read_average(10);   //Zweiter AD-Wandler
  
/*                            VORBEREITUNG FUER 4x hx711
*                            
  delay(1000);
  
  hx711DritteMessbruecke.set_scale();                                 //Dritter AD-Wandler
  hx711DritteMessbruecke.read_average(10);                            //Dritter AD-Wandler
  DritteMessbruecke.Tara = hx711DritteMessbruecke.read_average(10);   //Dritter AD-Wandler
  
  delay(1000);

  hx711VierteMessbruecke.set_scale();                                 //Vierter AD-Wandler
  hx711VierteMessbruecke.read_average(10);                            //Vierter AD-Wandler
  VierteMessbruecke.Tara = hx711VierteMessbruecke.read_average(10);   //Vierter AD-Wandler

*/  
  Serial.println(F("Waage mit genau 1 Kg beschweren - Kalibrierung mit '2' und 'Enter' starten!"));
  Serial.println();
  
  while (Befehlseingabe!='2')
    {
      Befehlseingabe = Serial.read();
    }
  
  Serial.println(F("Kalibriere ... "));
  Serial.println();
  
  hx711ErsteMessbruecke.set_offset(ErsteMessbruecke.Tara);
  hx711ErsteMessbruecke.get_units(10);
  ErsteMessbruecke.Scale = ((hx711ErsteMessbruecke.get_units(10))/1000);   // Durch 1000 wegen 1kg Pruefgewicht
  hx711ErsteMessbruecke.set_scale(ErsteMessbruecke.Scale);

  hx711ZweiteMessbruecke.set_offset(ZweiteMessbruecke.Tara);               //Zweiter AD-Wandler
  hx711ZweiteMessbruecke.get_units(10);                                    //Zweiter AD-Wandler  
  ZweiteMessbruecke.Scale = ((hx711ZweiteMessbruecke.get_units(10))/1000); //Zweiter AD-Wandler.Durch 1000 wegen 1kg Pruefgewicht
  hx711ZweiteMessbruecke.set_scale(ZweiteMessbruecke.Scale);               //Zweiter AD-Wandler

/*                            VORBEREITUNG FUER 4x hx711
*                            

  hx711DritteMessbruecke.set_offset(DritteMessbruecke.Tara);
  hx711DritteMessbruecke.get_units(10);
  DritteMessbruecke.Scale = ((hx711DritteMessbruecke.get_units(10))/1000);   // Durch 1000 wegen 1kg Pruefgewicht
  hx711DritteMessbruecke.set_scale(DritteMessbruecke.Scale);

  hx711VierteMessbruecke.set_offset(VierteMessbruecke.Tara);
  hx711VierteMessbruecke.get_units(10);
  VierteMessbruecke.Scale = ((hx711VierteMessbruecke.get_units(10))/1000);   // Durch 1000 wegen 1kg Pruefgewicht
  hx711VierteMessbruecke.set_scale(VierteMessbruecke.Scale);
  
*/
  Serial.println(hx711ErsteMessbruecke.get_units(10));
  Serial.println(hx711ZweiteMessbruecke.get_units(10));

/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.println(hx711DritteMessbruecke.get_units(10));
  Serial.println(hx711VierteMessbruecke.get_units(10));
  
*/  
  Serial.println();
    
  Serial.print(F("Pruefe Gewicht Erste Messbruecke: "));
  Serial.println(hx711ErsteMessbruecke.get_units(10), 1);
  Serial.print(F("Pruefe Gewicht Zweite Messbruecke: "));
  Serial.println(hx711ZweiteMessbruecke.get_units(10), 1);  //Zweiter AD-Wandler
  
/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.print(F("Pruefe Gewicht Dritte Messbruecke: "));
  Serial.println(hx711DritteMessbruecke.get_units(10), 1);  //Zweiter AD-Wandler
  Serial.print(F("Pruefe Gewicht Vierte Messbruecke: "));
  Serial.println(hx711VierteMessbruecke.get_units(10), 1);  //Zweiter AD-Wandler

*/
  
  Serial.println();
  Serial.print(F("Taragewicht: "));
  Serial.println(ErsteMessbruecke.Tara);
  Serial.println(ZweiteMessbruecke.Tara);                    //Zweiter AD-Wandler  
  
/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.println(ErsteMessbruecke.Tara);
  Serial.println(ZweiteMessbruecke.Tara);                    //Zweiter AD-Wandler  
  
*/
  
  Serial.println();
  Serial.print(F("Skalierung: "));
  Serial.println(ErsteMessbruecke.Scale);
  Serial.println(ZweiteMessbruecke.Scale);                   //Zweiter AD-Wandler

/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.println(DritteMessbruecke.Scale);
  Serial.println(VierteMessbruecke.Scale);
  
*/  

  Serial.println();
  Serial.println(F("Wiegen - mit '3' und 'Enter' starten!"));
  Serial.println();
  while (Befehlseingabe!='3')
    {
      Befehlseingabe = Serial.read();
    }
  Serial.println(F("Warte... "));
  Serial.println();

  ErsteMessbruecke.Taragewicht= ErsteMessbruecke.Tara;
  ErsteMessbruecke.Skalierung= ErsteMessbruecke.Scale;

  ZweiteMessbruecke.Taragewicht= ZweiteMessbruecke.Tara;
  ZweiteMessbruecke.Skalierung= ZweiteMessbruecke.Scale;

/*                            VORBEREITUNG FUER 4x hx711
*                            

  DritteMessbruecke.Taragewicht= DritteMessbruecke.Tara;
  DritteMessbruecke.Skalierung= DritteMessbruecke.Scale;

  VierteMessbruecke.Taragewicht= VierteMessbruecke.Tara;
  VierteMessbruecke.Skalierung= VierteMessbruecke.Scale;

*/

  hx711ErsteMessbruecke.set_offset(ErsteMessbruecke.Taragewicht);  
  hx711ErsteMessbruecke.set_scale(ErsteMessbruecke.Skalierung);
  hx711ZweiteMessbruecke.set_offset(ZweiteMessbruecke.Taragewicht); //Zweiter AD-Wandler  
  hx711ZweiteMessbruecke.set_scale(ZweiteMessbruecke.Skalierung);   //Zweiter AD-Wandler

/*                            VORBEREITUNG FUER 4x hx711
*                            

  hx711DritteMessbruecke.set_offset(DritteMessbruecke.Taragewicht);  
  hx711DritteMessbruecke.set_scale(DritteMessbruecke.Skalierung);

  hx711VierteMessbruecke.set_offset(VierteMessbruecke.Taragewicht);  
  hx711VierteMessbruecke.set_scale(VierteMessbruecke.Skalierung);

  */
}

void loop() {  
    delay(500);
    ErsteMessbruecke.Gewicht= hx711ErsteMessbruecke.get_units();
    
    ZweiteMessbruecke.Gewicht= hx711ZweiteMessbruecke.get_units(); //Zweiter AD-Wandler
    
/*                            VORBEREITUNG FUER 4x hx711
*                            

    DritteMessbruecke.Gewicht= hx711DritteMessbruecke.get_units();
    VierteMessbruecke.Gewicht= hx711VierteMessbruecke.get_units();
    
  */
  
    delay(500);
    Gesamtgewicht=ErsteMessbruecke.Gewicht+ZweiteMessbruecke.Gewicht;

  //Gesamtgewicht=ErsteMessbruecke.Gewicht+ZweiteMessbruecke.Gewicht+DritteMessbruec​ke.Gewicht+VierteMessbruecke.Gewicht; Oberes Gesamtgewicht muss durch dieses ersetzt werden
    Serial.print("Gewicht: " );
    Serial.print(ErsteMessbruecke.Gewicht);      //Ausgabe erster AD-Wandler
    Serial.print("  ");  
    Serial.print(ZweiteMessbruecke.Gewicht);     //Ausgabe zweiter AD-Wandler
    Serial.print("  ");

/*                            VORBEREITUNG FUER 4x hx711  
  *                            

    Serial.print(DritteMessbruecke.Gewicht);      //Ausgabe dritte AD-Wandler
    Serial.print("  ");
    Serial.print(VierteMessbruecke.Gewicht);      //Ausgabe vierter AD-Wandler
    
      */
      
    Serial.print("  ");
    Serial.println(" g");
    Serial.println();
    Serial.print("Mittelwert:  ");
    Serial.print(" ----> ");
    if(Gesamtgewicht>1000)
      {
         Gesamtgewicht=Gesamtgewicht/1000;
         Serial.print(Gesamtgewicht/2); //Ausgabe Mittelwert
         Serial.println(" kg");
      }
    else
    {
      Serial.print(Gesamtgewicht/2); //Ausgabe Mittelwert
    Serial.println(" g");  
    }
  
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.09.2017, 13:52
Beitrag #6
RE: Mehrere HX711 an einem Arduino Nano
Ich würde Dir ein extra Programm zum Kalibrieren vorschlagen.
Dieses kann dann die Werte im internen EEPROM ablegen. Dadurch passiert das nicht so häufig.
Zur Überprüfung, ob neu kalibriert werden muss, evtl. noch ein Programm oder eine Routine, das die Kalibrierung durchführt und mit den Werten im EEPROM vergleicht.

Das normale Messprogramm nutzt dann nur die Werte aus dem EEPROM.

Eine andere Variante wäre der EEPROM auf dem DS3231 (der sich aber auch nicht häufiger beschreiben läßt) oder ein FRAM (Thread)

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.09.2017, 14:51
Beitrag #7
RE: Mehrere HX711 an einem Arduino Nano
Ich habe noch ein wenig am Programm geschrieben und mich dazu entschlossen die Kalibrierungswerte im EEPROM zu speichern, da dies eigtl. im Betrieb nicht oft verwendet werden sollte und so der Verschleiß vernachlässigt werden kann.
Zusätzlich wurde die lib für die EEPROM von https://github.com/thijse/Arduino-EEPROMEx implementiert.

Ein paar Probleme hätte ich dennoch:
  1. Wenn ich die Kalibrierungswerte im internen Speicher schreibe gehen die Nachkommastellen trotz Variable vom Typ long verloren (long SpeicherwertTaragewicht) .
  2. Ich habe versucht am Programmanfang eine Menueabfrage zu Integrieren, in der falls im Speicher schon was steht, abgefragt werden soll, ob man direkt messen möchte oder nochmals eine Kalibrierung durchführen möchte. Im folgenden sieht man die Syntax die ich verwendet habe, aber aus dem Programm erstmal rausgelassen haben. Dabei wird werden die ganzen 'cases' einfach übersprungen und das Programm ist direkt im default
  3. Gibt es noch eine einfacher möglichkeit das Programm etwas übersichtlicher zu gestalten?


Code:
int Menueauswahl=Serial.read();
  switch(Menueauswahl)
    {
      case '1':  Serial.println(" MENUE 1 ");  
        break;  
      case '2':   Serial.println(" MENUE 2 ");  
        break;
      default: Serial.println("FEHLER");
    }

Und hier nochmal der komplette Quelltext:
Code:
#include <EEPROMex.h>                            // Bibliothek fuer internen Speicher
#include <HX711.h>                               // Bibliothek fuer HX711    

#define CLK A0                                   // clock pin fuer alle HX711
#define DOUT1 A1                                 // data pin fuer ersten HX711
#define DOUT2 A2                                 // data pin fuer zweiten HX711
//#define DOUT1 A3                               // data pin fuer dritten HX711
//#define DOUT2 A4                               // data pin fuer vierten HX711


HX711 hx711ErsteMessbruecke(DOUT1, CLK);         // Klasse fuer den ersten HX711
HX711 hx711ZweiteMessbruecke(DOUT2, CLK);        // Klasse fuer den zweiten HX711
//HX711 hx711DritteMessbruecke(DOUT3, CLK);      // Klasse fuer den dritten HX711
//HX711 hx711VierteMessbruecke(DOUT4, CLK);      // Klasse fuer den vierten HX711

int Menueauswahl;
char Befehlseingabe;                             // Variable fuer die Befehlseingabe
float Gesamtgewicht;                             // Variable fuer das Gesamtgewicht in float fuer Kommastellenausgabe

typedef struct                                   // Klasse Messung erstellt um Variablen uebersichtlicher zu haben
  {
    int SpeicheradresseTaragewicht;
    int SpeicheradresseSkalierung;
    long SpeicherwertTaragewicht;
    long SpeicherwertSkalierung;
    long Tara=0.0;
    long Taragewicht;
    long Skalierung;
    long LetztesGewicht= 0.0;
    float Gewicht= 999999.0;    
    float Scale;
  }Messung;


Messung ErsteMessbruecke;                       // Variable der Klasse Messung für die jeweiligen Messbruecken
Messung ZweiteMessbruecke;
//Messung DritteMessbruecke;
//Messung VierteMessbruecke;

void setup(){
  Serial.begin(115200);
  delay(1000);

/********************************************************************************​**************/
/****************************** Start der Kalibrierung*****************************************/
/********************************************************************************​**************/


  
  Serial.println(F("Zur Kalibrierung bitte den Anweisungen folgen!"));
  Serial.println();  
  Serial.println(F("Waage ohne Gewicht - Kalibrierung mit '1' und 'Enter' starten!"));
  Serial.println();
  
  while (Befehlseingabe!='1')                   //Solange keine '1' in die Zeile eingegeben und mit Enter bestaetigt wird, bleibt das Programm an dieser Stelle
    {
      Befehlseingabe = Serial.read();
    }    
  Befehlseingabe='x';
  
  Serial.println(F("Kalibriere ... "));
  Serial.println();
  
  hx711ErsteMessbruecke.set_scale();                                  //Erste AD-Wandler
  hx711ErsteMessbruecke.read_average(10);                             //Erste AD-Wandler
  ErsteMessbruecke.Tara = hx711ErsteMessbruecke.read_average(10);     //Erste AD-Wandler

  delay(1000);
  
  hx711ZweiteMessbruecke.set_scale();                                 //Zweiter AD-Wandler
  hx711ZweiteMessbruecke.read_average(10);                            //Zweiter AD-Wandler
  ZweiteMessbruecke.Tara = hx711ZweiteMessbruecke.read_average(10);   //Zweiter AD-Wandler
  
/*                            VORBEREITUNG FUER 4x hx711
*                            
  delay(1000);
  
  hx711DritteMessbruecke.set_scale();                                 //Dritter AD-Wandler
  hx711DritteMessbruecke.read_average(10);                            //Dritter AD-Wandler
  DritteMessbruecke.Tara = hx711DritteMessbruecke.read_average(10);   //Dritter AD-Wandler
  
  delay(1000);

  hx711VierteMessbruecke.set_scale();                                 //Vierter AD-Wandler
  hx711VierteMessbruecke.read_average(10);                            //Vierter AD-Wandler
  VierteMessbruecke.Tara = hx711VierteMessbruecke.read_average(10);   //Vierter AD-Wandler

*/  
  Serial.println(F("Waage mit genau 1 Kg beschweren - Kalibrierung mit '2' und 'Enter' starten!"));
  Serial.println();
  
  while (Befehlseingabe!='2')
    {
      Befehlseingabe = Serial.read();
    }
  
  Serial.println(F("Kalibriere ... "));
  Serial.println();
  
  hx711ErsteMessbruecke.set_offset(ErsteMessbruecke.Tara);
  hx711ErsteMessbruecke.get_units(10);
  ErsteMessbruecke.Scale = ((hx711ErsteMessbruecke.get_units(10))/1000);   // Durch 1000 wegen 1kg Pruefgewicht
  hx711ErsteMessbruecke.set_scale(ErsteMessbruecke.Scale);

  hx711ZweiteMessbruecke.set_offset(ZweiteMessbruecke.Tara);               //Zweiter AD-Wandler
  hx711ZweiteMessbruecke.get_units(10);                                    //Zweiter AD-Wandler  
  ZweiteMessbruecke.Scale = ((hx711ZweiteMessbruecke.get_units(10))/1000); //Zweiter AD-Wandler.Durch 1000 wegen 1kg Pruefgewicht
  hx711ZweiteMessbruecke.set_scale(ZweiteMessbruecke.Scale);               //Zweiter AD-Wandler

/*                            VORBEREITUNG FUER 4x hx711
*                            

  hx711DritteMessbruecke.set_offset(DritteMessbruecke.Tara);
  hx711DritteMessbruecke.get_units(10);
  DritteMessbruecke.Scale = ((hx711DritteMessbruecke.get_units(10))/1000);   // Durch 1000 wegen 1kg Pruefgewicht
  hx711DritteMessbruecke.set_scale(DritteMessbruecke.Scale);

  hx711VierteMessbruecke.set_offset(VierteMessbruecke.Tara);
  hx711VierteMessbruecke.get_units(10);
  VierteMessbruecke.Scale = ((hx711VierteMessbruecke.get_units(10))/1000);   // Durch 1000 wegen 1kg Pruefgewicht
  hx711VierteMessbruecke.set_scale(VierteMessbruecke.Scale);
  
*/
  Serial.println(hx711ErsteMessbruecke.get_units(10));
  Serial.println(hx711ZweiteMessbruecke.get_units(10));

/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.println(hx711DritteMessbruecke.get_units(10));
  Serial.println(hx711VierteMessbruecke.get_units(10));
  
*/  
  Serial.println();
    
  Serial.print(F("Pruefe Gewicht Erste Messbruecke: "));
  Serial.println(hx711ErsteMessbruecke.get_units(10), 1);
  Serial.print(F("Pruefe Gewicht Zweite Messbruecke: "));
  Serial.println(hx711ZweiteMessbruecke.get_units(10), 1);  //Zweiter AD-Wandler
  
/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.print(F("Pruefe Gewicht Dritte Messbruecke: "));
  Serial.println(hx711DritteMessbruecke.get_units(10), 1);  //Zweiter AD-Wandler
  Serial.print(F("Pruefe Gewicht Vierte Messbruecke: "));
  Serial.println(hx711VierteMessbruecke.get_units(10), 1);  //Zweiter AD-Wandler

*/
  
  Serial.println();
  Serial.print(F("Taragewicht: "));
  Serial.println(ErsteMessbruecke.Tara);
  Serial.println(ZweiteMessbruecke.Tara);                    //Zweiter AD-Wandler  
  
/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.println(ErsteMessbruecke.Tara);
  Serial.println(ZweiteMessbruecke.Tara);                    //Zweiter AD-Wandler  
  
*/
  
  Serial.println();
  Serial.print(F("Skalierung: "));
  Serial.println(ErsteMessbruecke.Scale);
  Serial.println(ZweiteMessbruecke.Scale);                   //Zweiter AD-Wandler

/*                            VORBEREITUNG FUER 4x hx711
*                            

  Serial.println(DritteMessbruecke.Scale);
  Serial.println(VierteMessbruecke.Scale);
  
*/  


  ErsteMessbruecke.Taragewicht= ErsteMessbruecke.Tara;
  ErsteMessbruecke.Skalierung= ErsteMessbruecke.Scale;

  ZweiteMessbruecke.Taragewicht= ZweiteMessbruecke.Tara;
  ZweiteMessbruecke.Skalierung= ZweiteMessbruecke.Scale;

  /* Kontrolle des Wertes vor der Speicherung im EEPROM */
  Serial.println();
  Serial.println(ErsteMessbruecke.Skalierung);
  Serial.println();Serial.println();

/********************************************************************************​**************/
/****************************** EEPROM EINBINDEN **********************************************/
/********************************************************************************​**************/
    
    EEPROM.writeLong(ErsteMessbruecke.SpeicheradresseTaragewicht,ErsteMessbruec​ke.Taragewicht);
    ErsteMessbruecke.SpeicherwertTaragewicht = EEPROM.readLong(ErsteMessbruecke.SpeicheradresseTaragewicht);
    EEPROM.writeLong(ErsteMessbruecke.SpeicheradresseSkalierung,ErsteMessbrueck​e.Skalierung);
    ErsteMessbruecke.SpeicherwertSkalierung = EEPROM.readLong(ErsteMessbruecke.SpeicheradresseSkalierung);

                                    
    EEPROM.writeLong(ZweiteMessbruecke.SpeicheradresseTaragewicht,ZweiteMessbru​ecke.Taragewicht);
    ZweiteMessbruecke.SpeicherwertTaragewicht = EEPROM.readLong(ZweiteMessbruecke.SpeicheradresseTaragewicht);      
    EEPROM.writeLong(ZweiteMessbruecke.SpeicheradresseSkalierung,ZweiteMessbrue​cke.Skalierung);
    ZweiteMessbruecke.SpeicherwertSkalierung = EEPROM.readLong(ZweiteMessbruecke.SpeicheradresseSkalierung);
      
    /*                                VORBEREITUNG FUER 4x hx711
     *
      EEPROM.writeLong(DritteMessbruecke.SpeicheradresseTaragewicht,DritteMessbru​ecke.Taragewicht);
      DritteMessbruecke.SpeicherwertTaragewicht = EEPROM.readLong(DritteMessbruecke.SpeicheradresseTaragewicht);      
      EEPROM.writeLong(DritteMessbruecke.SpeicheradresseSkalierung,DritteMessbrue​cke.Skalierung);
      DritteMessbruecke.SpeicherwertSkalierung = EEPROM.readLong(DritteMessbruecke.SpeicheradresseSkalierung);
    
      EEPROM.writeLong(VierteMessbruecke.SpeicheradresseTaragewicht,VierteMessbru​ecke.Taragewicht);
      VierteMessbruecke.SpeicherwertTaragewicht = EEPROM.readLong(VierteMessbruecke.SpeicheradresseTaragewicht);      
      EEPROM.writeLong(VierteMessbruecke.SpeicheradresseSkalierung,VierteMessbrue​cke.Skalierung);
      VierteMessbruecke.SpeicherwertSkalierung = EEPROM.readLong(VierteMessbruecke.SpeicheradresseSkalierung);
     *
     *Serial.print("ErsteMessbruecke.Speicheradresse: ");
      Serial.println(ErsteMessbruecke.SpeicheradresseTaragewicht);
      Serial.print("ErsteMessbruecke.Taragewicht: ");
      Serial.println(ErsteMessbruecke.Taragewicht);
      Serial.print("ErsteMessbruecke.SpeicherwertTaragewicht: ");
      Serial.println(ErsteMessbruecke.SpeicherwertTaragewicht);
      Serial.println("");
      
      Serial.print("ErsteMessbruecke.Speicheradresse: ");
      Serial.println(ErsteMessbruecke.SpeicheradresseTaragewicht);
      Serial.print("ErsteMessbruecke.Taragewicht: ");
      Serial.println(ErsteMessbruecke.Taragewicht);
      Serial.print("ErsteMessbruecke.SpeicherwertTaragewicht: ");
      Serial.println(ErsteMessbruecke.SpeicherwertTaragewicht);
      Serial.println("");  
     *
    */
    Serial.print("ErsteMessbruecke.Speicheradresse: ");
    Serial.println(ErsteMessbruecke.SpeicheradresseTaragewicht);
    Serial.print("ErsteMessbruecke.Taragewicht: ");
    Serial.println(ErsteMessbruecke.Taragewicht);
    Serial.print("ErsteMessbruecke.SpeicherwertTaragewicht: ");
    Serial.println(ErsteMessbruecke.SpeicherwertTaragewicht);
    Serial.println("");  
    
    Serial.print("ErsteMessbruecke.Speicheradresse: ");
    Serial.println(ErsteMessbruecke.SpeicheradresseSkalierung);
    Serial.print("ErsteMessbruecke.Skalierung: ");
    Serial.println(ErsteMessbruecke.Skalierung);
    Serial.print("ErsteMessbruecke.SpeicherwertSkalierung: ");
    Serial.println(ErsteMessbruecke.SpeicherwertSkalierung);
    Serial.println("");

    Serial.print("ZweiteMessbruecke.Speicheradresse: ");
    Serial.println(ZweiteMessbruecke.SpeicheradresseTaragewicht);
    Serial.print("ZweiteMessbruecke.Taragewicht: ");
    Serial.println(ZweiteMessbruecke.Taragewicht);
    Serial.print("ZweiteMessbruecke.SpeicherwertTaragewicht: ");
    Serial.println(ZweiteMessbruecke.SpeicherwertTaragewicht);
    Serial.println("");  
    
    Serial.print("ZweiteMessbruecke.Speicheradresse: ");
    Serial.println(ZweiteMessbruecke.SpeicheradresseSkalierung);
    Serial.print("ZweiteMessbruecke.Skalierung: ");
    Serial.println(ZweiteMessbruecke.Skalierung);
    Serial.print("ZweiteMessbruecke.SpeicherwertSkalierung: ");
    Serial.println(ZweiteMessbruecke.SpeicherwertSkalierung);
    Serial.println("");
    

    
    
/********************************************************************************​**************/
/****************************** EEPROM EINBINDEN ENDE *****************************************/
/********************************************************************************​**************/

  Serial.println();
  Serial.println(F("Wiegen - mit '3' und 'Enter' starten!"));
  Serial.println();
  while (Befehlseingabe!='3')
    {
      Befehlseingabe = Serial.read();
    }
  Serial.println(F("Warte... "));
  Serial.println();
/*                            VORBEREITUNG FUER 4x hx711
*                            

  DritteMessbruecke.Taragewicht= DritteMessbruecke.Tara;
  DritteMessbruecke.Skalierung= DritteMessbruecke.Scale;

  VierteMessbruecke.Taragewicht= VierteMessbruecke.Tara;
  VierteMessbruecke.Skalierung= VierteMessbruecke.Scale;

*/

  hx711ErsteMessbruecke.set_offset(ErsteMessbruecke.Taragewicht);  
  hx711ErsteMessbruecke.set_scale(ErsteMessbruecke.Skalierung);
  hx711ZweiteMessbruecke.set_offset(ZweiteMessbruecke.Taragewicht); //Zweiter AD-Wandler  
  hx711ZweiteMessbruecke.set_scale(ZweiteMessbruecke.Skalierung);   //Zweiter AD-Wandler

/*                            VORBEREITUNG FUER 4x hx711
*                            

  hx711DritteMessbruecke.set_offset(DritteMessbruecke.Taragewicht);  
  hx711DritteMessbruecke.set_scale(DritteMessbruecke.Skalierung);

  hx711VierteMessbruecke.set_offset(VierteMessbruecke.Taragewicht);  
  hx711VierteMessbruecke.set_scale(VierteMessbruecke.Skalierung);

  */
}

void loop() {  
    delay(500);
    ErsteMessbruecke.Gewicht= hx711ErsteMessbruecke.get_units();
    
    ZweiteMessbruecke.Gewicht= hx711ZweiteMessbruecke.get_units(); //Zweiter AD-Wandler
    
/*                            VORBEREITUNG FUER 4x hx711
*                            

    DritteMessbruecke.Gewicht= hx711DritteMessbruecke.get_units();
    VierteMessbruecke.Gewicht= hx711VierteMessbruecke.get_units();
    
  */
  
    delay(500);
    Gesamtgewicht=ErsteMessbruecke.Gewicht+ZweiteMessbruecke.Gewicht;

  //Gesamtgewicht=ErsteMessbruecke.Gewicht+ZweiteMessbruecke.Gewicht+DritteMessbruec​ke.Gewicht+VierteMessbruecke.Gewicht; Oberes Gesamtgewicht muss durch dieses ersetzt werden
    Serial.print("Gewicht: " );
    Serial.print(ErsteMessbruecke.Gewicht);      //Ausgabe erster AD-Wandler
    Serial.print("  ");  
    Serial.print(ZweiteMessbruecke.Gewicht);     //Ausgabe zweiter AD-Wandler
    Serial.print("  ");

/*                            VORBEREITUNG FUER 4x hx711  
  *                            

    Serial.print(DritteMessbruecke.Gewicht);      //Ausgabe dritte AD-Wandler
    Serial.print("  ");
    Serial.print(VierteMessbruecke.Gewicht);      //Ausgabe vierter AD-Wandler
    
      */
      
    Serial.print("  ");
    Serial.println(" g");
    Serial.println();
    Serial.print("Mittelwert:  ");
    Serial.print(" ----> ");
    if(Gesamtgewicht>1000)
      {
         Gesamtgewicht=Gesamtgewicht/1000;
         Serial.print(Gesamtgewicht/2); //Ausgabe Mittelwert
         Serial.println(" kg");
      }
    else
    {
      Serial.print(Gesamtgewicht/2); //Ausgabe Mittelwert
    Serial.println(" g");  
    }
  
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.09.2017, 15:15
Beitrag #8
RE: Mehrere HX711 an einem Arduino Nano
long ist ein Ganzzahlwert und hat keine Nachkommastellen. Du musst also entweder float verwenden oder den Messwert mit (10, 100, 1000) multiplizieren, um die Nachkommastellen mit im long unter zu bringen.

Der Code wird langsam unübersichtlich, weil Du 4 Mal das gleiche schreibst. Für solche Sachen wurden Funktionen erfunden. Da schreibst Du den Code nur einmal und übergibst jeweils die Parameter für die Messstelle.

ich würde an Deiner Stelle erst einmal folgende Funktionen vorsehen:

kalibrierenLeer
kalibrieren1kg
messen

Damit kann der Code übersichtlicher gehalten werden.

Hat es einen Grund, warum Du diese Abfrage immer doppelt durchführst und den 1. Wert weg wirfst?
Code:
hx711ErsteMessbruecke.read_average(10);                             //Erste AD-Wandler
  ErsteMessbruecke.Tara = hx711ErsteMessbruecke.read_average(10);     //Erste AD-Wandler

Die Menüsteuerung würde ich vorab in einem eigenen Sketch erst mal ausprobieren.

Wofür sind die delay(1000) gut?

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Wiegezelle und hx711 Probleme Haukini 2 397 24.03.2019 16:27
Letzter Beitrag: Haukini
  Mehrere HX711 mit einem Arduino Uno be14b029 8 3.126 16.03.2019 18:22
Letzter Beitrag: charlie883
  Gelöst ==> Arduino Nano, Kommunikation mit PC bringt nicht korrekten ASCII moehrle 4 414 02.03.2019 22:04
Letzter Beitrag: hotsystems
  neue NANO + Arduino IDE whn 11 965 09.02.2019 09:45
Letzter Beitrag: MiKo
  SPI Schnittstellen für mehrere Geräte nutzen Hoffmakl 11 817 31.01.2019 15:41
Letzter Beitrag: Hoffmakl
  Elektronischer Würfel (2W6) auf Arduino Nano - Warum Resets? Arduinero 7 393 20.01.2019 12:49
Letzter Beitrag: Arduinero
  mBlock und Arduino IDE gleichzeitig auf einem PC? mgbig 4 364 14.01.2019 08:39
Letzter Beitrag: mgbig
  Variablen zu einem CHAR verbinden und einbinden Frank_aus_WOB 3 472 02.01.2019 09:07
Letzter Beitrag: Tommy56
  Funknetz mit vielen Sendern und einem Empfänger Hi72 18 1.322 20.12.2018 12:48
Letzter Beitrag: Hi72
  mehrere Bytes seriell einlesen. Verständnisprobleme Mosi 9 794 19.12.2018 16:07
Letzter Beitrag: Mosi

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste