Go Down

Topic: Problem Real Time Clock (Read 2304 times) previous topic - next topic

Hallo Leute,

in diesem Teil des Forums habe ich tolle Hilfe von euch dabei bekommen, einen Windmesser mit dem Arduino zu realisieren :

http://forum.arduino.cc/index.php?topic=158479.0

Dabei ist jetzt das Problem aufgetaucht, dass meine Real Time Clock (diese hier: http://www.watterott.com/de/Real-Time-Clock-Module-RTC) scheinbar ihren Geist aufgegeben hat, auf einmal (sie hat einen ganzen Tag im Einsatz durchgehalten). Habt ihr eine Idee wie ich testen kann, ob sie funktioniert bzw. inwieweit ich versuchen kann sie anzusteuern?

Hab es mit verschiedensten Libaries probiert, die aber alle nicht zum Erfolg geführt haben.

Wenn ich beispielsweise diesen Sketch ausführe:

Code: [Select]
// #############################################################################
// #
// # Scriptname : DS1307_Test.pde
// # Author     : Peter Schmelzer, Oliver Kraus
// # Date       : 2011-04-08

// # Editor     : Lauren from DFRobot
// # Date       : 30.12.2011

// # Description:
// # Test file for the DS1307new library. Assumes that you have a DS1307
// # connected to the I2C-Bus of your Arduino and that it has a battery backup.
// # Update the library and sketch to compatible with IDE V1.0 and earlier

// # Version    : 1.0
// #############################################################################
// *********************************************
// INCLUDE
// *********************************************
#include <Wire.h>                       // For some strange reasons, Wire.h must be included here
#include <DS1307new.h>

// *********************************************
// DEFINE
// *********************************************

// *********************************************
// VARIABLES
// *********************************************
uint16_t startAddr = 0x0000;            // Start address to store in the NV-RAM
uint16_t lastAddr;                      // new address for storing in NV-RAM
uint16_t TimeIsSet = 0xaa55;            // Helper that time must not set again

// *********************************************
// SETUP
// *********************************************
void setup()
{
  pinMode(2, INPUT);                    // Test of the SQW pin, D2 = INPUT
  digitalWrite(2, HIGH);                // Test of the SQW pin, D2 = Pullup on

  Serial.begin(9600);

/*
   PLEASE NOTICE: WE HAVE MADE AN ADDRESS SHIFT FOR THE NV-RAM!!!
                  NV-RAM ADDRESS 0x08 HAS TO ADDRESSED WITH ADDRESS 0x00=0
                  TO AVOID OVERWRITING THE CLOCK REGISTERS IN CASE OF
                  ERRORS IN YOUR CODE. SO THE LAST ADDRESS IS 0x38=56!
*/
  RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t));// Store startAddr in NV-RAM address 0x08

/*
   Uncomment the next 2 lines if you want to SET the clock
   Comment them out if the clock is set.
   DON'T ASK ME WHY: YOU MUST UPLOAD THE CODE TWICE TO LET HIM WORK
   AFTER SETTING THE CLOCK ONCE.
*/
//  TimeIsSet = 0xffff;
//  RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); 

/*
  Control the clock.
  Clock will only be set if NV-RAM Address does not contain 0xaa.
  DS1307 should have a battery backup.
*/
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet != 0xaa55)
  {
    RTC.stopClock();
       
    RTC.fillByYMD(2011,4,8);
    RTC.fillByHMS(22,7,0);
   
    RTC.setTime();
    TimeIsSet = 0xaa55;
    RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
    RTC.startClock();
  }
  else
  {
    RTC.getTime();
  }

/*
   Control Register for SQW pin which can be used as an interrupt.
*/
  RTC.ctrl = 0x00;                      // 0x00=disable SQW pin, 0x10=1Hz,
                                        // 0x11=4096Hz, 0x12=8192Hz, 0x13=32768Hz
  RTC.setCTRL();

  Serial.println("DS1307 Testsketch");
  Serial.println("Format is \"hh:mm:ss dd-mm-yyyy DDD\"");

  uint8_t MESZ;

  MESZ = RTC.isMEZSummerTime();
  Serial.print("MEZ=0, MESZ=1 : ");
  Serial.println(MESZ, DEC);   
  Serial.println();
}

// *********************************************
// MAIN (LOOP)
// *********************************************
void loop()
{
  RTC.getTime();
  if (RTC.hour < 10)                    // correct hour if necessary
  {
    Serial.print("0");
    Serial.print(RTC.hour, DEC);
  }
  else
  {
    Serial.print(RTC.hour, DEC);
  }
  Serial.print(":");
  if (RTC.minute < 10)                  // correct minute if necessary
  {
    Serial.print("0");
    Serial.print(RTC.minute, DEC);
  }
  else
  {
    Serial.print(RTC.minute, DEC);
  }
  Serial.print(":");
  if (RTC.second < 10)                  // correct second if necessary
  {
    Serial.print("0");
    Serial.print(RTC.second, DEC);
  }
  else
  {
    Serial.print(RTC.second, DEC);
  }
  Serial.print(" ");
  if (RTC.day < 10)                    // correct date if necessary
  {
    Serial.print("0");
    Serial.print(RTC.day, DEC);
  }
  else
  {
    Serial.print(RTC.day, DEC);
  }
  Serial.print("-");
  if (RTC.month < 10)                   // correct month if necessary
  {
    Serial.print("0");
    Serial.print(RTC.month, DEC);
  }
  else
  {
    Serial.print(RTC.month, DEC);
  }
  Serial.print("-");
  Serial.print(RTC.year, DEC);          // Year need not to be changed
  Serial.print(" ");
  switch (RTC.dow)                      // Friendly printout the weekday
  {
    case 1:
      Serial.print("MON");
      break;
    case 2:
      Serial.print("TUE");
      break;
    case 3:
      Serial.print("WED");
      break;
    case 4:
      Serial.print("THU");
      break;
    case 5:
      Serial.print("FRI");
      break;
    case 6:
      Serial.print("SAT");
      break;
    case 7:
      Serial.print("SUN");
      break;
  }
  Serial.print(" seconds since 1.1.2000:");
  Serial.print(RTC.time2000, DEC);
  uint8_t MESZ = RTC.isMEZSummerTime();
  Serial.print(" MEZ=0, MESZ=1 : ");
  Serial.print(MESZ, DEC); 
 
  Serial.print(" - Address in NV-RAM is: ");
  RTC.getRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  Serial.print(lastAddr, HEX);
  lastAddr = lastAddr + 1;              // we want to use it as addresscounter for example
  RTC.setRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet == 0xaa55)              // check if the clock was set or not
  {
    Serial.println(" - Clock was set!");
  }
  else
  {
    Serial.println(" - Clock was NOT set!");
  }   
  delay(1000);                          // wait a second
}


Erhalte ich folgende Ausgabe:

DS1307 Testsketch
Format is "hh:mm:ss dd-mm-yyyy DDD"
MEZ=0, MESZ=1 : 0

165:165:85 165-165-2165 MON seconds since 1.1.2000:1076433489 MEZ=0, MESZ=1 : 0 - Address in NV-RAM is: 0 - Clock was set!
165:165:85 165-165-2165 MON seconds since 1.1.2000:1076433489 MEZ=0, MESZ=1 : 0 - Address in NV-RAM is: 1 - Clock was set!
165:165:85 165-165-2165 MON seconds since 1.1.2000:1076433489 MEZ=0, MESZ=1 : 0 - Address in NV-RAM is: 2 - Clock was set!
165:165:85 165-165-2165 MON seconds since 1.1.2000:1076433489 MEZ=0, MESZ=1 : 0 - Address in NV-RAM is: 3 - Clock was set!
165:165:85 165-165-2165 MON seconds since 1.1.2000:1076433489 MEZ=0, MESZ=1 : 0 - Address in NV-RAM is: 4 - Clock was set!
165:165:85 165-165-2165 MON seconds since 1.1.2000:1076433489 MEZ=0, MESZ=1 : 0 - Address in NV-RAM is: 5 - Clock was set!

Scheinbar wurde die Uhr nicht gestellt.

Bräuchte da dringend eure Hilfe!!

Falls meine RTC widererwarten defekt, kaputt, zum wegwerfen sein sollte, hat jemand von euch eine Idee, wo man solch eine günsitg (gern auch schon mit Stiftleiste dran gelötet) beziehen kann?

Gruß

Zum Sketch kann ich nichts sagen, aber zur Bezugsquelle. Ich habe diese hier vom freundlichen Chinesen: ebay 330868967962. Eine Suche nach DS1307 bringt diverse Treffer. Aber der Preis vom Chinamann ist unschlagbar. Eine Stiftleiste ist nicht unbedingt notwendig. Die Kabel kannst du doch auch direkt anlöten.

Läuft übrigens einwandfrei mit dem Arduino.

Frank
Anfänger, der sich am Mega versucht. (Wegen Pin-Mangel bin ich vom Uno auf den Mega umgestiegen) Aktuelles Projekt: http://mfc-wittgenstein.

jurs


Habt ihr eine Idee wie ich testen kann, ob sie funktioniert bzw. inwieweit ich versuchen kann sie anzusteuern?


Am besten mit einem funktionierenden Test-Sketch.

In dem von Dir geposteten Sketch steht das als Kommentar:
DON'T ASK ME WHY: YOU MUST UPLOAD THE CODE TWICE TO LET HIM WORK
   AFTER SETTING THE CLOCK ONCE.


Einen Code, der etwas vertrauenserweckender daherkommt, hast Du wirklich nicht gefunden?

Eisebaer

hi,

nimm die DS1307new-library, und wenn Du mit der feststellst, daß die RTC ok ist, kannst Du sie dann auch alleine mit der wire-library ansteuern. beispiel im playground.

gruß stefan
nimm abblockkondensatoren!  100nF.  glaub mir, nimm abblockkondensatoren!

Ich habe den Code von hier genommen (zweites Beispiel) http://macherzin.net/Arduino++Echtzeit
Nach dem anpassen meiner Display-Anschlüsse lief das einwandfrei.

Frank

Anfänger, der sich am Mega versucht. (Wegen Pin-Mangel bin ich vom Uno auf den Mega umgestiegen) Aktuelles Projekt: http://mfc-wittgenstein.

Vielen Dank für eure Antworten!

Um Das ganze aufzulösen, es lag an meiner SD-Karte die wohl irgendein Problem hatte.

Jetzt läuft alles wieder wunderbar.

Gruß

Nachdem gerad alles wunderbar funktioniert hat, geht jetzt wieder garnix mehr.

Es liegt wohl scheinbar doch an der Hardware als an allem anderen.

Bin da langsam leicht verunsichert, ob es an meinen "Lötkünsten" liegt.

Hier mal zwei Bilder meiner RTC mit den gelöteten Stellen.

http://s14.directupload.net/file/d/3317/aauzwokk_jpg.htm

http://s14.directupload.net/file/d/3317/aw4dbrv2_jpg.htm


Was sagt ihr dazu?

Falls es wirklich an den Lötkünsten liegen sollte, kennt ihr einen Shop bei dem ich eine RTC mit direkt angelöteter Stiftleiste beziehen kann?


Gruß

Serenifly

#7
Jul 15, 2013, 01:08 am Last Edit: Jul 16, 2013, 12:24 pm by Serenifly Reason: 1
Solche Ballen entstehen wenn das Lötzinn nicht heiß genug ist. Normalerweise macht man die Lötstelle kurz heiß, führt gleichzeitig Lötzinn nach und das Lötzinn läuft von selbst nach unten. Wenn man dann den Lötkolben weg nimmt streift man es etwas an dem Pin entlang und man hat einen schönen Kegel. Dazu gehört aber Erfahrung was die Temperatur und Eigenschaften des Lötzinns angeht. Irgendwann hat man einfach raus wie es verläuft und kann es auch an der Farbe erkennen. Das hängt auch mit der Art des Lötzinns und des Lötkolbens zusammen und kann sich daher ändern. Anfangs sieht das aber bei den meisten Leuten grauenhaft aus :)

Dreh den Lötkolben vielleicht etwas weiter auf und mach den Pin nochmal heiß, damit es richtig verläuft. Der Trick dabei ist aber dass der Lötkolben gleich die richtige Temperatur hat, so dass man ihn nur kurz hinhalten muss. Normal sind ca. 300-350°C

jurs

#8
Jul 15, 2013, 09:51 am Last Edit: Jul 15, 2013, 05:43 pm by jurs Reason: 1

Nachdem gerad alles wunderbar funktioniert hat, geht jetzt wieder garnix mehr.

Es liegt wohl scheinbar doch an der Hardware als an allem anderen.

Bin da langsam leicht verunsichert, ob es an meinen "Lötkünsten" liegt.


Deinen Bildern nach zu urteilen könnte da wirklich mindestens eine "kalte Lötstelle" bei sein.

Was für Lot verwendest Du denn zum Löten: bleihaltiges oder bleifreies? Genaue Formelbezeichnung des Lots?

Hat der Lötkolben beim Löten eine saubere, zunderfreie Spitze?
Ich stecke meinen Lötkolben in Lötpausen immer von der Stromversorgung aus, damit er nicht heiß vor sich hinbruzzelt und dabei die Spitze dicke Oxidschichten ansetzt, und sich bildende Oxidschichten streife ich auf einem Packen Zeitungspapier ab, das ich als Lötunterlage verwende.

Außerdem ist ein wichtiges Hilfsmittel beim Löten für mich eine kleine Dose Kolophonium als Flußmittel, damit das Lot besser fließt. Sowas wie eBay Artikelnummer 290823356418. Hast Du sowas auch?

Aber nochmal zur Software, ich habe mal einen Sketch zum Testen der RTC gemacht. Der Sketch liest beim Programmstart die Zeit aus einer DS1307 und bildet daraus eine mit dem 16 MHz Arduino-Takt laufende Systemzeit. Einmal pro Minute wird die Synchronität zwischen DS1307 und Systemzeit geprüft und angezeigt.

Gestellt werden kann die Uhr über den seriellen Monitor mit einem solchen Kommando zum gleichzeitigen Setzen von Datum und Uhrzeit:
set tt.mm.jjjj hh:mm
z.B.:
set 15.7.2013 10:13
Wobei die Trennzeichen zwischen den Zahlen beliebig sind und sogar weggelassen werden können, nur die Reihenfolge Tag, Monat, Jahr, Stunden, Minuten (und optional auch Sekunden) muss stimmen.
set 15 7 2013 10 13
Teste mal, ob dieser Code läuft.
Er benötigt keine zusätzliche Time- oder RTC-Library, sondern nur <Wire.h>.

BTW: Als RTC "mit angelöteten Pins" gibt es unter eBay Artikelnummer 251208194968 ein DS3231 Modul vom Chinaversender. Zumindest was das Stellen und Auslesen der DS3231 betrifft ist diese vollkommen Softwarekompatibel zur DS1307, d.h. das nachfolgende Programm funktioniert wahlweise mit DS1307 oder DS3231. Die DS3231 geht allerdings viel genauer und soll nur eine Gangabweichung von weniger als 64 Sekunden pro Jahr haben.

"The message exceeds the maximum allowed length (9500 characters)", den Code poste ich daher im folgenden Beitrag gesondert.

jurs


Code: [Select]

/*******************************************************************
* Clock and clock adjust demo by "jurs" for German Arduino Forum *
* Hardware required: DS1307
******************************************************************/

#include <Wire.h>

// I2C Adresse der RTC
#define DS1307_I2C_ADDRESS 0x68

// Globale Variablen für die laufende Zeit
int stunden,minuten,sekunden,millisekunden;
int tage=1,wochentag=1 , monate=1, jahre=2013;

char wochentage[][3]={"SO","MO","DI","MI","DO","FR","SA"};

int dayOfWeek(int year, int month, int day)
/* Calculate day of week in proleptic Gregorian calendar. Sunday == 0. */
{
  int adjustment, mm, yy;
  adjustment = (14 - month) / 12;
  mm = month + 12 * adjustment - 2;
  yy = year - adjustment;
  return (day + (13 * mm - 1) / 5 + yy + yy / 4 - yy / 100 + yy / 400) % 7;
}

byte decToBcd(byte val)
// Convert decimal number to binary coded decimal
// Hilfsfunktion für die Echtzeituhr
{
  return ( (val/10*16) + (val%10) );
}

byte bcdToDec(byte val)
// Convert binary coded decimal to decimal number
// Hilfsfunktion für die Echtzeituhr
{
  return ( (val/16*10) + (val%16) );
}

void rtcReadDS1307(int &sekunden,int &minuten,int &stunden,int &wochentag,int &tage,int &monate,int &jahre)
// aktuelle Zeit aus RTC auslesen
{
// 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
  sekunden    = bcdToDec(Wire.read() & 0x7f);
  minuten     = bcdToDec(Wire.read());
  stunden     = bcdToDec(Wire.read() & 0x3f);  // Need to change this if 12 hour am/pm
  wochentag   = bcdToDec(Wire.read());
  tage        = bcdToDec(Wire.read());
  monate      = bcdToDec(Wire.read());
  jahre       = bcdToDec(Wire.read())+2000; 
}

void rtcWriteDS1307(int &sekunden,int &minuten,int &stunden,int &wochentag,int &tage,int &monate,int &jahre)
// aktuelle Zeit in der RTC speichern
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.write(0);
  Wire.write(decToBcd(sekunden));    // 0 to bit 7 starts the clock
  Wire.write(decToBcd(minuten));
  Wire.write(decToBcd(stunden));      // If you want 12 hour am/pm you need to set
                                   // bit 6 (also need to change readDateDs1307)
                                 
  Wire.write(decToBcd(wochentag));
  Wire.write(decToBcd(tage));
  Wire.write(decToBcd(monate));
  Wire.write(decToBcd(jahre-2000));
  Wire.endTransmission(); 
}


void tickOneSecond()
// Systemzeit eine Sekunde weiterschalten
{
  byte daysInMonth[12]={31,28,31,30,31,30,31,31,30,31,30,31};
  sekunden++;
  if (sekunden>=60) {
    sekunden=0;
    minuten++;
  }
  else return;
  if (minuten>=60) {
    minuten=0;
    stunden++;
  }
  else return;
  if (stunden>=24) {
    stunden=0;
    tage++;
    wochentag++;
  }
  else return;
  if (wochentag>=7) wochentag=0;
  if( monate==2 && tage>=28) // könnte das Jahr einen 29.02. haben?
    if (jahre % 4 == 0) daysInMonth[2-1]=29; else daysInMonth[2-1]=28;
  if (tage>daysInMonth[monate-1])
  {
    tage=1;
    monate++;
  }
  if (monate>12)
  {
    monate=1;
    jahre++;
  } 
}

void keepTimeRunning()
// Diese Funktion muss in der loop laufend aufgerufen werden,
// damit die Systemzeit weiterläuft
{
  // Sekundenzähler
  static unsigned long prevMillis;
  while( millis() - prevMillis >= 1000){     
    tickOneSecond();
    prevMillis += 1000;
  }
  millisekunden=millis() - prevMillis;
  if (millisekunden>=1000) millisekunden=999;
}


char linebuf[81];


int getIntFromString (char *stringWithInt, byte num)
// input: pointer to a char array
// returns an integer number from the string (positive numbers only!)
// num=1, returns 1st number from the string
// num=2, returns 2nd number from the string, and so on
{
  char *tail;
  while (num>0)
  {
    num--;
    // skip non-digits
    while ((!isdigit (*stringWithInt))&&(*stringWithInt!=0)) stringWithInt++;
    tail=stringWithInt;
    // find digits
    while ((isdigit(*tail))&&(*tail!=0)) tail++;
    if (num>0) stringWithInt=tail; // new search string is the string after that number
  } 
  return(strtol(stringWithInt, &tail, 0));


void commandSync()
{
  rtcReadDS1307(sekunden, minuten, stunden, wochentag, tage, monate, jahre);       // Zeit aus der Echtzeituhr auslesen
  Serial.println(F("Datum und Zeit mit RTC synchronisiert."));
}

void commandDateTime(char* command, boolean set)
{
  int newtage=getIntFromString(command,1);
  int newmonate=getIntFromString(command,2);
  int newjahre=getIntFromString(command,3);
  int newstunden=getIntFromString(command,4);
  int newminuten=getIntFromString(command,5);
  if (newjahre<2000 || (newstunden+newminuten)<1) return; // keine gültigen Werte
  int newsekunden=getIntFromString(command,6);
  int newwochentag=dayOfWeek(newjahre,newmonate,newtage);
  if (set) // Neue Zeit in RTC schreiben
  {
    rtcWriteDS1307(newsekunden, newminuten, newstunden, newwochentag, newtage, newmonate, newjahre);       // neue Zeit in die Echtzeituhr schreiben
    Serial.println(F("RTC-Zeit neu gesetzt."));
  }
  else
  {
    long rtcDrift=newtage*86400L+newstunden*3600L+newminuten*60L+newsekunden;
    rtcDrift-= tage*86400L+ stunden*3600L+ minuten*60L+ sekunden;
    Serial.print(F("Eingegebene Zeit minus Systemzeit = RTC-Drift: "));
    Serial.print(rtcDrift);
    Serial.println(F(" Sekunden"));
  } 
}
 
void handleCommand()
// Kommandos von der seriellen Schnittstelle auslesen und verarbeiten
{
  static int i=0;
  static char commandline[41];
  if (!Serial.available()) return;
  while (Serial.available())
  {
    commandline[i]=Serial.read();
    if (commandline[i]==13)
    {
      if (strstr(commandline,"sync")==commandline) commandSync();
      else if (strstr(commandline,"set")==commandline) commandDateTime(commandline,true);
      else commandDateTime(commandline,false);
      i=0;
    }
    else if (commandline[i]<32)
      commandline[i]='\0';   
    else
    { 
      commandline[i+1]='\0';
      if (i<sizeof(commandline)-1) i++;
    } 
  }
}



void showTimeDiff()
{
  int tag,wtag,mon,jahr,std,min,sec;
  byte cursek;
  unsigned long millidiff;
  millidiff=millis();
  rtcReadDS1307(sec, min, std, wtag, tag, mon, jahr);       // Zeit aus der Echtzeituhr auslesen
  cursek=sec;
  do
    rtcReadDS1307(sec, min, std, wtag, tag, mon, jahr);       // Zeit aus der Echtzeituhr auslesen
  while(sec==cursek);
  millidiff=millis()-millidiff;
  long time1,time2,timediff;
  time1=stunden*3600000L+minuten*60000L+sekunden*1000L+millidiff;
  time2=std*3600000L+min*60000L+sec*1000L;
  timediff=time1-time2;
  snprintf_P(linebuf,sizeof(linebuf),PSTR("%s %02d.%02d.%04d  %02d:%02d:%02d Diff: %ld ms"),wochentage[wochentag], tage, monate, jahre, stunden,minuten,sekunden,timediff);
  Serial.println(linebuf);
}

void setup() 
{
  Serial.begin(9600);  // Serielle Schnittstelle auf 9600 Baud starten
  Serial.println();
  Serial.println(F("RTC demo for DS1307 clock by 'jurs' for German Arduino Forum"));
  Serial.println(F("This program shows a 'system time' each 10 seconds on serial monitor"));
  Serial.println(F("Each full minute the time difference between RTC and system time is shown as 'Diff:'"));
  Serial.println();
  Serial.println(F("These serial commands are interpreted:"));
  Serial.println(F("set dd.mm.yyyy hh:mm:ss  ==> Set RTC to new date and time"));
  Serial.println(F("sync                     ==> Reads current time from RTC into system time"));
  Serial.println();
  Wire.begin();        // initialisiert die Wire-Library
  keepTimeRunning();
  commandSync();
}


void loop()
{
  static byte lastSecond;
  keepTimeRunning();
  handleCommand();
  if (lastSecond==sekunden) return;
  lastSecond=sekunden;
  if (sekunden%60==0) showTimeDiff();
  else if (sekunden%10==0)
  {
    snprintf_P(linebuf,sizeof(linebuf),PSTR("%s %02d.%02d.%04d  %02d:%02d:%02d"),wochentage[wochentag], tage, monate, jahre, stunden,minuten,sekunden);
    Serial.println(linebuf);
  } 
}


Serenifly


Außerdem ist ein wichtiges Hilfsmittel beim Löten für mich eine kleine Dose Kolophonium als Flußmittel, damit das Lot besser fließt. Sowas wie eBay Artikelnummer 290823356418. Hast Du sowas auch?

Habe ich noch nie wirklich gebraucht, da es normalerweise im Lötzinn enthalten ist.

Es lag nun, schlussendlich an einer Lötstelle, welche sich durch mehrmaliges aufstecken der RTC auf ein Breadboard gelöst hatte. Habs heute/gestern nochmal neu gelötet. Jetzt funktioniert wieder alles und es heißt jetzt für mich, lass dass System arbeiten :D.

Nicht mehr dran rumspielen :D.

Vielen Dank nochmal an alle für die tolle Hilfe!

uwefed

Lötsellen müßten so sei, daß sie mehrmaliges Anstecken vertragen. Für Nicht-LötProfis ist aber eine gute Lötstelle nicht so einfach zu realisieren. Oft haben sie Angst die Platine / Bauteil zu überhitzen und somit erwärmen sie die Lötstelle nicht genug um das Lötzinnn zu schmelzen und gut verrinnen zu lassen.

Fehlerhafte Lötstellen sind für uns Ratgeber sehr schwer zu finden, da wir annehmen, daß die Lötstellen in Ordnung sind.

Gratuliere für die Fehlerdiagnose.
Grüße Uwe

sth77

Ergänzend zu Uwes Beitrag: Das Schöne ist aber, dass man mit jeder Lötverbindung immer besser im Löten wird. Auch hier macht Übung den meister. Also dranbleiben und basteln was das Zeug hält... ;)
Mein Arduino-Blog: http://www.sth77.de/ - letzte Einträge: Teensy 3.0 - Teensyduino unter Window 7 - Teensyduino unter Windows 8

guntherb

Nicht umsonst müssen unsere Azubis erstmal ein paar Lochrasterplatten mit jeweils einigen hundert Lötstellen produzieren!

Mach das doch auch mal: eine Lochrasterplatte, Schaltdraht, und dann sinnfreie Muster mit Drahtbrücken erstellen!
oder nur aus Draht geometrische Drahtmodelle löten. Google doch mal nach "lötübung"
Grüße
Gunther

Go Up