Seltsames Arduino Serial Read verhalten

[cableer (Gast)]

Hallo zusammen,

mein kleines Projekt mit RTC und LCD stellt mich für ein für mich 
merkwürdiges verhalten. Ich sende die Zeitdaten über eine serielle 
Schnitstelle an den Arduino Uno. Allerdings werden diese nur sporadisch 
auch in die variablen für stunde sekunde etc. eingetragen. Im 
beigefügten Screenshot sieht man dass erst beim letzen versuch die Daten 
gespeichert und Datum und Uhrzeit korrekt ausgegeben wurde. Zuvor wurden 
die daten zwar korrekt übertragen (Siehe fälschliche Ausgabe als Control 
Byte) jedoch in der Routine für das schreiben der Daten auf die RTC von 
den Serial Reads offensichtlich nicht aus dem Puffer gelesen.

Nach einigen schnell aufeinander foglenden Resends der Daten aus der 
Konsole geht es dann. Ich kann den fehler nicht finden :(

#include <LiquidCrystal_I2C.h>
#include <Wire.h>

int clockAddress = 0x68; 
int alarmstatus = 0; 
long previousmillis = 0;
int pageswitch = 1;
int command = 0;    
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year, alarmhour, alarmminute, alarmsecond, alarmday, alarmdayofmonth, alarmmonth, alarmyear;
byte test; 
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);


//###########################################BDC Math ###############################################################

byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}


byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}


//############################################Set Alarm Time###############################################################

void setAlarmTime()
{
  Serial.println("in Set Alarm Mode");
  alarmdayofmonth = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  alarmmonth = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  alarmyear = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  pageswitch = 1; 
  alarmstatus = 0; 
  Serial.println(String("New Expiration Date: ") + String(alarmdayofmonth) + String("/") + String(alarmmonth) + String("/") + String(alarmyear));
}



//############################################Display page Selector###############################################################

  void displaypage( int pageselector)
  {
    String line0; 
    String line1; 
    String line2;
    String line3;
    
    if(pageselector == 1)
    {
       line0 = String("NOW: ") + String(dayOfMonth)+ String("/")+  String(month) + String("   ") + String(hour)+String(":")+String(minute);
       line1 = String("Vitralit 7041T");
       line2 = String("DUE DATE:");
        line3 = String("LLOC: 1LRZ");

      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print(line0);
      lcd.setCursor(0,1);
      lcd.print(line1);
      lcd.setCursor(0,2);
      lcd.print(line2);
      lcd.setCursor(0,3);
      lcd.print(line3);
    }
    else if (pageselector == 2)
    {
      String line0 = String("CHANGE GLUE IMMEDIATELY"); 
            lcd.clear();
      lcd.setCursor(0,0);
      lcd.print(line0);
    }
  }


//############################################Alarm###############################################################


void checkAlarm()
{
  if(alarmdayofmonth==dayOfMonth && alarmmonth == month)
  {
    alarmstatus = 1;
    pageswitch = 2; 
  } 
}


//############################################Write Data to RTC###############################################################

void setDateDs1307()                
{
  Serial.println("In set Mode");  
  second = (byte) ((Serial.read() - 48) * 10 + (Serial.read() - 48)); 
  minute = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  hour  = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  dayOfWeek = (byte) (Serial.read() - 48);
  dayOfMonth = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  month = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  year= (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  Wire.beginTransmission(clockAddress);
  Wire.write(byte(0x00));
  Wire.write(decToBcd(second));  // 0 to bit 7 starts the clock
  Wire.write(decToBcd(minute));
  Wire.write(decToBcd(hour));    

  Wire.write(decToBcd(dayOfWeek));
  Wire.write(decToBcd(dayOfMonth));
  Wire.write(decToBcd(month));
  Wire.write(decToBcd(year));
  Wire.endTransmission();

  Serial.print(hour, DEC);
  Serial.print(":");
  Serial.print(minute, DEC);
  Serial.print(":");
  Serial.print(second, DEC);
  Serial.print("  ");
  Serial.print(month, DEC);
  Serial.print("/");
  Serial.print(dayOfMonth, DEC);
  Serial.print("/");
  Serial.println(year, DEC);
}


//############################################Read Data from RTC###############################################################


void getDateDs1307() {

  Wire.beginTransmission(clockAddress);
  Wire.write(byte(0x00));
  Wire.endTransmission();

  Wire.requestFrom(clockAddress, 7);


  second     = bcdToDec(Wire.read() & 0x7f);
  minute     = bcdToDec(Wire.read());
  

  hour       = bcdToDec(Wire.read() & 0x3f);  
  dayOfWeek  = bcdToDec(Wire.read());
  dayOfMonth = bcdToDec(Wire.read());
  month      = bcdToDec(Wire.read());
  year       = bcdToDec(Wire.read());
}

//############################################Setup###############################################################


void setup() 
{
  Wire.begin();
  Serial.begin(57600);

//--------------------Blink Display on Startup-----------------------  
  lcd.begin(20,4);
   for(int i = 0; i< 3; i++)
  {
    lcd.backlight();
    delay(250);
    lcd.noBacklight();
    delay(250);
  }
  lcd.backlight();
}


//############################################Main###############################################################


void loop() 
{
//---------------Serial Interface ---------------------------------------------
  if (Serial.available()) {
    command = Serial.read();
    if (command == 84) {     
      setDateDs1307();
      getDateDs1307();
      Serial.println("Done With Set ");
    }
    else if (command == 65)
    {
      getDateDs1307();
      
      Serial.println(" ");
    } 

    else if (command == 66)
    {
     setAlarmTime();
      Serial.println("Set Alarm Time: ");
    } 
    
    Serial.print("Done Withc Commad: ");
    Serial.println(char(command));  
  }
  
  command = 0;                 



//-------display update routine------------------------------------
  if(millis()-previousmillis > 1000)
  {
    previousmillis = millis();
    getDateDs1307();
    checkAlarm();
    displaypage(pageswitch);
  } 
}

[cableer (Gast)]

anyone? :(

[Einer K. (Gast)]

cableer schrieb:
> anyone? :(
Doch doch...

cableer schrieb:
> Serial.read()
Evtl hast du vergessen die Doku zu lesen.....
Tipp:
Mach das mal...
(den Rest habe ich mir noch gar nicht angesehen)

[Joachim B. (jar)]

warum nutzt du nicht die Arduino LIB? DS1307new
die DS1307 ist zickig


in setup teste ich ob RTC vorhanden und wenn ja welche

#if (ARDUINO>0)
  DEBUG_PRINTLN(F(" -> Scanning..."));

  byte error, address;
  int nDevices=0;
  for(address = 1; address < 127; address++ ) 
  { // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();

    if (error == 0)
    { DEBUG_PRINT(F("I2C device found at address 0x"));
      if (address<16) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINT_DEC_HEX(address,HEX);
      DEBUG_PRINT(F("; "));
      if (address<64) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINT_DEC_HEX(address,BIN);
      DEBUG_PRINT(F("x; << 0x"));
      DEBUG_PRINT_DEC_HEX((address<<1),HEX);
      DEBUG_PRINT(F("; "));
      if ((address<<1)<128) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINT_DEC_HEX((address<<1),BIN);
      
      switch(address<<1)
      { case 0xA0:
          DEBUG_PRINTLN(F(" I2C EEPROM       "));
          i2c_test_flags|=(1<<I2C_EEPROM);          
          break;
        case 0xD0:
          Wire.beginTransmission(DS1307_ID);
          printIIC(0x3F);
          (Wire.endTransmission()) ? i2c_test_flags|=(1<<I2C_RTC_3231) : i2c_test_flags|=(1<<I2C_RTC_1307);
          #ifdef DEBUG
          (i2c_test_flags&(1<<I2C_RTC_3231)) ? Serial.println(F(" DS3231 RTC ")) : Serial.println(F(" DS1307 RTC "));
          #endif
          break;
        default:
          DEBUG_PRINTLN(F(""));
          break;
      }
      nDevices++;
    }
    else if (error==4) 
    { DEBUG_PRINT(F("Unknow error at address 0x"));
      if (address<16) 
        DEBUG_PRINT(F("0"));
      DEBUG_PRINTLN_DEC_HEX(address,HEX);
    }    
  }
  if (nDevices == 0)
    DEBUG_PRINTLN(F("No I2C devices found"));
  else
    DEBUG_PRINTLN(F("done"));
  DEBUG_PRINTLN(F(""));

 #ifdef I2C_RTC
  //test_rtc_1307_3231
  if( i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307) )
  { RTC.getTime();
    sprintf(r_str, "%04d/%02d/%02d__%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second);
    DEBUG_PRINT(F("clock   ")); DEBUG_PRINTLN(r_str);
 #ifdef DEBUG
    (strcmp(c_str, r_str)>0) ? Serial.println(F("compile > RTC ")) : Serial.println(F("compile < RTC "));
 #endif // #ifdef DEBUG
    if(strcmp(c_str, r_str)>0)
    { if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.stopClock();
      RTC.fillByHMS( atoi(mids(c_str,13,2)), atoi(mids(c_str,15,2)), atoi(rights(c_str,2)) );
      RTC.fillByYMD( atoi(lefts(c_str,4)), atoi(mids(c_str,6,2)), atoi(mids(c_str,9,2)) );
      RTC.setTime();
      if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.startClock();
 #ifdef DEBUG
      (i2c_test_flags&(1<<I2C_RTC_3231)) ? Serial.println(F(" DS3231 RTC ist gestellt")) : Serial.println(F(" DS1307 RTC ist gestellt"));
      RTC.getTime();
      sprintf(r_str, "%04d/%02d/%02d__%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second); 
      Serial.print(F("RTC: ")); Serial.println(r_str);
 #endif // #ifdef DEBUG
      if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
      DEBUG_PRINTLN(F(""));
    } // if(strcmp(c_str, r_str)>0)
    RTC.getTime();
    sprintf(r_str, "%04d/%02d/%02d__%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second); 
  } // if( i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307) )
  else
  { DEBUG_PRINTLN(F(""));
    DEBUG_PRINT(F("compile ")); DEBUG_PRINT(c_str);
    DEBUG_PRINTLN(F(""));
  } // !( i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307) )
 #endif // #ifdef I2C_RTC

  DEBUG_PRINTLN(F(""));
  DEBUG_PRINTLN(F("Testflags "));
 #ifdef I2C_RTC
  if(i2c_test_flags&(1<<I2C_RTC_3231))
    DEBUG_PRINTLN(F("I2C_RTC_3231      "));
  if(i2c_test_flags&(1<<I2C_RTC_1307))
    DEBUG_PRINTLN(F("I2C_RTC_1307      "));
  if(i2c_test_flags&(1<<I2C_EEPROM))
  { DEBUG_PRINT(F("I2C_EEPROM        ")); DEBUG_PRINT(my_i2c_eeprom_size()); DEBUG_PRINT(F(" Byte, ee_size 0x")); DEBUG_PRINTLN_DEC_HEX(my_i2c_eeprom_size(), HEX);
  }
 #endif // #ifdef I2C_RTC

  if(!(i2c_test_flags&(255)))
    DEBUG_PRINTLN(F("keine Testflags   "));
  DEBUG_PRINTLN(F(""));
#endif // #if (ARDUINO>0)

die DS1307 braucht für set eine Sonderbehandlung

if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.stopClock();
      RTC.fillByHMS( atoi(mids(c_str,13,2)), atoi(mids(c_str,15,2)), atoi(rights(c_str,2)) );
      RTC.fillByYMD( atoi(lefts(c_str,4)), atoi(mids(c_str,6,2)), atoi(mids(c_str,9,2)) );
      RTC.setTime();
      if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.startClock();

[cableer (Gast)]

Bitte schaut auch den Screenshot an. Das Problem liegt nicht beim 
Handling der RTC. Das Problem liegt beim holen der Daten aus dem 
Seriellen Stream von PC.

Von Zeit zu zeit Liest er in der Set Routine nicht die Daten aus dem 
Fifo. Erst der

    Serial.print("Done Withc Commad: ");
    Serial.println(char(command));

Teil schreibt dann zeile für zeile die daten raus, die eigentlich in

void setDateDs1307()
{
  Serial.println("In set Mode");
  second = (byte) ((Serial.read() - 48) * 10 + (Serial.read() - 48));
  minute = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  hour  = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  dayOfWeek = (byte) (Serial.read() - 48);
  dayOfMonth = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 
48));
  month = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
  year= (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));

ausgelesen hätten werden sollen.

[cableer (Gast)]

Arduino F. schrieb:
> cableer schrieb:
>> anyone? :(
> Doch doch...
>
> cableer schrieb:
>> Serial.read()
> Evtl hast du vergessen die Doku zu lesen.....
> Tipp:
> Mach das mal...
> (den Rest habe ich mir noch gar nicht angesehen)

Das zeigt nur, dass du nicht alle Informationen die ich zur Verfügung 
gestellt habe gelesen/angesehen hast.

Serial.read() sollte Byteweise aus dem Puffer lesen. Die Bytes sollten 
dann NICHT MEHR im Puffer stehen, so wie ich die Doku interpretiere.

[Einer K. (Gast)]

cableer schrieb:
> Das zeigt nur, dass du nicht alle Informationen die ich zur Verfügung
> gestellt habe gelesen/angesehen hast.
Stimmt!
Aber es hat gereicht, um wenigstens einen Fehler zu finden.


cableer schrieb:
> so wie ich die Doku interpretiere.
Daran kannst du noch arbeiten ;-)


cableer schrieb:
> Serial.read() sollte Byteweise aus dem Puffer lesen.
Ja! "sollte"
Und was passiert, wenn der Buffer leer ist?

[cableer (Gast)]

Arduino F. schrieb:
> cableer schrieb:
>> Serial.read() sollte Byteweise aus dem Puffer lesen.
> Ja! "sollte"
> Und was passiert, wenn der Buffer leer ist?

Wenn du dir die  mühe machen würdest die Bilder anzusehen und meine 
Antwort richtig zu lesen wüsstest du dass der Buffer nicht leer ist. Es 
wird ja der gesamte inhalbt, exact das was ich auch gesehen habe, 
ausgegeben, allerdings erst NACH der set routine.

[Einer K. (Gast)]

cableer schrieb:
> allerdings erst NACH der set routine.
Ja...
Dann hat die Set Routine wohl nur eine Handvoll -1 bekommen.

cableer schrieb:
> dass der Buffer nicht leer ist.
Wo soll ich das sehen?
Ein einziges mal prüft du, ob was im Bufffer ist.
Den Rest der Zeit geht dir das offensichtlich am Ars*h vorbei.

[cableer (Gast)]

Arduino F. schrieb:
> cableer schrieb:
>> allerdings erst NACH der set routine.
> Ja...
> Dann hat die Set Routine wohl nur eine Handvoll -1 bekommen.

Die Set routine wird aber vom ersten byte des eingehenden streams erst 
geriggert. Das macht so keinen Sinn.

[Einer K. (Gast)]

cableer schrieb:
> Die Set routine wird aber vom ersten byte des eingehenden streams erst
> geriggert.
Und dann kommen zverlässig weitere Byte rein, so dann man gar nicht 
prüfen muss, ob da eins ist...
Nee... sowas tuts nur in der Fantasie

[cableer (Gast)]

cableer schrieb:
> rduino F. schrieb:
>> cableer schrieb:
>>> allerdings erst NACH der set routine.
>> Ja...
>> Dann hat die Set Routine wohl nur eine Handvoll -1 bekommen.
>
> Die Set routine wird aber vom ersten byte des eingehenden streams erst
> geriggert. Das macht so keinen Sinn.


Oder meinst du, dass die routine abgearbeitet wird bevor der buffer 
tatsächlich ALLE daten enthält? Ich werde mal ein delay einbauen. Danke 
für den Hinweis!

[Joachim B. (jar)]

cableer schrieb:
> Das Problem liegt beim holen der Daten aus dem
> Seriellen Stream von PC.

Arduino F. schrieb:
> Und was passiert, wenn der Buffer leer ist?

gute Einwände, darauf habe ich nicht geachtet, ich habe mich nur auf die 
Sonderbehandlung mit stop / start der DS1307 gestürzt.

Der TO muss auch noch mehr lernen (wie ich auch)

aber klar richtig einsammeln muss man auch aus serial.....

// --------------- serial in ---------------
  if (Serial.available() > 0) 
  { char incomingByte = (char)Serial.read();
    if(incomingByte == 13)  // Wenn das Enter ankommt
    { strcpy(serial_in_command, serial_in_buff);
      chr_cnt = 0;
      strcpy(serial_in_buff,"");
    }
    else // Falls kein Enter kommt muss der Text gespeichert werden in dem inText Array
    { if(isprint(incomingByte))
        serial_in_buff[chr_cnt++] = incomingByte;
    }
  } // if (Serial.available() > 0) 
  
  if(strlen(serial_in_command))
  { Serial.println(F("")); Serial.print(serial_in_command);  Serial.println(F(" -> erkannt")); 
          
    if( !strcmp(serial_in_command, "help") || ( !strcmp(serial_in_command, "?") && strlen(serial_in_command)==1 ) )
    { // help screen
      Serial.println(F("\ncommands: \n"));
  
      Serial.println(F("setdate2015/01/15"));
      Serial.println(F("getdate"));
  
      Serial.println(F("settime17:22:30"));
      Serial.println(F("gettime"));
      Serial.println(F("reset"));
      Serial.println(F(""));
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    }

    if( strstr(serial_in_command, "setdate") )
    { // "setdate2014/10/05"  setdate2015/01/15
      if(strlen(serial_in_command)>=17) 
      { if( (i2c_test_flags&(1<<I2C_RTC_1307)) | (i2c_test_flags&(1<<I2C_RTC_3231)) )
        { uint16_t jjjj=atoi(strncpy(serial_in_buff, &serial_in_command[7], 4));
          if( jjjj >= atoi(strncpy(serial_in_buff, c_str, 4)) )
          { uint8_t mo = atoi(strncpy(serial_in_buff, &serial_in_command[12], 2)); 
            if(mo && mo<13) 
            { uint8_t ta=atoi(rights(serial_in_command, 2));
              if(!(ta>0 && ta<= Monatstage(jjjj, mo))) 
                ta=0;
              if(ta)  
              { RTC.getTime();
                sprintf(r_str, "%04d/%02d/%02d_%02d:%02d:%02d", jjjj, mo, ta, RTC.hour, RTC.minute, RTC.second); 
                if(strncmp(r_str, (char *)&c_str[0], 8)>0) DEBUG_PRINTLN(F("compile > inputdatetime -> nicht gestellt"));
                if(strncmp(r_str, c_str, 6)<0) 
                { DEBUG_PRINTLN(F("compile < inputdatetime "));
                } // if(strncmp(r_str, c_str, 6)<0) 
                if(!strncmp(c_str, r_str, 6)) 
                { DEBUG_PRINTLN(F("strncmp(c_str, r_str, 6)")); 
                  DEBUG_PRINT(F("c ")); DEBUG_PRINTLN(c_str);
                  DEBUG_PRINT(F("e ")); DEBUG_PRINTLN(r_str);
                  DEBUG_PRINTLN(F("compile == inputdatetime "));
                }
              } // if(ta)        
              else
              { DEBUG_PRINTLN(F("ERROR TA=0 RTC nicht gestellt !"));
                memset(&serial_in_command[0], 0, sizeof(serial_in_command));
                memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
              }
            } // if(mo)
            else
            { DEBUG_PRINTLN(F(" -> ERROR !MO oder (JahrMonat < compile), RTC nicht gestellt !"));
              memset(&serial_in_command[0], 0, sizeof(serial_in_command));
              memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
            }
          } // if( jjjj >= atoi(lefts(c_str, 4)) )
          else
          { DEBUG_PRINTLN(F(" -> ERROR (jjjj < compile), RTC nicht gestellt !"));
            memset(&serial_in_command[0], 0, sizeof(serial_in_command));
            memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
          }
        } // if(i2c_test_flags&(1<<RTC_CHIP))
      } // if(strlen(serial_in_command)>=17)
      else
      { Serial.print(F("\"")); Serial.print(serial_in_command); Serial.println(F("\" ->zu kurz, min. 17 Zeichen\"setdate2014/10/05\"")); 
        memset(&serial_in_command[0], 0, sizeof(serial_in_command));
        memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
      }
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    } // if(strstr(serial_in_buff, "setdate"))
    
    if( strstr(serial_in_command, "getdate") )
    { // "getdate"
      sprintf((char *)serial_in_buff,"%s %02d.%s %04d", strWochentagname_kurz( wochentag_im_jahr(RTC.year, tagesnummer( RTC.year, RTC.month, RTC.day )) ), RTC.day, lefts(strMonatsname(RTC.month), 3), RTC.year);
      Serial.println(serial_in_buff);
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    } // if( strstr(serial_in_command, "getdate") )
  
    if( strstr(serial_in_command, "settime") )
    { // "settime17:22:30" 
      if(strlen(serial_in_command)>=15) 
      { if( (i2c_test_flags&(1<<I2C_RTC_1307)) | (i2c_test_flags&(1<<I2C_RTC_3231)) )
        { uint8_t hh=atoi(strncpy(serial_in_buff, &serial_in_command[7], 2));
          if( 0 <= hh && hh < 24)
          { uint8_t mm = atoi(strncpy(serial_in_buff, &serial_in_command[10], 2)); 
            if( 0 <= mm && mm < 60)
            { uint8_t ss=atoi(rights(serial_in_command, 2));
              if( 0 <= ss && ss < 60)
              { RTC.fillByHMS( hh, mm, ss );
                sprintf(r_str, "%02d:%02d:%02d", RTC.hour, RTC.minute, RTC.second); 
if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.stopClock();                RTC.setTime();
if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.startClock();                (i2c_test_flags&(1<<I2C_RTC_3231)) ? Serial.println(F(" DS3231 RTC ist gestellt")) : Serial.println(F(" DS1307 RTC ist gestellt"));
                RTC.getTime();
                sprintf(r_str, "%04d/%02d/%02d_%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second);
                Serial.println(r_str); Serial.println();
              } // if(ss)        
              else
              { DEBUG_PRINTLN(F("ERROR ss Fehler RTC nicht gestellt !"));
              }
            } // if(mm)
            else
            { DEBUG_PRINTLN(F("ERROR mm Fehler RTC nicht gestellt !"));
            }
          } // if(hh)
          else
          { DEBUG_PRINTLN(F("ERROR hh Fehler RTC nicht gestellt !"));
          }
        } // if(i2c_test_flags&(1<<RTC_CHIP))
      } // if(strlen(serial_in_command)>=15)
      else
      { Serial.print(F("\"")); Serial.print(serial_in_command); 
        Serial.print(F("\" ->zu kurz: ")); Serial.print(strlen(serial_in_command)); 
        Serial.println(F(", min. 15 Zeichen\"settime17:22:30\"")); 
      }
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    } // if(strstr(serial_in_buff, "settime"))

    if( strstr(serial_in_command, "gettime") )
    { // "gettime"
      sprintf((char *)serial_in_buff,"%02d:%02d:%02d", RTC.hour, RTC.minute, RTC.second);
      Serial.print(serial_in_buff); Serial.println(F(" Uhr"));
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    } // if( strstr(serial_in_command, "gettime") )

    if( !strcmp(serial_in_command, "reset") )
    { // "reset"
      {asm("ldi r30,0"); asm("ldi r31,0"); asm("ijmp");}
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    } // if( !strcmp(serial_in_command, "reset") )
  
    if(strlen(serial_in_command))
    { memset(&serial_in_command[0], 0, sizeof(serial_in_command));
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
    }
  } // if(strlen(serial_in_command))

[Einer K. (Gast)]

cableer schrieb:
> Ich werde mal ein delay einbauen.

Das ist mit Abstand die schlechteste Lösung.

[Joachim B. (jar)]

es fehlt noch die Abfrage das es keinen Überlauf im In Buffer gibt.

[cableer (Gast)]

Problem solved. Jetzt habe ich auch verstanden was du mir genau sagen 
wolltest. Die Daten brauchen tatsächlich länger als der Durchlauf der 
Routine. Und das selbst bei 57600 Baud. Das hätte ich so nicht vermutet.

Also, besten Dank für's Helfen!

[cableer (Gast)]

Joachim B. schrieb:
> es fehlt noch die Abfrage das es keinen Überlauf im In Buffer gibt.

Ich weiß, das Programm ist auch bei Weitem noch nicht fertig. Ich wollte 
nur ein kurzes "proof of concept" machen um zu sehen ob es in etwa so 
wird wie ich mir das vorstelle. Jetzt, da es tut, geht es an die 
Feinheiten.

[Joachim B. (jar)]

cableer schrieb:
> Oder meinst du, dass die routine abgearbeitet wird bevor der buffer
> tatsächlich ALLE daten enthält?

cableer schrieb:
> Problem solved.

das glaube ich nicht, jedenfalls mit delay ist Mist!

[Axel R. (Gast)]

hättest Du es als *.ino anhängen können? Gäbe sicher mehr Resonanz.

StromTuner

[Einer K. (Gast)]

Joachim B. schrieb:
> Der TO muss auch noch mehr lernen (wie ich auch)
Das will ich auch....

cableer schrieb:
> Das hätte ich so nicht vermutet.
Ungeprüfte Annahmen sind oft genug die Grundbausteine des Versagens.




cableer schrieb:
> Also, besten Dank für's Helfen!
Gern geschehen.

[Joachim B. (jar)]

Axel R. schrieb:
> hättest Du es als *.ino anhängen können? Gäbe sicher mehr Resonanz.
>
> StromTuner

hmmm, klar aber es sind nur Bausteine und eigentlich auch mit kleinen 
Umbauten als C zu gebrauchen, ich wechsel manchmal zwischen AVR Studio 
und Arduino, deswegen:

Joachim B. schrieb:
> #if (ARDUINO>0)

Das ganze Ino braucht hier keiner und es ist ja noch nicht perfekt

[Cableer (Gast)]

Joachim B. schrieb:
> cableer schrieb:
> Oder meinst du, dass die routine abgearbeitet wird bevor der buffer
> tatsächlich ALLE daten enthält?
>
> cableer schrieb:
> Problem solved.
>
> das glaube ich nicht, jedenfalls mit delay ist Mist!

Ich habe es natürlich nicht als Delay implementiert sondern leere das 
fifo in einer Schleife bis zum carriage return.


Man muss nicht immer alles schlecht machen. Designs unterscheiden sich 
eben in konzeptphase und der ausgerollten Implementierung.

Klar kann man das auch selbst nachsehen. Alles per Hand machen. Am Ende 
braucht es halt manchmal ein zweites paar Augen.

[Joachim B. (jar)]

Cableer schrieb:
> Ich habe es natürlich nicht als Delay implementiert sondern leere das
> fifo in einer Schleife bis zum carriage return.

wo hattest du das geschrieben?

ich las nur:

cableer schrieb:
> Ich werde mal ein delay einbauen

cableer schrieb:
> Problem solved.

[Stefan F. (Gast)]

Als Chinesische Hersteller die Frechheit besaßen, PC's mit mehr als 8Mhz 
Taktfrequenz zu bauen, funktionierten einige prominente Programme 
plötzlich nicht mehr.

Die Programmierer konnten sich damals wohl nicht vorstellen, dass IBM 
kompatible PC's mal schneller sein würden. Deswegen hatten viele rechner 
damals den Turbo Schalter, damit konnte man sie heruntertakten.

Dann als später 386er auf den Markt kamen, vielen reihenweise Programme 
aus, die mit Borland Pascal geschrieben wurden. Prinzipiell aus dem 
selben Grund, dieses mal steckte der Fehler allerings in der 
Laufzeitbibliothek von Borland - nicht im Anwednungsprogramm.

Und in den 15 Jahren danach kenne ich weitere Beispiele. Ich habe daraus 
gelernt, dass Programme niemals von einer bestimmtem 
Ausführungsgeschwindigkeit abhängig sein sollen. Ja man sollte nichtmal 
davon ausgehen, dass die Geschwindigkeit nach Programmstart konstant 
ist.

Das ist bei µC jetzt nicht ganz so wichtig, ich rate dennoch dazu. Denn 
es wird nicht mehr lange dauern, bis auch "kleine" Mikrcocontroller 
nicht mehr mit Konstanter Geschwindigkeit laufen werden. Für 
Zeitmessungen nimmt man Timer, nicht CPU Leistung. Und damit 
Kommunikations-Schnittstellen später mal durch andere ausgetauscht 
werden können, sollte man sich auch dort nicht an feste 
Übertragungsraten gewöhnen. USB, Ethernet, Bluetooth, WLAN, SD Karten 
übertragen Daten nur unregelmäßig. An solche Verhältnisse sollte man 
sich gewöhnen.

Wenn das alle Programmierer schon länger verinnerlicht hätten, dann 
hätten wir jetzt nicht so viele serielle Geräte, die an USB Adaptern 
versagen.

[Einer K. (Gast)]

Stefan U. schrieb:
> Wenn das alle Programmierer schon länger verinnerlicht hätten, dann
> hätten wir jetzt nicht so viele serielle Geräte, die an USB Adaptern
> versagen.

Na na na ....

Da liegt der Hase aber woanders im Pfeffer..

Heutzutage wird gern/blauäugig auf jegliches Handshake, auf der 
seriellen, verzichtet.
Scheint irgendwie modern zu sein....
Aber vielleicht ist den meisten Entwicklern auch ein Handshake zu 
kompliziert....

Das war "Früher" undenkbar.
Wenigsten XON/XOFF sollte doch drin sitzen...

;-)

[Huh (Gast)]

Joachim B. schrieb:
> Cableer schrieb:
>> Ich habe es natürlich nicht als Delay implementiert sondern leere das
>> fifo in einer Schleife bis zum carriage return.
>
> wo hattest du das geschrieben?
>
> ich las nur:
>
> cableer schrieb:
>> Ich werde mal ein delay einbauen
>
> cableer schrieb:
>> Problem solved.

Beschwerst du dich jetzt, daß er gegebene Ratschläge angenommen hat und 
es richtig gemacht hat? Wäre es dir lieber gewesen, wenn er stattdessen 
doch das delay verwendet hätte? :-D
---leute jibbet---

[Joachim B. (jar)]

Huh schrieb:
> Beschwerst du dich jetzt, daß er gegebene Ratschläge angenommen hat

nein niemals, sondern das er nicht geschrieben hat wie!

Huh schrieb:
> ---leute jibbet---

jenau, du hast auch schon mal besser verstanden!

oder gibts von huh auch fakes wie von MaWin?