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
Auf SD-Karte registrierende Waage
01.03.2013, 09:23 (Dieser Beitrag wurde zuletzt bearbeitet: 03.03.2013 11:16 von Apus_Apus.)
Beitrag #17
RE: Auf SD-Karte registrierende Waage
Ich habe mal eine ganz konkrete Frage.

Wie müsste ich die Wert-Anzeige "behandeln", wenn ich die Gewichte nach dem Komma orientiert auf dem Display sehen will.
   
Es ist zwar nur Kosmetik, aber wenn die Anzeige so zappelt, wenn ein Minuszeichen erscheint oder eine Dezimalstelle überschritten wird, dann stört es besonders, wenn mehrere Werte übereinander stehen.
   

Zur Zeit sieht die entsprechende Zeile noch so aus:

Code:
lcd.setCursor(0, 0);
  lcd.print("Reg. "); lcd.print(RegW2,1);lcd.print(" gr.  ");
  lcd.setCursor(0, 1);
  lcd.print("Akt. "); lcd.print(AktW1,1);lcd.print(" gr.  ");

Für die Monitor - Anzeige habe ich es schon mal mit "if" versucht um dann Nullen beim Datum einzufügen, wenn Tag oder Monat einstellig ist.
Das geht vermutlich auch einfacher.

Für einen enstsprechenden Tipp, wäre ich dankbar.

Gruß, Apus²
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.03.2013, 13:41 (Dieser Beitrag wurde zuletzt bearbeitet: 03.03.2013 13:49 von Apus_Apus.)
Beitrag #18
RE: Auf SD-Karte registrierende Waage
Das mit der formatierten Datenausgabe auf das Display hebe ich mir auf, bis ich einen seriellen Dsiplay-Typ habe.

Mit einigen (keinen überraschenden) Schwierigkeiten, habe ich inzwischen einen Sketch zusammengestrickt,
mit dem ich die Gewichtsänderungen auf den SD-Chip zusammen mit mm : ss speichern kann.

Punkt statt Komma umgehe ich, indem ich den Gewichts-Wert vorher mit 100 multipliziere und als Integer speichere.
Als Delimiter zwischen den Werten und der Zeit, nehme ich ein ";" das kann ich beim Übertragen in Excel benutzen.
   
Im Bild sind die Daten der Monitor-Anzeige zu sehen. Das will ich nun noch mit der Stunde erweitern.
Bei dem kurzen Ausschnitt vom Sketch --- bitte bedenken --- ich mach das erst seit ~vier Wochen. Blush

Das Tagesdatum will ich nur zu Beginn -- nach der Initialisierung der SD-Karte einfügen. ( versuche ich noch)

Gruß, Apus²
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
03.03.2013, 19:28 (Dieser Beitrag wurde zuletzt bearbeitet: 03.03.2013 19:35 von Apus_Apus.)
Beitrag #19
RE: Auf SD-Karte registrierende Waage
Ich glaube es ist nun doch notwendig, den Sketch komplette zur Diskussion zu stellen.
Binäre Sketchgröße: 21.084 Bytes (von einem Maximum von 30.720 Bytes)
Allein von der Größe komme ich inzwischen sowieso an die Grenze des Machbaren.
Denn das LCD-Display ist noch nicht dabei Huh

Denn beim Mega sähe es schon ganz anders aus.

Binäre Sketchgröße: 22.534 Bytes (von einem Maximum von 258.048 Bytes)
Nur bekomme ich mit ihm noch nicht das SD-Shield zum laufen.
Bisher habe ich einen Mega nur als Versuchsobjekt, werde mir aber sicher selbst einen kaufen.
Ich wollte den kompletten Sketch-Ordner anhängen, das geht offensichtlich nicht. Huh

Dann eben in der MAXI-Version.Dodgy

UNO_wiegen_TIME_u_DATE_auf_SD_11
Code:
/* sample for digital weight scale of hx711,  with Com1 Monitor only
* ohne  HD44780 liquid crystal monitor
* UNO wiegen TIME & DATE auf SD_11
* Apus-Apus Waage    03-03-2013_10:00
*/
// #A1 & #A0 is shiftet, #A0 is used for Key function
// coulors of the cable for SCALE ONE  
// Hx711.SCK  - pin #A1  >S1>  yellow
// Hx711.DOUT - pin #A2  >S1>  orange  
// Hx711 Vcc    PIN 5V   >S1>  red          
// Hx711 GND    PIN GND  >S1>  brown

int   P1   =    100;    //  Pause  
float AktW1  =  0.0;    // aktueller Wert
float RegW2  =  0.0;    // registrieter Wert
float DX     = 30.0;    // Toleranz Kriterium
  
//////////
#include <SD.h>             // SD Teil
const int chipSelect = 10;  // SD Teil
//
byte zero = 0x00; //workaround
File dataFile;
//
#include <Hx711.h>
Hx711 scale(A2, A1);
//////////////////////////////////////////
#include "Wire.h"
#define DS1307_I2C_ADDRESS 0x68

// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}

// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}
// Gets the date and time from the ds1307
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
  // Reset the register pointer
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

  // A few of these need masks because certain bits are control bits
  *second     = bcdToDec(Wire.read() & 0x7f);
  *minute     = bcdToDec(Wire.read());
  *hour       = bcdToDec(Wire.read() & 0x3f);  // Need to change this if 12 hour am/pm
  *dayOfWeek  = bcdToDec(Wire.read());
  *dayOfMonth = bcdToDec(Wire.read());
  *month      = bcdToDec(Wire.read());
  *year       = bcdToDec(Wire.read());
}
///////////////////////////////////////////////////////////////////////
void setup()
{
  Wire.begin();
  Serial.begin(9600);     // for the Serial Monitor
  //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() {
    String dataString = "";
    ////////////////////
  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;                                                              
  getDateDs1307(&second, &minute, &hour, &dayOfWeek,  &year , &month, &dayOfMonth);
  
  AktW1=(scale.getGram()); //Faktor x 1,02   erst beim Speichern
//
  if (AktW1 > RegW2 + DX)               //  wenn AktW1 um DX größer als RegW2
  {                                     // Serial Print zum PC Monitor     wie ich die langen Zeilen vermeiden kann weiß ich noch nicht!
     delay(P1); AktW1 = (scale.getGram()); RegW2 = AktW1 ;Serial.print("P ;");Serial.print(RegW2);dataString += String(int(RegW2*102));dataString += ("; "); dataString +=String(hour);dataString +=(":");dataString += String(minute); dataString += (":"); dataString += String (second); dataString += ("; ");dataFile.println(dataString);Serial.print("; "); Serial.print(hour); Serial.print (":");Serial.print(minute);Serial.print(":");Serial.println(second);//dataFile.flush();//
} else {
          RegW2 = RegW2 ;
///
}
  if (AktW1 <  RegW2-DX)                  //  wenn AktW1 um DX kleiner als RegW2
  {
    delay(P1); AktW1 = (scale.getGram()); RegW2 = AktW1 ;Serial.print("M ;");Serial.print(AktW1);dataString += String(int(AktW1*102));dataString += ("; "); dataString +=String(hour);dataString +=(":");dataString += String(minute); dataString += (":"); dataString += String (second); dataString += ("; ");dataFile.println(dataString);Serial.print("; "); Serial.print(hour); Serial.print (":");Serial.print(minute);Serial.print(":");Serial.println(second); //dataFile.flush();//

} else {
           AktW1 = AktW1 ;
                        
}

dataFile.flush();
}

Dazu gehört auch Hx711.h
Code:
/* Arduino library for digital weight scale of hx711
*
  *
*  Created on: Oct 31, 2012
*/

#ifndef HX711_H_
#define HX711_H_

#include "Arduino.h"

class Hx711
{
public:
    Hx711(uint8_t pin_din, uint8_t pin_slk);
    virtual ~Hx711();
    long getValue();
    long averageValue(byte times = 32);
    void setOffset(long offset);
    void setScale(float scale = 742.f);
    float getGram();

private:
    const uint8_t _pin_dout;
    const uint8_t _pin_slk;
    long _offset;
    float _scale;
};

#endif /* HX711_H_ */

SD.h
Code:
/*

SD - a slightly more friendly wrapper for sdfatlib

This library aims to expose a subset of SD card functionality
in the form of a higher level "wrapper" object.

License: GNU General Public License V3
          (Because sdfatlib is licensed with this.)

(C) Copyright 2010 SparkFun Electronics

*/

#ifndef __SD_H__
#define __SD_H__

#include <Arduino.h>

#include <utility/SdFat.h>
#include <utility/SdFatUtil.h>

#define FILE_READ O_READ
#define FILE_WRITE (O_READ | O_WRITE | O_CREAT)

class File : public Stream {
private:
  char _name[13]; // our name
  SdFile *_file;  // underlying file pointer

public:
  File(SdFile f, const char *name);     // wraps an underlying SdFile
  File(void);      // 'empty' constructor
  ~File(void);     // destructor
  virtual size_t write(uint8_t);
  virtual size_t write(const uint8_t *buf, size_t size);
  virtual int read();
  virtual int peek();
  virtual int available();
  virtual void flush();
  int read(void *buf, uint16_t nbyte);
  boolean seek(uint32_t pos);
  uint32_t position();
  uint32_t size();
  void close();
  operator bool();
  char * name();

  boolean isDirectory(void);
  File openNextFile(uint8_t mode = O_RDONLY);
  void rewindDirectory(void);
  
  using Print::write;
};

class SDClass {

private:
  // These are required for initialisation and use of sdfatlib
  Sd2Card card;
  SdVolume volume;
  SdFile root;
  
  // my quick&dirty iterator, should be replaced
  SdFile getParentDir(const char *filepath, int *indx);
public:
  // This needs to be called to set up the connection to the SD card
  // before other methods are used.
  boolean begin(uint8_t csPin = SD_CHIP_SELECT_PIN);
  
  // Open the specified file/directory with the supplied mode (e.g. read or
  // write, etc). Returns a File object for interacting with the file.
  // Note that currently only one file can be open at a time.
  File open(const char *filename, uint8_t mode = FILE_READ);

  // Methods to determine if the requested file path exists.
  boolean exists(char *filepath);

  // Create the requested directory heirarchy--if intermediate directories
  // do not exist they will be created.
  boolean mkdir(char *filepath);
  
  // Delete the file.
  boolean remove(char *filepath);
  
  boolean rmdir(char *filepath);

private:

  // This is used to determine the mode used to open a file
  // it's here because it's the easiest place to pass the
  // information through the directory walking function. But
  // it's probably not the best place for it.
  // It shouldn't be set directly--it is set via the parameters to `open`.
  int fileOpenMode;
  
  friend class File;
  friend boolean callback_openPath(SdFile&, char *, boolean, void *);
};

extern SDClass SD;

#endif

Wire.h
Code:
/*
  TwoWire.h - TWI/I2C library for Arduino & Wiring
  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

  Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
*/

#ifndef TwoWire_h
#define TwoWire_h

#include <inttypes.h>
#include "Stream.h"

#define BUFFER_LENGTH 32

class TwoWire : public Stream
{
  private:
    static uint8_t rxBuffer[];
    static uint8_t rxBufferIndex;
    static uint8_t rxBufferLength;

    static uint8_t txAddress;
    static uint8_t txBuffer[];
    static uint8_t txBufferIndex;
    static uint8_t txBufferLength;

    static uint8_t transmitting;
    static void (*user_onRequest)(void);
    static void (*user_onReceive)(int);
    static void onRequestService(void);
    static void onReceiveService(uint8_t*, int);
  public:
    TwoWire();
    void begin();
    void begin(uint8_t);
    void begin(int);
    void beginTransmission(uint8_t);
    void beginTransmission(int);
    uint8_t endTransmission(void);
    uint8_t endTransmission(uint8_t);
    uint8_t requestFrom(uint8_t, uint8_t);
    uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
    uint8_t requestFrom(int, int);
    uint8_t requestFrom(int, int, int);
    virtual size_t write(uint8_t);
    virtual size_t write(const uint8_t *, size_t);
    virtual int available(void);
    virtual int read(void);
    virtual int peek(void);
    virtual void flush(void);
    void onReceive( void (*)(int) );
    void onRequest( void (*)(void) );
  
    inline size_t write(unsigned long n) { return write((uint8_t)n); }
    inline size_t write(long n) { return write((uint8_t)n); }
    inline size_t write(unsigned int n) { return write((uint8_t)n); }
    inline size_t write(int n) { return write((uint8_t)n); }
    using Print::write;
};

extern TwoWire Wire;

#endif

Dann noch den Text, wie er im Monitorfenster erscheint.

.txt  Monitor-Anzeige.txt (Größe: 1,51 KB / Downloads: 147)

Das sind die Variablen:

int P1 = 100; // Pause
float AktW1 = 0.0; // aktueller Gewichtswert
float RegW2 = 0.0; // registrierter Gewichtswert
float DX = 30.0; // Kriterium Gewichtstoleranz

Wenn ich mit dem CODE auch nicht zufrieden sein kann, er zeigt zumindestens die Logik mit der die Waage arbeiten soll.

Ich hoffe nur, dass das Thema interessant genug ist und sich jemand die Mühe macht mir Fehler zu zeigen.
So richtig fingen die Fehler erst an, als ich auch die Stunden mit speichern wollte.

Sollten noch Informationen fehlen, liefere ich sie nach.
Gruß. Apus²
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
08.03.2013, 23:04
Beitrag #20
RE: Auf SD-Karte registrierende Waage
Noch mal in eigener Sache.

Inzwischen habe ich mich entschlossen, für die kommende Saison es bei der Daten-Anzeige auf dem Monitor erst mal zu belassen.
Das werden täglich maximal 40-45 Zeilen. Wenn es auch umständlich ist, den angezeigten Text in den Editor zu kopieren,
bekomme ich auf diese Weise schon alle Werte die ich für meine Beobachtung brauche.

Auf einem kleinen XP-PC läuft der Arduino Uno damit im Testlauf problemlos.

Bis der Waage-Kasten wieder einsatzbereit ist, habe ich noch genügend andere Probleme, die gelöst werden müssen und auch Zeit kosten.

Mit der zweiten Waage , kann ich im Laufe des Jahres versuchen eine bessere Lösung mit der Datenspeicherung auf SD-Karte zu realisieren.
Die neue Version kommt dann im nächsten Jahr zum Einsatz.Smile

Aus den Daten vom Testlauf, kann ich in Excel z.B. solche Grafiken erzeugen.
   

Gruß, Apus²
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.03.2013, 16:36
Beitrag #21
RE: Auf SD-Karte registrierende Waage
nachdem ich schon einen Sketch habe, mit dem ich Gewicht und Zeit zu jedem Ereignis >< xx.x Gramm,auf dem Monitor anzeigen lassen kann, möchte ich nun anfangen mir die Teilfunktionen für einen voll funktionierenden Sketch zusammenzustellen.

Mit der Wiegen-Funktion habe ich angefangen. Der Sketch funktioniert so auch.
Es stehen schon // PLATZHALTER // und einige Kommentare drin.

Code:
/* sample for digital weight scale of hx711, with a KeyPad-Shield
* and a HD44780 liquid crystal monitor
* Apus - Waage 2013
*/
// #A1 & #A0 is shiftet, #A0 is used for Key function
// for two different cable W1 & W2 the used coulors
// Hx711.SCK  - pin #A1  >W1>  weiss   >W2 blue
// Hx711.DOUT - pin #A2  >W1>  orange  >W2 green
// Hx711 Vcc    PIN 5V   >W1>  red     >W2 violet      
// Hx711 GND    PIN GND  >W1>  brown   >W2 grey

// LCD.RS - pin 8
// LCD.En - pin 9
//
// LCD.D4 - pin 4
// LCD.D5 - pin 5
// LCD.D6 - pin 6
// LCD.D7 - pin 7
//****************************************************************
//#include                                      //wird später aktiviert
//#include                                      // wird später aktiviert
  #include <LiquidCrystal.h>            // Display
  #include <Hx711.h>                     // ADC Verstaerker
float Gewicht = 0.0;
//                                                 //  String definieren ?
//                                                 //  
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
Hx711 scale(A2, A1);
//****************************************************************
void setup() {
Serial.begin(9600);       // für die Monitoranzeige
  lcd.clear();
  lcd.begin(16, 4);
}
//******************** die Wiegefunktion *****************************
void wiegen() {
  Gewicht = ((scale.getGram()*1.007));
  // dtostrf(floatVar, minStringWidthIncDecimalPoint,numVarsAfterDecimal,charBuf);  
   // mit dieser Vorgabe hatte ich es versucht , den Wert in einen String umwandeln.
  
   delay(100);
}
//****************************************************************
void loop     () {
//Datum      ();
//Zeit          ();
//Tempratur();
//Druck       ();
//****************************************************************
  wiegen();            // Wiegefunktion ausführen!
                           // Werte anzeigen
  lcd.setCursor(1,1);
  lcd.println(Gewicht);lcd.println("  gr.  ");
  Serial.println(Gewicht);
  //***************************************************************
  //                             hier soll zum Funktionstest der Wert auch als String erscheinen
  delay(100);
// alle Strings          Datum , Zeit, Gewicht, Temperatut, Druck    zusammensetzen
//  Daten-String speichern.
}
//****************************************************************

Bisher gelingt es mir noch nicht mit "dtostrf" den Gewichtswert in einen String zu packen.
Wer ist bereit das nachzubessern?

Dann habe ich noch eine weitere Frage, zu dem Speichern auf SD als Test.
Die angelegten Files haben immer das Erstell-Datum 01.01.2000 und nicht das aktuelle Datum.
Woran liegt das ?

Code:
File dataFile = SD.open("datalog.txt", FILE_WRITE);
Fehlt in der Zeile die das datalog - File anlegt noch etwas?

Gruß Apus²
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
14.03.2013, 13:13 (Dieser Beitrag wurde zuletzt bearbeitet: 14.03.2013 19:53 von Apus_Apus.)
Beitrag #22
RE: Auf SD-Karte registrierende Waage
Meine Frage von gestern zur Formatierung , hat sich inzwischen erledigt.
Ich habe herausgefunden, wie es geht. Smile

Code:
WIEGEN TIME DATE Monitor & LCD 25gr. V4b
Datum : ;14.03.2013
Zeit  : ;11:28:49
          WARTE  ;   alt  ;     neu
01; EIN ;11:29:01;    0.00;    50.97; DIFF;    50.97; <
02; AUS ;11:29:04;   50.97;     6.37; DIFF;   -44.60; >
03; EIN ;11:29:05;    6.37;    57.14; DIFF;    50.77; <
04; AUS ;11:29:08;   57.14;    12.60; DIFF;   -44.53; >
05; EIN ;11:29:10;   12.60;    63.37; DIFF;    50.76; <
06; AUS ;11:29:12;   63.37;    18.90; DIFF;   -44.46; >
07; EIN ;11:29:13;   18.90;    69.64; DIFF;    50.73; <
08; AUS ;11:29:16;   69.64;    25.16; DIFF;   -44.47; >
09; EIN ;11:29:17;   25.16;    76.05; DIFF;    50.88; <
10; AUS ;11:29:23;   76.05;    31.44; DIFF;   -44.61; >
11; EIN ;11:29:30;   31.44;    82.39; DIFF;    50.95; <
12; AUS ;11:29:35;   82.39;    37.75; DIFF;   -44.64; >
13; EIN ;11:29:36;   37.75;    88.62; DIFF;    50.87; <
14; AUS ;11:29:39;   88.62;    44.09; DIFF;   -44.53; >
15; EIN ;11:29:40;   44.09;    94.88; DIFF;    50.80; <
16; AUS ;11:29:44;   94.88;    50.28; DIFF;   -44.61; >
17; EIN ;11:29:49;   50.28;   101.05; DIFF;    50.77; <
18; AUS ;11:29:52;  101.05;    56.58; DIFF;   -44.47; >
19; EIN ;11:29:55;   56.58;   107.27; DIFF;    50.70; <
20; AUS ;11:29:58;  107.27;    62.66; DIFF;   -44.62; >
21; EIN ;11:30:01;   62.66;   113.58; DIFF;    50.93; <
22; AUS ;11:30:06;  113.58;    69.01; DIFF;   -44.57; >
23; EIN ;11:30:08;   69.01;   119.92; DIFF;    50.91; <
24; AUS ;11:30:10;  119.92;    75.44; DIFF;   -44.48; >
25; EIN ;11:30:12;   75.44;   126.17; DIFF;    50.73; <
26; AUS ;11:30:14;  126.17;    81.61; DIFF;   -44.56; >
27; EIN ;11:30:16;   81.61;   132.54; DIFF;    50.93; <
28; AUS ;11:45:01;  132.54;    88.09; DIFF;   -44.45; >

So wie hier, sieht es jetzt auch am Monitor aus. Das war heute Nachmittag.

Inzwischen habe ich auch noch einen kleinen logischen Fehler besietigt, der sich nur bemerkbar gemacht hat,
wenn ich mehr als 200 Gramm spontane Änderung erzwungen habe. Jetzt geht es auch noch bei + 1350 Gramm ohne Fehler.Big Grin

Die Frage wie ich in den IF-Abfragen die langen Zeilen vermeide, habe ich inzwischen auch herausgefunden. Blush

Jetzt fehlt mir nur noch die Funktion für zwei Dallas Temperaturen, dann wäre ich vorerst mal restlos zufrieden.

Aber der Appetit kommt bekanntlich beim Essen, beim Programmieren soll das auch so ähnlich sein.Wink

Gruß, Apus²
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
19.03.2013, 11:32 (Dieser Beitrag wurde zuletzt bearbeitet: 19.03.2013 17:17 von Apus_Apus.)
Beitrag #23
RE: Auf SD-Karte registrierende Waage
Die Freude ist zwar groß, wenn mir ohne fremde Hilfe selbst etwas gelingt, aber in diesem Fall hätte ich mich über Hilfestellung schon sehr gefreut.
Es hätte mir viel Zeit gespart.

Auch wenn ich erst Arduino-Beginner bin, vielleicht ist dieser Sketch in ähnlichen Fällen --- mit anderen Sensoren --- jemandem nützlich.
An Verbesserungen bin ich aber auch interessiert.

So wie ich die Kommentare eingefügt habe, sollte er leicht verstanden werden.

Ich hatte einen Beispiel-Sketch gefunden und glaubte ihn zu verstehen. Huh

Leider war mir die Berechnung der Temperatur aus den Bytes und noch einge Zeilen unverständlich.
Die angezeigte Temperatur war nicht plausibel, aber die Struktur war verständlich.

Dann habe ich alle unnützen Zeilen der Berechnung entfernt und durch die mit //** markierten Zeilen mit einer anderen (kürzeren) Berechnung ersetzt.

Das funktioniert jetzt! Big Grin

Code:
#include <OneWire.h>
#include <DallasTemperature.h>

OneWire  ds(2); //pin für ds1820

//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 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 TEMP;                        //** zusätzliche Variable
  
  byte data[12];

  writeToScratchpad(address);                     // Funktion  aufrufen   0x44,1

  readFromScratchpad(address,data);           //  Funktion lesen      0XBE

  TEMP = ((data[1] << 8) + data[0] )*0.0625;  
                                        //** 12Bit = 0,0625 C per Bit  andere Berechnung
  
  return TEMP;                  //**  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);
}

Ich würde mich freuen, wenn dieses Beispiel jemandem nützt!

Gruß, Apus²

Inzwischen habe ich die 3x Temperatur - Anzeige auch in den WAAGE-Sketch mit eingebaut. [17:00]
   
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.03.2013, 00:11 (Dieser Beitrag wurde zuletzt bearbeitet: 28.03.2013 14:30 von Apus_Apus.)
Beitrag #24
Smile RE: Auf SD-Karte registrierende Waage
Ich habe den Mut noch nicht verloren. Big Grin

Seit heute ist der Waage Sketch auch ausreichend schnell.
Gewichtsänderungen werden jetzt auch im Sekunden - Abstand noch erfasst.
Gestern war es besser als ich dachte, aber mit Verzögerungen bis vier Sekunden, mir noch nicht schnell genug.
Mit etwas Nachhilfe konnte ich dann das Auslesen der Dallas Sensoren beschleunigen.

Ebenso, habe ich die PINS für das LCD Display von 8,9, 4,5,6,7 noch mal um einen Pin versetzt.
Auf 7,8, 3,4,5,6 Wegen der Pin-Konflikte für mit dem SD-Shield, habe ich das vorsorglich gemacht und es funktioniert auch.

Nur jetzt habe ich ein Problem.
Beim Versuch den Sketch um die SD-Speicherung zu erweitern, bin ich für heute erst mal gescheitert.

Es hat lange gedauert, bis ich überhaupt ein Speichern auf die Karte erreicht habe.
Denn das Key Pad Shield mit den Tasten an A0 benutze ich im Moment nicht.
Mein Waage - Sketch benötigt schon:
Binäre Sketchgröße: 15.674 Bytes (von einem Maximum von 30.720 Bytes)

Allein der kleine SD - logger Sketch, der nicht mehr macht als die beiden Waage-PINs A1 und A2 sinnlos einzulesen und zu speichern
-- das macht er aber richtig -- , braucht schon:
Binäre Sketchgröße: 14.998 Bytes (von einem Maximum von 30.720 Bytes) WARUM so viel Huh

Das passt nicht beides in den Arduino 2009! Oder hat jemand eine Idee? Gibt es eine SD.h auch kleiner?

Jetzt werde ich es erst mal mit dem Arduino Mega versuchen. Undecided

Gruß, Apus²

28.03.2013 14:00 NACHTRAG
Inzwischen bin ich einen kleinen Schritt weiter.
Der Waage-Sketch lässt sich auch mit der SD.h kompilieren, wenn ich ihn nicht von der Arduino IDE aus lade,
sonder die *.ino direkt aus dem Explorer aufrufe und dann erst mit der IDE überprüfe.


Irgend wie ist es doch ein Anfängerfehler, den ich da noch mache.

Ohne SD.h kompiliert
Binäre Sketchgröße: 17.182 Bytes (von einem Maximum von 258.048 Bytes)

Mit SD.h kompiliert
Binäre Sketchgröße: 22.780 Bytes (von einem Maximum von 258.048 Bytes)

Wer kann mir dazu einen hilfreichen Tipp geben?

Gruß, Apus²
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Gehe zu:


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