[Inzwischen nutze ich den Match-Rom Befehl damit ich nur einmal die 750ms Delay habe.]

Da hier gerade DS18b20 Fehler diskutiert werden, habe ich dazu auch eine Frage.

http://arduino.cc/forum/index.php/topic,145766.msg1163932.html#msg1163932
Hier hatte ich schon mal gezeigt wie ein erster Sketch funktioniert hat.

Adressen Teil:

Code:

//DeviceAdressen der einzelnen ds1820 Temperatursensoren. (loop anpassen)
  DeviceAddress sensor1 = { 0x28, 0x5E, 0x91, 0xAA, 0x3, 0x0, 0x0, 0xF  };
                 // ROM =     28    5E    91    AA    3    0    0    F        C3
  DeviceAddress sensor2 = { 0x28, 0xF5, 0x73, 0xAA, 0x3, 0x0, 0x0, 0xF2 };
                 // ROM =     28    F5    73    AA    3    0    0    F2       C2
  DeviceAddress sensor3 = { 0x28, 0xCF, 0x1E, 0xCA, 0x3, 0x0, 0x0, 0xBD };
                 // ROM =     28    CF    1E    CA    3    0    0    BD       IC
  char data[12]; 
  char sensor1Name[] = "C3 : ";
  char sensor2Name[] = "C2 : ";
  char sensor3Name[] = "IC : ";
 //..................................................................................

Inzwischen nutze ich den Match-Rom Befehl damit ich nur einmal die 750ms Delay habe.

Code:

  }
 // ...Match-Rom Befehl...............................................
 void OW_Match_ROM(byte* address, byte ow_befehl) {  // Match-ROM Befehl
   ds.reset();  //reset the bus
   ds.select(address);   //select sensor
   ds.write(ow_befehl);  // Befehl senden
   
 }
 // ...Skip-Rom Befehl...............................................
 void OW_Skip_ROM(byte ow_befehl) {  // Skip-ROM Befehl
   ds.reset();  //reset the bus
   ds.write(0xCC);  // Skip-ROM Befehl senden
   ds.write(ow_befehl);  // Befehl senden
 }
 // ...Read Scratchpad...............................................
 void OW_Read_Scratchpad(byte* address, byte data_zahl) {  // Read Scratchpad
   OW_Match_ROM(address, 0xBE);                            // Match-ROM Befehl 0xBE
   for (byte i=0;i<data_zahl;i++) {                        // Data-Zahl Bytes einlesen
      data[i] = ds.read();                                 // Bytes lesen
   }
 }
 // ...Temperatur_berechnen...............................................
 float Temperatur_berechnen(byte* address) {               // Temperatur berechnen
   float TEM; //** zusätzliche Variable
   OW_Read_Scratchpad(address, 9);                         // 9 Byte vom Scratchpad einlesen 
   TEM = ((data[1] << 8) + data[0] )*0.0625;               //** 12Bit = 0,0625 C per Bit andere Berechnung
   return TEM;                                             //** NEUE Variable der einfacheren Berechnung
 }
 // ...Temperaturen_einlesen...............................................
 void Temperaturen_einlesen(void) {                        // Temperaturen einlesen
   temp1 = Temperatur_berechnen(sensor1);                  // Temperatur Nr.1 einlesen
   temp2 = Temperatur_berechnen(sensor2);                  // Temperatur Nr.2 einlesen
   temp3 = Temperatur_berechnen(sensor3);                  // Temperatur Nr.3 einlesen
   OW_Skip_ROM(0x44);                                      // Temperaturmessung starten
   delay (750);
 }

Mit einem "Timer" statt "delay"  habe ich es noch nicht hinbekommen.

Nur jetzt suche ich nach einem Weg den mit "CRC" korrekt übertragene Werte zu erkennen.
Da die Temperaturwerte, zwar dauernd ausgelesen werden, ich sie aber nur sporadisch im Moment der Gewichtsänderungen mit anzeige,
werden manchmal unplausible falsche Werte angezeigt.

Mit CRC würde ich jetzt gerne immer nur die "gültigen Temperaturwerte" in Variablen vorher übernehmen und sie erst dann übernehmen,
wenn die Gewichtsänderung eingetreten ist.
Denn auf "richtige Werte" will ich nicht warten, deenn dann könnte sich inzwischen das Gewicht ändern, ohne dass es registriert wird.
Ein korrekt ausgelesener Wert der schon 5 Minuten früher eingelesen wurde ist mir auch recht.

Diesen Sketch habe ich eben noch mal getestet. Mit dem Arduino UNO und dem LCD Keypad Shield ROBOT Type läuft der Test.

Code:

// DALLAS_TEST_OK                     getestet 16-04-2013
#include <OneWire.h>
#include <LiquidCrystal.h>
                                      // Apus² Test modifiziert und angepasst.
OneWire  ds(2);                       // 1Wire Instance on Arduino digital pin 2
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  // LCD instance for LCD Keypad Shield ROBOT Type
                                      // Define some values used by the panel and buttons:
byte i;
byte present = 0;
byte data[12];
byte addr[8];
float Temp;

void setup(void) {
  Serial.begin(9600);            // Start serial interface with 9600 Baud
  lcd.begin(16,2);              // Start the LCD library for 16 x 2 display
  lcd.setCursor(0,0);
  lcd.print(" TESTPROGRAMM ");
  lcd.setCursor(0,1);
  lcd.print(" Dallas DS18B20 ");
  delay(3000);
  lcd.clear();
}

void loop(void) {
  if ( !ds.search(addr)) {
    // No more Dallas chips present:
    Serial.print("No more addresses.\n");
    ds.reset_search();
    delay(250);
    return;
  }

  // Output 64 Bit hardware id of Dallas Chip:
  Serial.print("R=");
  for( i = 0; i < 8; i++) {
    Serial.print(addr[i], HEX);
    Serial.print(" ");
  }

  // Check for invalid CRC in address:
  if ( OneWire::crc8( addr, 7) != addr[7]) {
    Serial.print("CRC is not valid!\n");
    return;
  }

  // Check for family code which is not DS18B20:
  if ( addr[0] != 0x28) {
    Serial.print("Device is not a DS18B20 family device.\n");
    return;
  }

  // The DallasTemperature library can do all this work for you!
  ds.reset();
  ds.select(addr);
  ds.write(0x44,0);          // start conversion, with parasite power off

  delay(1000);               // maybe 750ms is enough, maybe not

  // Check whether chip is present:
  present = ds.reset();
  ds.select(addr);   
  ds.write(0xBE);             // Read Scratchpad

  Serial.print("P=");         // Present = 1
  Serial.print(present,HEX);
  Serial.print(" ");
  for ( i = 0; i < 9; i++) {   // we need 9 bytes of data
    data[i] = ds.read();
    Serial.print(data[i], HEX);
    Serial.print(" ");
  }
  Serial.print(" CRC=");
  Serial.print( OneWire::crc8( data, 8), HEX);
  // Calculate temperature. data[1] High Byte, data[0] Low Byte.
  Temp =  ((data[1] << 8) + data[0] ) * 0.0625;  // 12Bit = 0,0625 C per Bit
  Serial.print( " T=");
  Serial.print( Temp, 2);
  Serial.print( " C");
  Serial.println();
  display_1WSensor();
}

void display_1WSensor(){
  // display Sensor data on LCD:
  char line[17];
  // Hardware ID:
  sprintf(line, "%02X%02X%02X%02X%02X%02X%02X%02X", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]);
  lcd.setCursor(0,0);         // move to the begining of the second line
  lcd.print(line);
  // Temperature in Hex:
  lcd.setCursor(0,1);
  sprintf(line, "D=%02X%02X", data[1], data[0]);
  lcd.print(line);
  // Temperature as Degree Celsius:
  lcd.setCursor(7,1);
  //sprintf(line, "T=%f C", Temp); funktioniert nicht, Fehler in Compiler?
  dtostrf(Temp, 5, 2, line);  // funktionierende Alterntative: http://dereenigne.org/electronics/arduino/arduino-float-to-string
  lcd.print("T=");
  lcd.print(line);
  lcd.print(" C");
}

Hier die Monitorausgabe

Code:

R=28 E2 6A AA 3 0 0 A3 P=1 83 1 4B 46 7F FF D 10 66  CRC=66 T=24.19 C
R=28 75 DD 1B 3 0 0 97 P=1 86 1 4B 46 7F FF A 10 5E  CRC=5E T=24.37 C
R=28 8B 6F AA 3 0 0 24 P=1 7E 1 4B 46 7F FF 2 10 25  CRC=25 T=23.87 C
R=28 47 62 AA 3 0 0 2A P=1 83 1 4B 46 7F FF D 10 66  CRC=66 T=24.19 C
No more addresses.
R=28 E2 6A AA 3 0 0 A3 P=1 82 1 4B 46 7F FF E 10 70  CRC=70 T=24.12 C
R=28 75 DD 1B 3 0 0 97 P=1 86 1 4B 46 7F FF A 10 5E  CRC=5E T=24.37 C
R=28 8B 6F AA 3 0 0 24 P=1 7E 1 4B 46 7F FF 2 10 25  CRC=25 T=23.87 C
R=28 47 62 AA 3 0 0 2A P=1 83 1 4B 46 7F FF D 10 66  CRC=66 T=24.19 C
No more addresses.
R=28 E2 6A AA 3 0 0 A3 P=1 83 1 4B 46 7F FF D 10 66  CRC=66 T=24.19 C
R=28 75 DD 1B 3 0 0 97 P=1 85 1 4B 46 7F FF B 10 5F  CRC=5F T=24.31 C
R=28 8B 6F AA 3 0 0 24 P=1 7E 1 4B 46 7F FF 2 10 25  CRC=25 T=23.87 C
R=28 47 62 AA 3 0 0 2A P=1 83 1 4B 46 7F FF D 10 66  CRC=66 T=24.19 C
No more addresses.
R=28 E2 6A AA 3 0 0 A3 P=1 82 1 4B 46 7F FF E 10 70  CRC=70 T=24.12 C
R=28 75 DD 1B 3 0 0 97 P=1 85 1 4B 46 7F FF B 10 5F  CRC=5F T=24.31 C
R=28 8B 6F AA 3 0 0 24 P=1 7D 1 4B 46 7F FF 3 10 24  CRC=24 T=23.81 C
R=28 47 62 AA 3 0 0 2A P=1 83 1 4B 46 7F FF D 10 66  CRC=66 T=24.19 C
No more addresses.

Im Sketch steht schon die CRC Abfrage mit drin.
Warum er sich dauernd ändert und wie ich das in dem anderen Code einfügen kann, versuche ich nun herauszubekommen,
oder es kann mir jemand erklären. 

Gruss Apus²            [ vom Thema Auf SD-Karte registrierende Waage ]

Um die Waage mal live zu testen, habe ich sie kurzfristig für einen anderen Zweck angepasst und das Reaktionsniveau mit 6 Gramm der Aufgabe  angepasst.
Unten an den Biegebalken-Sensor ist ein Haken, der eigentlich für Testgewichte vorgesehen ist.



Aber heute habe ich ein Futtersäckchen angehängt und registriere die Zeit,  wenn eine Blaumeise zum fressen kommt.
Das hat heute bisher 11 Mal [x2] sehr gut funktioniert.  

Code:

Futter - Waage 2013 with Arduino Mega
DATE TIME SCALE TEMP PERESSURE (abs) & LCD 6gr.F06
 Zeit : 08:04:16 Datum: 06.04.2013
 N | Ereignis |  WARTE |   ALT |   NEU |  DIFF | MS| T (Z)| T (K)| T (S)| P [hPa] | T (R) |  P [NN hPa]
 00|  <Start> |08:04:16|    0.0|   -0.0|   -0.0|  0|  16.7|   3.9|   3.4|   995.74|  17.10|   1014.20
 01|  < EIN < |08:09:04|   -0.0|   10.3|   10.3|  1|  16.8|   4.0|   3.6|   995.92|  17.10|   1014.38
 02|  > AUS > |08:10:18|   10.3|   -0.2|  -10.4|  0|  16.8|   4.0|   3.5|   995.86|  17.10|   1014.32
 03|  < EIN < |08:44:46|   -0.2|   10.1|   10.3|  1|  17.4|   4.3|   3.8|   996.28|  17.70|   1014.75
 04|  > AUS > |08:45:06|   10.1|   -0.7|  -10.9|  0|  17.4|   4.3|   3.8|   996.34|  17.70|   1014.81
 05|  < EIN < |09:13:06|   -0.7|    9.7|   10.4|  1|  17.8|   4.4|   4.0|   996.49|  18.10|   1014.96
 06|  > AUS > |09:13:33|    9.7|   -0.6|  -10.3|  0|  17.9|   4.4|   4.0|   996.52|  18.10|   1014.99
 07|  < EIN < |10:04:36|   -0.6|    9.7|   10.3|  1|  17.6|   4.6|   4.0|   996.89|  18.10|   1015.37
 08|  > AUS > |10:04:39|    9.7|   -0.4|  -10.2|  0|  17.6|   4.5|   4.0|   996.89|  18.10|   1015.37
 09|  < EIN < |10:04:58|   -0.4|    9.9|   10.4|  1|  17.6|   4.6|   4.0|   996.89|  18.10|   1015.37
 10|  > AUS > |10:06:50|    9.9|   -0.8|  -10.7|  0|  17.6|   4.5|   3.9|   996.92|  18.10|   1015.40
 11|  < EIN < |13:14:44|   -0.8|    8.2|    9.0|  1|  21.9|   6.8|   6.6|   997.73|  21.90|   1016.22
 12|  > AUS > |13:15:08|    8.2|   -2.3|  -10.5|  0|  21.9|   6.8|   6.6|   997.79|  21.90|   1016.29
 13|  < EIN < |15:23:09|   -2.3|    8.9|   11.1|  1|   8.0|   7.1|   6.9|   998.24|  24.00|   1016.74
 14|  > AUS > |15:23:59|    8.9|   -2.6|  -11.5|  0|   8.0|   7.1|   6.9|   998.12|  24.00|   1016.62
 15|  < EIN < |15:27:13|   -2.6|    8.2|   10.9|  1|  23.9|   7.1|   6.9|   998.18|  23.90|   1016.68
 16|  > AUS > |15:30:05|    8.2|   -2.8|  -11.0|  0|  23.8|   7.1|   7.0|   998.26|  23.90|   1016.76
 17|  < EIN < |15:43:13|   -2.8|    8.4|   11.2|  1|  23.1|   7.3|   7.1|   998.21|  23.30|   1016.71
 18|  > AUS > |15:43:23|    8.4|   -2.8|  -11.2|  0|  23.1|   7.3|   7.1|   998.29|  23.30|   1016.80
 19|  < EIN < |16:11:32|   -2.8|    7.7|   10.5|  1|  22.3|   7.1|   6.7|   998.33|  22.50|   1016.84
 20|  > AUS > |16:13:28|    7.7|   -3.1|  -10.8|  0|  22.2|   7.1|   6.7|   998.33|  22.50|   1016.84
 21|  < EIN < |16:18:34|   -3.1|   15.0|   18.1|  1|  22.3|   7.0|   6.6|   998.24|  22.50|   1016.74
 22|  > AUS > |16:18:57|   15.0|   -2.8|  -17.9|  0|  22.3|   7.0|   6.6|   998.21|  22.60|   1016.71

Gruß, Apus²

Code:

Futter - Waage 2013 with Arduino Mega
DATE TIME SCALE TEMP PERESSURE (abs) & LCD 6gr.F06
 Zeit : 15:22:37 Datum: 07.04.2013
 N | Ereignis |  WARTE |   ALT |   NEU |  DIFF | MS| T (Z)| T (K)| T (S)| P [hPa] | T (R) |  P [NN hPa]
 00|  <Start> |15:22:37|   -0.1|   -0.1|    0.0|  0|  22.5|  -5.3|  -4.4|   999.35|  22.50|   1017.88
 01|  < EIN < |16:02:13|   -0.1|   11.6|   11.7|  1|  22.2|  -5.6|  -5.1|   998.89|  22.40|   1017.41
 02|  > AUS > |16:03:25|   11.6|    0.5|  -11.1|  0|  22.2|  -5.7|  -5.1|   998.82|  22.40|   1017.34
 03|  < EIN < |16:41:32|    0.5|   12.2|   11.7|  1|  22.0|  -5.7|  -5.3|   998.24|  22.20|   1016.74
 04|  > AUS > |16:44:01|   12.2|    0.7|  -11.6|  0|  22.0|  -5.8|  -5.3|   998.18|  22.20|   1016.68

Und hier mit Foto der Meise um 16:43h 

Danke für das Beispiel,

ich wollte gerade meine switch/case Lösung hier reinstellen.

Statt default habe ich es etwas ander gelöst, aber das probiere ich jetzt mal aus.

Ich bin eben nach 8 Wochen noch immer .......... C++ Anfänger. 

Gruß, Apus²

[if]

Eine Frage zu diesem Sketch Teil

Die vielen if Abfragen dieser Zustandsabfrage von MS sind etwas langsam.
Die Abfrage funktioniert auch erst, seit ich MS mit den Variablen und nicht direkt mit den Zahlen vergleiche. [?]

Code:

void LED_Ampel()
{
  if ((MS) ==  (MS2)) digitalWrite(led24, HIGH);
  if ((MS) ==  (MS2)) digitalWrite(led26, HIGH);
  if ((MS) ==  (MS2)) digitalWrite(led28, LOW );   // turn two LEDs ON
   {
 }
  if ((MS) ==  (MS1)) digitalWrite(led24, HIGH);
  if ((MS) ==  (MS1)) digitalWrite(led26, LOW );
  if ((MS) ==  (MS1)) digitalWrite(led28, LOW );   // turns one LED off
   {
 }
  if ((MS) ==  (MS0)) digitalWrite(led24, LOW );
  if ((MS) ==  (MS0)) digitalWrite(led26, LOW );
  if ((MS) ==  (MS0)) digitalWrite(led28, LOW );   // turns all red LEDs off
   {
 }
  if ((MS) >= (MS3)||(MS) < (MS0)) digitalWrite(led24,  LOW );
  if ((MS) >= (MS3)||(MS) < (MS0)) digitalWrite(led26,  LOW );
  if ((MS) >= (MS3)||(MS) < (MS0)) digitalWrite(led28,  HIGH);   // turns the red LED on
   }

Wie muss ich die selbe Logik anders formulieren, damit es schneller reagiert?
MS wird im Sketch inkrementiert und dekrementiert und sollte sich nur im Bereich 0-1-2 bewegen.
Kleiner Null und größer 2 sollte nicht vorkommen.

MS0 = 0; MS1 = 1 ; MS2 = 2; MS3 = 3;

Wer hilft mir da etwas weiter?

Gruß, Apus²

Hier habe ich eine Übung, als ich die 16x4 Displays ausprobiert habe.
Den Teil mit der Kurzfassung und Kleinbuchstaben, habe ich erst gestern eingefügt. 

In dieser Art, könnte ich auch bei der MS-Abfrage eine Lösung gebrauchen.

Code:

/* ÜBUNG  Apus_Apus   01.04.2013
 * LiquidCrystal_16x4_Testen_OK
 * DV16400 liquid crystal display
 */
// Pinbelegung des Displays
// LCD.RS - pin 7
// LCD.En - pin 8
// LCD.D4 - pin 3
// LCD.D5 - pin 4
// LCD.D6 - pin 5
// LCD.D7 - pin 6

#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 3, 4, 5, 6);

int x = 0;                // Spalten - Zähler
int z = 0;                // Zeilen - Zähler
String stringType = " ";  // Zeichen

void setup() {
  lcd.begin(16,4);  // DV16400 liquid crystal display
}
void loop() {
   
  lcd.clear();
  lcd.setCursor(0 ,0);lcd.print("1. Zeile  0,0");
  lcd.setCursor(0 ,1);lcd.print("2. Zeile  0,1");
  lcd.setCursor(16,0);lcd.print("3. Zeile 16,0");
  lcd.setCursor(16,1);lcd.print("4. Zeile 16,1");
delay (2000) ;
  lcd.clear();
delay ( 300) ;                       
//         Beginn der  Kurzform und ohne delay; schnell

  for (int z = 0; z< 2; z++){
       for (int y = 0; y< 2; y++){
       y = y *16; lcd.setCursor(y ,z);
           for (int x = 0; x< 16; x++){
           stringType = String(x,HEX);
           lcd.print (stringType);
}
}
}
//         Ende der  Kurzform

delay (3000) ; //  Zeit zum Staunen :-))

  lcd.clear();
//               lange Form mit delay und langsamer
  lcd.setCursor(0 ,0);lcd.print("0"); // erste Zeile
delay (100);
  lcd.setCursor(1 ,0);lcd.print("1");
delay (100);
  lcd.setCursor(2 ,0);lcd.print("2");
delay (100);
  lcd.setCursor(3 ,0);lcd.print("3");
delay (100);
  lcd.setCursor(4 ,0);lcd.print("4");
delay (100);
  lcd.setCursor(5 ,0);lcd.print("5");
delay (100);
  lcd.setCursor(6 ,0);lcd.print("6");
delay (100);
  lcd.setCursor(7 ,0);lcd.print("7");
delay (100);
  lcd.setCursor(8 ,0);lcd.print("8");
delay (100);
  lcd.setCursor(9 ,0);lcd.print("9");
delay (100);
  lcd.setCursor(10 ,0);lcd.print("A");
delay (100);
  lcd.setCursor(11 ,0);lcd.print("B");
delay (100);
  lcd.setCursor(12 ,0);lcd.print("C");
delay (100);
  lcd.setCursor(13 ,0);lcd.print("D");
delay (100);
  lcd.setCursor(14 ,0);lcd.print("E");
delay (100);
  lcd.setCursor(15 ,0);lcd.print("F");
delay (100) ;                             // zweite Zeile
  lcd.setCursor(0 ,1);lcd.print("0");
delay (100);
  lcd.setCursor(1 ,1);lcd.print("1");
delay (100);
  lcd.setCursor(2 ,1);lcd.print("2");
delay (100);
  lcd.setCursor(3 ,1);lcd.print("3");
delay (100);
  lcd.setCursor(4 ,1);lcd.print("4");
delay (100);
  lcd.setCursor(5 ,1);lcd.print("5");
delay (100);
  lcd.setCursor(6 ,1);lcd.print("6");
delay (100);
  lcd.setCursor(7 ,1);lcd.print("7");
delay (100);
  lcd.setCursor(8 ,1);lcd.print("8");
delay (100);
  lcd.setCursor(9 ,1);lcd.print("9");
delay (100);
  lcd.setCursor(10 ,1);lcd.print("A");
delay (100);
  lcd.setCursor(11 ,1);lcd.print("B");
delay (100);
  lcd.setCursor(12 ,1);lcd.print("C");
delay (100);
  lcd.setCursor(13 ,1);lcd.print("D");
delay (100);
  lcd.setCursor(14,1);lcd.print("E");
delay (100);
  lcd.setCursor(15,1);lcd.print("F");
delay (100) ;                            // dritte Zeile
  lcd.setCursor(16,0);lcd.print("0");
delay (100);
  lcd.setCursor(17,0);lcd.print("1");
delay (100);
  lcd.setCursor(18,0);lcd.print("2");
delay (100);
  lcd.setCursor(19,0);lcd.print("3");
delay (100);
  lcd.setCursor(20,0);lcd.print("4");
delay (100);
  lcd.setCursor(21,0);lcd.print("5");
delay (100);
  lcd.setCursor(22,0);lcd.print("6");
delay (100);
  lcd.setCursor(23,0);lcd.print("7");
delay (100);
  lcd.setCursor(24,0);lcd.print("8");
delay (100);
  lcd.setCursor(25,0);lcd.print("9");
delay (100);
  lcd.setCursor(26,0);lcd.print("A");
delay (100);
  lcd.setCursor(27,0);lcd.print("B");
delay (100);
  lcd.setCursor(28,0);lcd.print("C");
delay (100);
  lcd.setCursor(29,0);lcd.print("D");
delay (100);
  lcd.setCursor(30,0);lcd.print("E");
delay (100);
  lcd.setCursor(31,0);lcd.print("F");
delay (100) ;                         // vierte Zeile
  lcd.setCursor(16 ,1);lcd.print("0");
delay (100);
  lcd.setCursor(17 ,1);lcd.print("1");
delay (100);
  lcd.setCursor(18 ,1);lcd.print("2");
delay (100);
  lcd.setCursor(19,1);lcd.print("3");
delay (100);
  lcd.setCursor(20,1);lcd.print("4");
delay (100);
  lcd.setCursor(21,1);lcd.print("5");
delay (100);
  lcd.setCursor(22,1);lcd.print("6");
delay (100);
  lcd.setCursor(23 ,1);lcd.print("7");
delay (100);
  lcd.setCursor(24,1);lcd.print("8");
delay (100);
  lcd.setCursor(25,1);lcd.print("9");
delay (100);
  lcd.setCursor(26 ,1);lcd.print("A");
delay (100);
  lcd.setCursor(27 ,1);lcd.print("B");
delay (100);
  lcd.setCursor(28 ,1);lcd.print("C");
delay (100);
  lcd.setCursor(29 ,1);lcd.print("D");
delay (100);
  lcd.setCursor(30 ,1);lcd.print("E");
delay (100);
  lcd.setCursor(31 ,1);lcd.print("F");
  delay (3000);
}
 

Rechtzeitig vor Ostern habe ich einen Zwischenstand erreicht, mit dem ich als Arduino Anfänger schon zufrieden sein kann.

Das Speichern der Daten auf SD-Karte funktioniert zwar noch nicht, aber inzwischen bekomme ich alle gewünschten Daten auf den PC-Monitor.

Durch die gemeinsame Erfassung der DS18B20 Temperaturen mit "MATCH-Befehl" wurde der Sketch auch schnell genug.
Gewichtsänderungen  werden noch im Sekundentakt erfasst. Schneller brauche ich es nicht.

Seit gestern habe ich auch einen BMP085 V2  Luftdruck Sensor. Einen geigneten Sketch zum Testen habe ich hier gefunden.
http://sensorapp.net/?p=278

Der etwas ältere Sketch-CODE musste bei "receive" und "send" entsprechend angepasst werden.

Alles was mir davon brauchbar erschien, habe ich in meinen Waage-Sketch übernommen.

Überrascht war ich schon, als zusammen mit den Gewichtsänderungen beim ersten Versuch auch der Luftdruck  mit der Sensor - Temperatur angezeigt wurde.
Leider war dann aber die Anzeige von Datum und Zeit gestört.

Als ich am Sensor nur die 5V Versorgung weggenommen habe, um den Grund für die Störung zu sehen, hat Datum und Zeit wieder gestimmt,
aber auch die Sensorsignale wurden immer noch richtig angezeigt.   

In welchem Betriebszusatnd der Sensor das auch kann, weiß ich nicht.

Um ganz Sicher zu sein habe ich dann alternativ die 3,3V Versorgung benutz.  Das ist mit dem V2 Typ möglich. Auch danach funktioniert es ohne Fehler.

Meinem Projekt-Titel werde ich damit noch nicht gerecht, aber mit dem Etappenziel nach 8 Wochen, bin ich  nun doch sehr zufrieden.

Alle Daten, die ich für meine eigentliche Überwachungsaufgabe haben will, kann ich jetzt vom Monitor kopieren und dann als Text-Datei sichern.

Theoretisch bleiben mir noch vier Wochen. Vielleicht finde ich bis dahin  zum Speichern auf die SD-Karte auch noch eine Lösung.

Das ganze Equipment habe ich im Doppel, so kann ich auch über die nächsten vier Wochen hinaus, weiter versuchen den Sketch zu verbessern.

Der Luftdruck wird absolut angezeigt. Er ist nicht auf Meereshöhe angepasst. Das muss ich nicht im Sketch korrigieren.
Um das aber nachzurechnen, habe ich eine gut gemachte Seite gefunden, mit der sich die örtliche Höhe für diese Rechnung bestimmen lässt.
http://gpso.de/maps/

Allen ein frohes Osterfest,

Apus²

Zu dem oben gezeigten Beispiel habe ich eine weitere Frage.

Weil ich die drei Sensoren, nacheinander auslese, habe ich für jeden Sensor die 750ms delay.
Jetzt hat mir jemand vorgeschlagen, ich sollte sie mit Match ROM(0xBE) gemeinsam einlesen
und würde mir 2x 750ms sparen = SCHNELLER !

Code:

void Temperatur_einlesen(void) {
   Match ROM(0xBE) ---> Nr1 einlesen
   Match ROM(0xBE) ---> Nr2 einlesen
   Match ROM(0xBE) ---> Nr3 einlesen
   Skip ROM(0x44) ---> Alle Messungen neu starten
}

Mit diesem Vorschlag habe ich´mich auf die Suche nach einem Beispiel gemacht,
aus dem direkt hervorgeht, wie  das anzuwenden ist.  
Nur habe ich nichts gefunden, das ich umsetzen kann.

Vielleicht hilft mir an diesem Punkt jemand weiter?

Der Sketch in dem das geändert werden soll, steht weiter oben.

Gruß, Apus²

[//**]

Hi an alle und besonders an die Skeptiker, 

seit heute habe ich nun auch den größeren Sketch zusammen, mit dem ich außer Datum, Zeit und WIEGEN auch zusätzlich drei Temperaturen erfasse.
Speichern auf SD geht zwar noch nicht, aber was ich mir auf dem Monitor und dem LCD - Display anzeige ist für mich erst mal OK!

Mein zusammengebastelter Sketch ist sicher noch zu verbessern, schließlich bin ich mit knapp 5 Woochen nur Anfänger auf dem C++ Gebiet.

Aber bei dem sehr schön strukturierten Beispiel, für das einlesen der Temperaturen von DS18B20 - Sensoren mit bekannten ROM- Adressen, das ich heute gefunden habe,
konnte ich zwar die Sketch-Struktur gut verstehen, aber bei der Berechnung der Temperatur aus den beiden Daten-Bytes habe ich nicht durchgeblickt.

Die damit berechneten Werte waren leider Hausnummern und hatten mit den vorhandnen Temperaturen nichts zu tun.

Dann habe ich in dem Bereich die vielen Zeilen entfernt, alles was mit der Berechnung zu tun hat und zu der neuen Variablen  float TEM; 

noch diese Zeile für die Berechnung eingefügt:      TEM = ((data[1] <<  8  ) + data[0] )*0.0625;    // 1/16 = 0.0625

Damit stimmt die Berechnung!    Schade ist nur dass die delays den Sketch etwas langsam machen.

Hier ist das Beispiel:  Wer auch DS18B20 Sensoren hat, sollte diesen Sketch  mit den entsprechenden ROM Adressen nutzen können.

Meine hinzugefügten ersetzten Zeilen  für die Byte-Umrechnung sind mit //** markiert!

Code:

#include <OneWire.h>
#include <DallasTemperature.h>
 
OneWire  ds(2); //pin für ds1820
 
//DeviceAdressen der einzelnen ds1820 Temperatursensoren. (ROM Adresse für jeden Sensor anpassen)
  DeviceAddress sensor1 = { 0x28, 0x5E, 0x91, 0xAA, 0x3, 0x0, 0x0, 0xF  };
                 // ROM =     28    5E    91    AA    3    0    0    F        C3
  DeviceAddress sensor2 = { 0x28, 0xF5, 0x73, 0xAA, 0x3, 0x0, 0x0, 0xF2 };
                 // ROM =     28    F5    73    AA    3    0    0    F2       C2
  DeviceAddress sensor3 = { 0x28, 0xCF, 0x1E, 0xCA, 0x3, 0x0, 0x0, 0xBD };
                 // ROM =     28    CF    1E    CA    3    0    0    BD       IC
 
char sensor1Name[] = "C3 : ";
char sensor2Name[] = "C2 : ";
char sensor3Name[] = "IC : ";

//..................................................................................
void setup(void)
{
  Serial.begin(9600);
}
//..............................................................aufrufen............
void writeToScratchpad(byte* address)
{
  //reset the bus
  ds.reset();
  //select sensor
  ds.select(address);
  //CONVERT T function call (44h) übernimmt Data in scratchpad
  ds.write(0x44,1);                                             // ,0 oder ,1 ?
  // 750 ms Wartezeit
  delay(750);
}
//..................................................................lesen............
void readFromScratchpad(byte* address, byte* data)
{
  //reset the bus
  ds.reset();
  //select our sensor
  ds.select(address);
  //read the scratchpad (BEh)
  ds.write(0xBE);
  for (byte i=0;i<9;i++){
    data[i] = ds.read();                     // Bytes  lesen
  }
}
//..................................................................................
float getTemperature(byte* address)
{
  float TEM;                   //** zusätzliche Variable
 
  byte data[12];
 
  writeToScratchpad(address);                 // Funktion  aufrufen   0x44,1
 
  readFromScratchpad(address,data);           //  Funktion lesen      0XBE
 
  TEM = ((data[1] << 8) + data[0] )*0.0625; 
                                //** 12Bit = 0,0625 C per Bit  andere Berechnung
 
  return TEM;                  //**  NEUE Variable der einfacheren Berechnung
}
 
void loop(void)
{
  float temp1 = getTemperature(sensor1);
  float temp2 = getTemperature(sensor2);
  float temp3 = getTemperature(sensor3);
 
  Serial.print(sensor1Name);
  Serial.print(temp1);
  Serial.println(" C");
 
  Serial.print(sensor2Name);
  Serial.print(temp2);
  Serial.println(" C");
 
  Serial.print(sensor3Name);
  Serial.print(temp3);
  Serial.println(" C");
 
  Serial.println();
 
  delay(750);
}

Was mögliche versteckten Zeichen betrifft, bin ich schon sehr vorsichtig. 
Wenn ich hier CODES zeige, sollten die leeren Stellen nur BLANKS sein, die ich zur besseren Lesbarkeit als Zeilen und Spaltenausgleich einfüge.

Es würde mich feuen, wenn jemand mit diesem Sketch was anfangen kann und dann die Zeit spart, die ich zum FINDEN, VERSTEHEN und ABÄNDERN aufgewendet habe.

Ebenso wären Beiträge und Antworten, die mir als Anfänger mit Beispielen zeigen wie es geht, sinnvoller.
Aber für meine Motivation und Ausdauer werde ich wohl noch eine Weile selbst sorgen müssen. 

Der Sketch oben, ist nur das Beispiel, das ich nach geglückter Änderung zum Teil in meinen WAAGE-Sketch eingebaut habe.

Gruß, Apus²

Temperatur - Messung mit DS 18B20

inzwischen habe ich einen Sketch, der sollte eigentlich funktionieren.
Ich habe nur die HEX Adressen angepasst und   // einige Kommentare und Erweiterungsmöglichkeiten entfernt.
Die Fehlermeldungen sind danach gleich geblieben.

Code:

  #include <Wire.h>
  #include <OneWire.h>
  #include <DallasTemperature.h>
  #include <LiquidCrystal.h>
// Data wire is plugged into pin 2 on the Arduino
      #define ONE_WIRE_BUS 2
//  #define TEMPERATURE_PRECISION 10
//  Setup a oneWire instance to communicate with any OneWire devices
      OneWire oneWire(ONE_WIRE_BUS);
//  Setup lcd
     LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
// Pass our oneWire reference to Dallas Temperature.
     DallasTemperature sensors(&oneWire);
// Assign the addresses of your 1-Wire temp sensors.
    DeviceAddress Probe001 = { 0x28, 0xF5, 0x73, 0xAA, 0x03, 0x00, 0x00, 0xF2 }; //ROM = 28 F5 73 AA 03 00 00 F2
    DeviceAddress Probe002 = { 0x28, 0x13, 0x50, 0xCA, 0x03, 0x00, 0x00, 0x4F }; //ROM = 28 13 50 CA 03 00 00 4F

void setup(void)
{
  // start lcd
  Wire.begin();
  lcd.begin(16, 4);
  // start serial port
  Serial.begin(9600);
  // Start up the library
  sensors.begin();
  // set the resolution to 10 bit (good enough?)
  sensors.setResolution(Probe001,10);
  sensors.setResolution(Probe002,10);
}
void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  if (tempC == -127.00) {
  Serial.print("Error getting temperature");
}
else
{
  lcd.print("C: ");
  lcd.print(tempC);
  //Serial.print(” F: “);
  //Serial.print(DallasTemperature::toFahrenheit(tempC));
}
}
void loop(void)
{
  delay(2000);
  Serial.println();
  Serial.println();
  Serial.print("Getting temperatures \n\r");
  sensors.requestTemperatures();
  Serial.print("Probe 01 temperature is: ");
  printTemperature(Probe001);
  Serial.print("\n\r");
  Serial.print("Probe 02 temperature is: ");
  printTemperature(Probe002);
  Serial.print("\n\r");

Ich weiß nicht, wie ich diese Fehler deuten soll. 

Code:

sketch_mar17a_Dallas18B20.cpp.o: In function `__static_initialization_and_destruction_0':
C:\Users\me\Arduino\arduino-1.0.3/sketch_mar17a_Dallas18B20.ino:13: undefined reference to `DallasTemperature::DallasTemperature(OneWire*)'
sketch_mar17a_Dallas18B20.cpp.o: In function `printTemperature(unsigned char*)':
C:\Users\me\Arduino\arduino-1.0.3/sketch_mar17a_Dallas18B20.ino:33: undefined reference to `DallasTemperature::getTempC(unsigned char*)'
sketch_mar17a_Dallas18B20.cpp.o: In function `loop':
C:\Users\me\Arduino\arduino-1.0.3/sketch_mar17a_Dallas18B20.ino:51: undefined reference to `DallasTemperature::requestTemperatures()'
sketch_mar17a_Dallas18B20.cpp.o: In function `setup':
C:\Users\me\Arduino\arduino-1.0.3/sketch_mar17a_Dallas18B20.ino:26: undefined reference to `DallasTemperature::begin()'
C:\Users\me\Arduino\arduino-1.0.3/sketch_mar17a_Dallas18B20.ino:28: undefined reference to `DallasTemperature::setResolution(unsigned char*, unsigned char)'
C:\Users\me\Arduino\arduino-1.0.3/sketch_mar17a_Dallas18B20.ino:29: undefined reference to `DallasTemperature::setResolution(unsigned char*, unsigned char)'

Was habe ich falsch gemacht oder übersehen?  Wer kann mir das erklären?

Gruß, Apus²

Dann stelle ich hier auch mal eine Frage, zur SD-Karte.

Irgend wann will ich sie auch mal für die Waage benutzen. 
Bei dem angehängten Test-Sketch, werden Datalog.txt Files angelegt.

Nur warum bekommen die alle 01.01.2000 01:00  als Erstelldatum mit angehängt?

Gruß, Apus²

Code:

#include <SD.h>

// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 10;

File dataFile;

void setup()
{
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  Serial.print("Initializing SD card...");
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(SS, OUTPUT);
 
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1) ;
  }
  Serial.println("card initialized.");
 
  // Open up the file we're going to log to!
  dataFile = SD.open("datalog.txt", FILE_WRITE);
  if (! dataFile) {
    Serial.println("error opening datalog.txt");
    // Wait forever since we cant write data
    while (1) ;
  }
}

void loop()
{
  // make a string for assembling the data to log:
  String dataString = "";

  // read three sensors and append to the string:
  for (int analogPin = 0; analogPin < 3; analogPin++) {
    int sensor = analogRead(analogPin);
    dataString += String(sensor);
    if (analogPin < 2) {
      dataString += ",";
    }
  }

  dataFile.println(dataString);

  // print to the serial port too:
  Serial.println(dataString);
 
  // The following line will 'save' the file to the SD card after every
  // line of data - this will use more power and slow down how much data
  // you can read but it's safer!
  // If you want to speed up the system, remove the call to flush() and it
  // will save the file only every 512 bytes - every time a sector on the
  // SD card is filled with data.
  dataFile.flush();
 
  // Take 1 measurement every 500 milliseconds
  delay(500);
}

Hallo jurs,

erst mal Danke für die "notwendige Nachhilfe".

Die Beschreibung werde ich versuchen umzusetzen und mit der notwendigen Logik füllen.

Inzwischen versuche ich mit beiden DS18B20 Hex Adressen nur diese beiden Dallas Sensoren auszulesen.

ROM = 28 F5 73 AA 03 00 00 F2
ROM = 28 13 50 CA 03 00 00 4F

Sketche, die das können und noch viel mehr machen habe ich.

Die roten führenden Nullen sehe ich beim Test auf dem Display, aber am Monitor nicht.
 P = 1 A2 01 4B 46 7F FF E 10 D8  CRC=D8 T = 26.12 C
 P = 1 B3 01 4B 46 7F FF D 10 9A  CRC=9A T = 27.19 C

Bei den Hexzahlen der Messwerte LB HB   ist es genau so.

Die Minimal-Lösung, die nur die beiden Temperaturen am Monitor in  xx.xx °C anzeigt, bekomme ich nicht zusammen.
Ich scheitere schon daran die Hexadresse der Sensoren in die Abfrage zu übernehemen.
Der Faktor für die Umrechnung des Hex-Messwertes ist 0,0625 °C / bit   z.B.   Hex 0200 sind 32°C

Wer weiß wie das aussehen muss?


Gruß, Apus²

[Die Pins für den I2C-Bus sind auf UNO und MEGA Boards unterschiedliche.UNO I2C: A4 (SDA), A5 (SCL)MEGA I2C: 20 (SDA), 21 (SCL)]

Es macht einen Sinn, mal die bisherigen Etappen-Ziele zu meinem Projekt aufzulisten.

O   Zu der Logik des beabsichtigten Wiegevorganges habe ich ein funktionierenden Sketch.
      Über die Monitor-Funktion, lassen sich die Meßwerte auch erfassen.  [mit C&P etwas improvisiert]

O    Mit einem Sketch kann ich die aktuelle Uhrzeit und Datum über die Monitor-Funktion ausgeben

O  Für den Test der SD-Karte habe ich einen Sketch

Code:

Initializing SD card...
Card type: SDHC

Volume type is FAT32

Volume size (bytes): 3956801536
Volume size (Kbytes): 3864064
Volume size (Mbytes): 3773

Files found on the card (name, date and size in bytes):
DATALOG.TXT   2000-01-01 01:00:00 264

O  Zum anzeigen über die Monitor-Funktion und Speichern der Werte von A0 , A1 und A2 habe ich einen Sketch.

Code:

Initializing SD card...card initialized.
1023,495,1023
1023,511,1023
1023,531,1023
1023,547,1023
1023,559,1023
1023,582,1023
144,527,1023                  // Der erste Wert [i]144 [/i]steht für die Betätigung
144,511,1023                  // der UP-Key Taste am Keypad Shield.
144,484,1023                  // für insgesamt 4 Sekunden.
144,471,1023
144,449,1023
1023,497,

Damit habe ich alle Teilfunktionen als Beispiele zusammen, jetzt muss ich nur noch Verstehen, wie ich das in EINEM - Code organisieren muss.
Noch bleiben mir weiter 4 - maximal 6 Wochen, dann sollte die erste komplette Sketch-Fassung funktionsfähig sein.
Am 28/29 Januar 2013 habe ich erst mit C++ und Arduino angefangen.  

Gestern habe ich den Versuch gemacht, das Kabel zwischen Hx711 ADC und Arduino mit einem Abgeschirmten Kabel auf 1,10m zu verlängern.
Es hat zwar die Werte zuerst etwas unstabiler gemacht, aber das habe ich jetzt im Sketch erfolgreich abgeändert.

Wegen des langen (dünnen) Kabel, habe ich vorsorglich direkt am ADC die Versorgungsspannung mit 1µF gestützt.
Leider habe ich privat noch kein OSZI um die Notwendigkeit nachzuweisen. Die Messwerte schienen mir dadurch aber etwas stabiler.
Das lange Kabel wird gebraucht, weil der Abstand Waage im Kasten vor dem Fenster und Arduino im Innenraum so groß sein muß.

Für mich war es wichtig, kleine gut dokumentierte Sketche zu finden, die ich als C++  Anfänger verstehen kann.
Das war eine mühsame Arbeit. Für den Brauchbaren Tipp, möchte ich mich auch nochmal bedanken.
Damit bekomme ich eventuell alles zusammen auch auf dem Arduino Mega zum laufen.

Die Pins für den I2C-Bus sind auf UNO und MEGA Boards unterschiedliche.

UNO   I2C: A4 (SDA), A5 (SCL)
MEGA I2C: 20 (SDA), 21 (SCL)


Inzwischen bin ich sogar übermütig und versuche auch noch einen Luftdruck Sensor zu integrieren.
http://www.adafruit.com/products/391
Dort gibt es inzwischen sogar den 5V Typ.

Jetzt muss ich noch ein  verständliches Beispiel finden, in dem ich erkenne, wie die Teilfunktionen zusammenzufassen sind.

WIEGEN + Datum > Speichern.      Ich darf wohl so direkt fragen, denn mit C++ habe ich erst 1.2.2013 angefangen.  

Um die ALU-Waagschale  im Kasten korrekt einzubauen , habe ich auch etwas Zeit gebraucht.
Noch sehe ich meinen Zeitplan nicht gefärdet. Mit etwas Hilfe wäre ich mir da aber sicherer.

Gruß, Apus²

Zu der Grafik:

Für den Test zum Wiegen, habe ich eine 9V Batterie zusammen mit einer 1,5V AA Zelle reingelegt und danach nur die 9V-Batt entnommen.
Erst  bei einer spontanen Gewichtsänderung von mehr als plus oder minus 35 Gramm soll ein neuer Wert registriert werden.
Erst die AA Zelle und dann die 9V Batterie geht genau so, wenn die AA Zelle drin bleibt.

Auf dem Arduino Mega läuft der selbe Sketch leider nicht. (???)

Die Pins für den I2C-Bus sind auf UNO und MEGA Boards unterschiedliche.

UNO  I2C: A4 (SDA), A5 (SCL)
MEGA I2C: 20 (SDA), 21 (SCL)

Danke für die Antwort,

nachdem ich durch die Antwort den Grund kannte, was unter der Bemerkung ... "nur nach Modifikation " ... zu verstehen ist,
habe ich auch direkt diesen Link gefunden:
http://arduino.cc/en/Reference/Wire

Deshalb DANKE für den TIPP.

Gruß, Apus²

......... zu meinem WAAGE-Thema. Ich habe seit heute die größere Waage - Schale.
Mit 500gr habe ich getestet welcher Fehler beim Wiegen entsteht, wenn das Gewicht im Bereich von +/-10 cm an verschiedenen Stellen liegt.  Der Fehler bleibt bei maximal 0,2% 

@ Alle,

inzwischen habe ich die RTC auf dem Arduino UNO R3 zum Laufen gebracht.

Mit einem Sketch kann ich die Uhr am PC-Monitor über COM1 stellen und die Zeit zur Anzeige bringen.
Dann habe ich den Sketch auch noch erweitert und zeige jetzt in der zweiten Zeile auch das Datum an.

Auf dem Arduino Mega läuft der selbe Sketch leider nicht. (???)

Beim Sketch der Waage habe ich eine Abfrage hinzugefügt mit der ich bei Gewichtsüberschreitung LEDs schalte.

Solch eine Entscheidung brauche ich später ähnlich, um das Speichern der Daten zu starten.

Gibt es hier im Forum jemanden, der im Rhein-Main-Gebiet zuhause ist?
Dann würde ich auch einen direkten Kontakt zum Informationsaustausch für sinvoll halten.

Gruß, Apus²

Hallo jurs,

es gibt auf Deine skeptische Einschätzung etwas erfreuliches zu berichten.
Sicher habe ich als Anfänger  mit C++ etwas hoch gegriffen, aber inzwischen läuft einiges.

Ok, an eine Ampelschaltung, habe ich auch mal realisiert. 
Der Key-Test auf mit dem LCD KeyPach Shield läuft auch.
Etwas genauer musste ich hinschauen, bis ich auch die Waage zum Wiegen gebracht habe. 

Beim Kauf der Komponenten, wurde ich etwas auf die falsche Spur gesetzt,
denn mir wurde versichert, dass das LCD Keypad-Shield problemlos auch für die Waage einzusetzen ist.
Meine Vermutung, dass ich mit dem normalen LCD-Display keine Probleme bekommen hätte,
war durchaus stimmig.
Hier hätte einer der erfahrenen Arduino-KENNER sich den Code "LiquidCristalScale"  genau ansehen müssen und mit der Hardware vergleichen und hätte das Wettrennen zur Lösung locker vor mir gewinnen können.
Letztendlich war es sehr einfach.

Das steht im originalen Code:

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
Hx711 scale(A1, A0);


Das ist nun meine Legende im Sketch

Code:

// #A1 & #A0 is shiftet, #A0 is used for the key function
// the colours of the cabel for "SCALE ONE"  = S1 are
// Hx711.SCK    -  pin #A1   >S1>  white
// Hx711.DOUT -  pin #A2   >S1>  orange   
// Hx711 Vcc       PIN 5V     >S1>  red           
// Hx711 GND      PIN GND  >S1>  brown   

// LCD.RS - pin 8
// LCD.En - pin 9
// the order of these four pins are changed too.
// LCD.D4 - pin 4
// LCD.D5 - pin 5
// LCD.D6 - pin 6
// LCD.D7 - pin 7

Mit dieser Einstellung habe ich es dann probiert und es funktioniert.

Code:

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
Hx711 scale(A2, A1);

Die Waage ist erstaunlich genau.
Mit jedem Einschalten kalibriert sie sich auf "Null", ein Reset bewirkt eine Tara-Funktion zum Dazuwiegen. Über Nacht blieb die Anzeige von 499 Gramm stabil.

Wer mit dem vorgegebenen Max-Gewicht von 3 kg zurecht kommt, hat auch noch bis 4 kg Reserve,
ohne dass sich der Nullpunkt nach der Mehrbelastung verändert.

Als nächsten Schritt, will ich die RTC auf dem  SD - Memorial Snootlab Memoire Kit (Data Logging Shield) einstellen und auf dem Display darstellen.
Für Vorschläge wäre ich schon jetzt dankbar, mache mich aber schon mal auf den Weg. 

Ich muss nicht unbedingt wieder zuerst ankommen. 

Gruß, Apus²

Hallo,  
Nach dem ich in einem anderen Forum leider keine Reaktion erzielt habe,
möchte ich nichts unversucht lassen und frage auch mal hier.

Als Neuling mit dem Arduino möchte ich mein Wunschprojekt kurz beschreiben.
Mit diesen Hardware Komponenten,

http://www.play-zone.ch/de/digitale-waage-mit-hx711-adc-bis-3kg.html

http://www.play-zone.ch/de/elektronik-kit-zubehoer/avr-arduino-freeduino/arduino-sets-bundles/arduino-uno-atmega328p-pu-mit-protoshield-v5-kompat-board.html

http://www.play-zone.ch/de/snootlab-memoire-kit.html


möchte ich eine Waage realisieren, die bei einer spontanen Gewichtsänderung von plus oder minus X Gramm, (z.B. 30 Gramm)
mit Datum und Uhrzeit das aktuelle Gewicht auf der SD-Karte protokolliert.

Zu jeder Komponente gibt es schon eine Sketch-Datei. >> auf den html-Seiten der Links
Wie ich die Sketche miteinander "verheirate" ....... ist für mich leider noch ein Problem.
Wer weiß das?  
Ich hoffe hier auf Versändnis für meine Frage.

Gruß, Apus^²