Forum: Mikrocontroller und Digitale Elektronik Seltsames Arduino Serial Read verhalten


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
von cableer (Gast)


Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
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 :(
1
#include <LiquidCrystal_I2C.h>
2
#include <Wire.h>
3
4
int clockAddress = 0x68; 
5
int alarmstatus = 0; 
6
long previousmillis = 0;
7
int pageswitch = 1;
8
int command = 0;    
9
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year, alarmhour, alarmminute, alarmsecond, alarmday, alarmdayofmonth, alarmmonth, alarmyear;
10
byte test; 
11
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
12
13
14
//###########################################BDC Math ###############################################################
15
16
byte decToBcd(byte val)
17
{
18
  return ( (val/10*16) + (val%10) );
19
}
20
21
22
byte bcdToDec(byte val)
23
{
24
  return ( (val/16*10) + (val%16) );
25
}
26
27
28
//############################################Set Alarm Time###############################################################
29
30
void setAlarmTime()
31
{
32
  Serial.println("in Set Alarm Mode");
33
  alarmdayofmonth = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
34
  alarmmonth = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
35
  alarmyear = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
36
  pageswitch = 1; 
37
  alarmstatus = 0; 
38
  Serial.println(String("New Expiration Date: ") + String(alarmdayofmonth) + String("/") + String(alarmmonth) + String("/") + String(alarmyear));
39
}
40
41
42
43
//############################################Display page Selector###############################################################
44
45
  void displaypage( int pageselector)
46
  {
47
    String line0; 
48
    String line1; 
49
    String line2;
50
    String line3;
51
    
52
    if(pageselector == 1)
53
    {
54
       line0 = String("NOW: ") + String(dayOfMonth)+ String("/")+  String(month) + String("   ") + String(hour)+String(":")+String(minute);
55
       line1 = String("Vitralit 7041T");
56
       line2 = String("DUE DATE:");
57
        line3 = String("LLOC: 1LRZ");
58
59
      lcd.clear();
60
      lcd.setCursor(0,0);
61
      lcd.print(line0);
62
      lcd.setCursor(0,1);
63
      lcd.print(line1);
64
      lcd.setCursor(0,2);
65
      lcd.print(line2);
66
      lcd.setCursor(0,3);
67
      lcd.print(line3);
68
    }
69
    else if (pageselector == 2)
70
    {
71
      String line0 = String("CHANGE GLUE IMMEDIATELY"); 
72
            lcd.clear();
73
      lcd.setCursor(0,0);
74
      lcd.print(line0);
75
    }
76
  }
77
78
79
//############################################Alarm###############################################################
80
81
82
void checkAlarm()
83
{
84
  if(alarmdayofmonth==dayOfMonth && alarmmonth == month)
85
  {
86
    alarmstatus = 1;
87
    pageswitch = 2; 
88
  } 
89
}
90
91
92
//############################################Write Data to RTC###############################################################
93
94
void setDateDs1307()                
95
{
96
  Serial.println("In set Mode");  
97
  second = (byte) ((Serial.read() - 48) * 10 + (Serial.read() - 48)); 
98
  minute = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
99
  hour  = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
100
  dayOfWeek = (byte) (Serial.read() - 48);
101
  dayOfMonth = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
102
  month = (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
103
  year= (byte) ((Serial.read() - 48) *10 +  (Serial.read() - 48));
104
  Wire.beginTransmission(clockAddress);
105
  Wire.write(byte(0x00));
106
  Wire.write(decToBcd(second));  // 0 to bit 7 starts the clock
107
  Wire.write(decToBcd(minute));
108
  Wire.write(decToBcd(hour));    
109
110
  Wire.write(decToBcd(dayOfWeek));
111
  Wire.write(decToBcd(dayOfMonth));
112
  Wire.write(decToBcd(month));
113
  Wire.write(decToBcd(year));
114
  Wire.endTransmission();
115
116
  Serial.print(hour, DEC);
117
  Serial.print(":");
118
  Serial.print(minute, DEC);
119
  Serial.print(":");
120
  Serial.print(second, DEC);
121
  Serial.print("  ");
122
  Serial.print(month, DEC);
123
  Serial.print("/");
124
  Serial.print(dayOfMonth, DEC);
125
  Serial.print("/");
126
  Serial.println(year, DEC);
127
}
128
129
130
//############################################Read Data from RTC###############################################################
131
132
133
void getDateDs1307() {
134
135
  Wire.beginTransmission(clockAddress);
136
  Wire.write(byte(0x00));
137
  Wire.endTransmission();
138
139
  Wire.requestFrom(clockAddress, 7);
140
141
142
  second     = bcdToDec(Wire.read() & 0x7f);
143
  minute     = bcdToDec(Wire.read());
144
  
145
146
  hour       = bcdToDec(Wire.read() & 0x3f);  
147
  dayOfWeek  = bcdToDec(Wire.read());
148
  dayOfMonth = bcdToDec(Wire.read());
149
  month      = bcdToDec(Wire.read());
150
  year       = bcdToDec(Wire.read());
151
}
152
153
//############################################Setup###############################################################
154
155
156
void setup() 
157
{
158
  Wire.begin();
159
  Serial.begin(57600);
160
161
//--------------------Blink Display on Startup-----------------------  
162
  lcd.begin(20,4);
163
   for(int i = 0; i< 3; i++)
164
  {
165
    lcd.backlight();
166
    delay(250);
167
    lcd.noBacklight();
168
    delay(250);
169
  }
170
  lcd.backlight();
171
}
172
173
174
//############################################Main###############################################################
175
176
177
void loop() 
178
{
179
//---------------Serial Interface ---------------------------------------------
180
  if (Serial.available()) {
181
    command = Serial.read();
182
    if (command == 84) {     
183
      setDateDs1307();
184
      getDateDs1307();
185
      Serial.println("Done With Set ");
186
    }
187
    else if (command == 65)
188
    {
189
      getDateDs1307();
190
      
191
      Serial.println(" ");
192
    } 
193
194
    else if (command == 66)
195
    {
196
     setAlarmTime();
197
      Serial.println("Set Alarm Time: ");
198
    } 
199
    
200
    Serial.print("Done Withc Commad: ");
201
    Serial.println(char(command));  
202
  }
203
  
204
  command = 0;                 
205
206
207
208
//-------display update routine------------------------------------
209
  if(millis()-previousmillis > 1000)
210
  {
211
    previousmillis = millis();
212
    getDateDs1307();
213
    checkAlarm();
214
    displaypage(pageswitch);
215
  } 
216
}

von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
anyone? :(

von Arduino Fanboy D. (ufuf)


Bewertung
0 lesenswert
nicht lesenswert
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)

von Joachim B. (jar)


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


in setup teste ich ob RTC vorhanden und wenn ja welche
1
#if (ARDUINO>0)
2
  DEBUG_PRINTLN(F(" -> Scanning..."));
3
4
  byte error, address;
5
  int nDevices=0;
6
  for(address = 1; address < 127; address++ ) 
7
  { // The i2c_scanner uses the return value of
8
    // the Write.endTransmisstion to see if
9
    // a device did acknowledge to the address.
10
    Wire.beginTransmission(address);
11
    error = Wire.endTransmission();
12
13
    if (error == 0)
14
    { DEBUG_PRINT(F("I2C device found at address 0x"));
15
      if (address<16) 
16
        DEBUG_PRINT(F("0"));
17
      DEBUG_PRINT_DEC_HEX(address,HEX);
18
      DEBUG_PRINT(F("; "));
19
      if (address<64) 
20
        DEBUG_PRINT(F("0"));
21
      DEBUG_PRINT_DEC_HEX(address,BIN);
22
      DEBUG_PRINT(F("x; << 0x"));
23
      DEBUG_PRINT_DEC_HEX((address<<1),HEX);
24
      DEBUG_PRINT(F("; "));
25
      if ((address<<1)<128) 
26
        DEBUG_PRINT(F("0"));
27
      DEBUG_PRINT_DEC_HEX((address<<1),BIN);
28
      
29
      switch(address<<1)
30
      { case 0xA0:
31
          DEBUG_PRINTLN(F(" I2C EEPROM       "));
32
          i2c_test_flags|=(1<<I2C_EEPROM);          
33
          break;
34
        case 0xD0:
35
          Wire.beginTransmission(DS1307_ID);
36
          printIIC(0x3F);
37
          (Wire.endTransmission()) ? i2c_test_flags|=(1<<I2C_RTC_3231) : i2c_test_flags|=(1<<I2C_RTC_1307);
38
          #ifdef DEBUG
39
          (i2c_test_flags&(1<<I2C_RTC_3231)) ? Serial.println(F(" DS3231 RTC ")) : Serial.println(F(" DS1307 RTC "));
40
          #endif
41
          break;
42
        default:
43
          DEBUG_PRINTLN(F(""));
44
          break;
45
      }
46
      nDevices++;
47
    }
48
    else if (error==4) 
49
    { DEBUG_PRINT(F("Unknow error at address 0x"));
50
      if (address<16) 
51
        DEBUG_PRINT(F("0"));
52
      DEBUG_PRINTLN_DEC_HEX(address,HEX);
53
    }    
54
  }
55
  if (nDevices == 0)
56
    DEBUG_PRINTLN(F("No I2C devices found"));
57
  else
58
    DEBUG_PRINTLN(F("done"));
59
  DEBUG_PRINTLN(F(""));
60
61
 #ifdef I2C_RTC
62
  //test_rtc_1307_3231
63
  if( i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307) )
64
  { RTC.getTime();
65
    sprintf(r_str, "%04d/%02d/%02d__%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second);
66
    DEBUG_PRINT(F("clock   ")); DEBUG_PRINTLN(r_str);
67
 #ifdef DEBUG
68
    (strcmp(c_str, r_str)>0) ? Serial.println(F("compile > RTC ")) : Serial.println(F("compile < RTC "));
69
 #endif // #ifdef DEBUG
70
    if(strcmp(c_str, r_str)>0)
71
    { if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.stopClock();
72
      RTC.fillByHMS( atoi(mids(c_str,13,2)), atoi(mids(c_str,15,2)), atoi(rights(c_str,2)) );
73
      RTC.fillByYMD( atoi(lefts(c_str,4)), atoi(mids(c_str,6,2)), atoi(mids(c_str,9,2)) );
74
      RTC.setTime();
75
      if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.startClock();
76
 #ifdef DEBUG
77
      (i2c_test_flags&(1<<I2C_RTC_3231)) ? Serial.println(F(" DS3231 RTC ist gestellt")) : Serial.println(F(" DS1307 RTC ist gestellt"));
78
      RTC.getTime();
79
      sprintf(r_str, "%04d/%02d/%02d__%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second); 
80
      Serial.print(F("RTC: ")); Serial.println(r_str);
81
 #endif // #ifdef DEBUG
82
      if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
83
      DEBUG_PRINTLN(F(""));
84
    } // if(strcmp(c_str, r_str)>0)
85
    RTC.getTime();
86
    sprintf(r_str, "%04d/%02d/%02d__%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second); 
87
  } // if( i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307) )
88
  else
89
  { DEBUG_PRINTLN(F(""));
90
    DEBUG_PRINT(F("compile ")); DEBUG_PRINT(c_str);
91
    DEBUG_PRINTLN(F(""));
92
  } // !( i2c_test_flags&(1<<I2C_RTC_3231) || i2c_test_flags&(1<<I2C_RTC_1307) )
93
 #endif // #ifdef I2C_RTC
94
95
  DEBUG_PRINTLN(F(""));
96
  DEBUG_PRINTLN(F("Testflags "));
97
 #ifdef I2C_RTC
98
  if(i2c_test_flags&(1<<I2C_RTC_3231))
99
    DEBUG_PRINTLN(F("I2C_RTC_3231      "));
100
  if(i2c_test_flags&(1<<I2C_RTC_1307))
101
    DEBUG_PRINTLN(F("I2C_RTC_1307      "));
102
  if(i2c_test_flags&(1<<I2C_EEPROM))
103
  { 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);
104
  }
105
 #endif // #ifdef I2C_RTC
106
107
  if(!(i2c_test_flags&(255)))
108
    DEBUG_PRINTLN(F("keine Testflags   "));
109
  DEBUG_PRINTLN(F(""));
110
#endif // #if (ARDUINO>0)

die DS1307 braucht für set eine Sonderbehandlung
1
if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.stopClock();
2
      RTC.fillByHMS( atoi(mids(c_str,13,2)), atoi(mids(c_str,15,2)), atoi(rights(c_str,2)) );
3
      RTC.fillByYMD( atoi(lefts(c_str,4)), atoi(mids(c_str,6,2)), atoi(mids(c_str,9,2)) );
4
      RTC.setTime();
5
      if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.startClock();

von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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.

von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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.

von Arduino Fanboy D. (ufuf)


Bewertung
0 lesenswert
nicht lesenswert
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?

von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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.

von Arduino Fanboy D. (ufuf)


Bewertung
0 lesenswert
nicht lesenswert
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.

: Bearbeitet durch User
von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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.

von Arduino Fanboy D. (ufuf)


Bewertung
0 lesenswert
nicht lesenswert
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

von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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!

von Joachim B. (jar)


Bewertung
0 lesenswert
nicht lesenswert
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.....
1
// --------------- serial in ---------------
2
  if (Serial.available() > 0) 
3
  { char incomingByte = (char)Serial.read();
4
    if(incomingByte == 13)  // Wenn das Enter ankommt
5
    { strcpy(serial_in_command, serial_in_buff);
6
      chr_cnt = 0;
7
      strcpy(serial_in_buff,"");
8
    }
9
    else // Falls kein Enter kommt muss der Text gespeichert werden in dem inText Array
10
    { if(isprint(incomingByte))
11
        serial_in_buff[chr_cnt++] = incomingByte;
12
    }
13
  } // if (Serial.available() > 0) 
14
  
15
  if(strlen(serial_in_command))
16
  { Serial.println(F("")); Serial.print(serial_in_command);  Serial.println(F(" -> erkannt")); 
17
          
18
    if( !strcmp(serial_in_command, "help") || ( !strcmp(serial_in_command, "?") && strlen(serial_in_command)==1 ) )
19
    { // help screen
20
      Serial.println(F("\ncommands: \n"));
21
  
22
      Serial.println(F("setdate2015/01/15"));
23
      Serial.println(F("getdate"));
24
  
25
      Serial.println(F("settime17:22:30"));
26
      Serial.println(F("gettime"));
27
      Serial.println(F("reset"));
28
      Serial.println(F(""));
29
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
30
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
31
    }
32
33
    if( strstr(serial_in_command, "setdate") )
34
    { // "setdate2014/10/05"  setdate2015/01/15
35
      if(strlen(serial_in_command)>=17) 
36
      { if( (i2c_test_flags&(1<<I2C_RTC_1307)) | (i2c_test_flags&(1<<I2C_RTC_3231)) )
37
        { uint16_t jjjj=atoi(strncpy(serial_in_buff, &serial_in_command[7], 4));
38
          if( jjjj >= atoi(strncpy(serial_in_buff, c_str, 4)) )
39
          { uint8_t mo = atoi(strncpy(serial_in_buff, &serial_in_command[12], 2)); 
40
            if(mo && mo<13) 
41
            { uint8_t ta=atoi(rights(serial_in_command, 2));
42
              if(!(ta>0 && ta<= Monatstage(jjjj, mo))) 
43
                ta=0;
44
              if(ta)  
45
              { RTC.getTime();
46
                sprintf(r_str, "%04d/%02d/%02d_%02d:%02d:%02d", jjjj, mo, ta, RTC.hour, RTC.minute, RTC.second); 
47
                if(strncmp(r_str, (char *)&c_str[0], 8)>0) DEBUG_PRINTLN(F("compile > inputdatetime -> nicht gestellt"));
48
                if(strncmp(r_str, c_str, 6)<0) 
49
                { DEBUG_PRINTLN(F("compile < inputdatetime "));
50
                } // if(strncmp(r_str, c_str, 6)<0) 
51
                if(!strncmp(c_str, r_str, 6)) 
52
                { DEBUG_PRINTLN(F("strncmp(c_str, r_str, 6)")); 
53
                  DEBUG_PRINT(F("c ")); DEBUG_PRINTLN(c_str);
54
                  DEBUG_PRINT(F("e ")); DEBUG_PRINTLN(r_str);
55
                  DEBUG_PRINTLN(F("compile == inputdatetime "));
56
                }
57
              } // if(ta)        
58
              else
59
              { DEBUG_PRINTLN(F("ERROR TA=0 RTC nicht gestellt !"));
60
                memset(&serial_in_command[0], 0, sizeof(serial_in_command));
61
                memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
62
              }
63
            } // if(mo)
64
            else
65
            { DEBUG_PRINTLN(F(" -> ERROR !MO oder (JahrMonat < compile), RTC nicht gestellt !"));
66
              memset(&serial_in_command[0], 0, sizeof(serial_in_command));
67
              memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
68
            }
69
          } // if( jjjj >= atoi(lefts(c_str, 4)) )
70
          else
71
          { DEBUG_PRINTLN(F(" -> ERROR (jjjj < compile), RTC nicht gestellt !"));
72
            memset(&serial_in_command[0], 0, sizeof(serial_in_command));
73
            memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
74
          }
75
        } // if(i2c_test_flags&(1<<RTC_CHIP))
76
      } // if(strlen(serial_in_command)>=17)
77
      else
78
      { Serial.print(F("\"")); Serial.print(serial_in_command); Serial.println(F("\" ->zu kurz, min. 17 Zeichen\"setdate2014/10/05\"")); 
79
        memset(&serial_in_command[0], 0, sizeof(serial_in_command));
80
        memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
81
      }
82
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
83
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
84
    } // if(strstr(serial_in_buff, "setdate"))
85
    
86
    if( strstr(serial_in_command, "getdate") )
87
    { // "getdate"
88
      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);
89
      Serial.println(serial_in_buff);
90
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
91
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
92
    } // if( strstr(serial_in_command, "getdate") )
93
  
94
    if( strstr(serial_in_command, "settime") )
95
    { // "settime17:22:30" 
96
      if(strlen(serial_in_command)>=15) 
97
      { if( (i2c_test_flags&(1<<I2C_RTC_1307)) | (i2c_test_flags&(1<<I2C_RTC_3231)) )
98
        { uint8_t hh=atoi(strncpy(serial_in_buff, &serial_in_command[7], 2));
99
          if( 0 <= hh && hh < 24)
100
          { uint8_t mm = atoi(strncpy(serial_in_buff, &serial_in_command[10], 2)); 
101
            if( 0 <= mm && mm < 60)
102
            { uint8_t ss=atoi(rights(serial_in_command, 2));
103
              if( 0 <= ss && ss < 60)
104
              { RTC.fillByHMS( hh, mm, ss );
105
                sprintf(r_str, "%02d:%02d:%02d", RTC.hour, RTC.minute, RTC.second); 
106
if(i2c_test_flags&(1<<I2C_RTC_1307)) RTC.stopClock();                RTC.setTime();
107
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"));
108
                RTC.getTime();
109
                sprintf(r_str, "%04d/%02d/%02d_%02d:%02d:%02d", RTC.year, RTC.month, RTC.day, RTC.hour, RTC.minute, RTC.second);
110
                Serial.println(r_str); Serial.println();
111
              } // if(ss)        
112
              else
113
              { DEBUG_PRINTLN(F("ERROR ss Fehler RTC nicht gestellt !"));
114
              }
115
            } // if(mm)
116
            else
117
            { DEBUG_PRINTLN(F("ERROR mm Fehler RTC nicht gestellt !"));
118
            }
119
          } // if(hh)
120
          else
121
          { DEBUG_PRINTLN(F("ERROR hh Fehler RTC nicht gestellt !"));
122
          }
123
        } // if(i2c_test_flags&(1<<RTC_CHIP))
124
      } // if(strlen(serial_in_command)>=15)
125
      else
126
      { Serial.print(F("\"")); Serial.print(serial_in_command); 
127
        Serial.print(F("\" ->zu kurz: ")); Serial.print(strlen(serial_in_command)); 
128
        Serial.println(F(", min. 15 Zeichen\"settime17:22:30\"")); 
129
      }
130
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
131
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
132
    } // if(strstr(serial_in_buff, "settime"))
133
134
    if( strstr(serial_in_command, "gettime") )
135
    { // "gettime"
136
      sprintf((char *)serial_in_buff,"%02d:%02d:%02d", RTC.hour, RTC.minute, RTC.second);
137
      Serial.print(serial_in_buff); Serial.println(F(" Uhr"));
138
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
139
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
140
    } // if( strstr(serial_in_command, "gettime") )
141
142
    if( !strcmp(serial_in_command, "reset") )
143
    { // "reset"
144
      {asm("ldi r30,0"); asm("ldi r31,0"); asm("ijmp");}
145
      memset(&serial_in_command[0], 0, sizeof(serial_in_command));
146
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
147
    } // if( !strcmp(serial_in_command, "reset") )
148
  
149
    if(strlen(serial_in_command))
150
    { memset(&serial_in_command[0], 0, sizeof(serial_in_command));
151
      memset(&serial_in_buff[0], 0, sizeof(serial_in_buff));
152
    }
153
  } // if(strlen(serial_in_command))

von Arduino Fanboy D. (ufuf)


Bewertung
1 lesenswert
nicht lesenswert
cableer schrieb:
> Ich werde mal ein delay einbauen.

Das ist mit Abstand die schlechteste Lösung.

von Joachim B. (jar)


Bewertung
0 lesenswert
nicht lesenswert
es fehlt noch die Abfrage das es keinen Überlauf im In Buffer gibt.

von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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!

von cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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.

von Joachim B. (jar)


Bewertung
0 lesenswert
nicht lesenswert
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!

von Axel R. (Gast)


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

StromTuner

von Arduino Fanboy D. (ufuf)


Bewertung
0 lesenswert
nicht lesenswert
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.

: Bearbeitet durch User
von Joachim B. (jar)


Bewertung
0 lesenswert
nicht lesenswert
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

von Cableer (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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.

von Joachim B. (jar)


Bewertung
0 lesenswert
nicht lesenswert
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.

von Stefan ⛄ F. (stefanus)


Bewertung
0 lesenswert
nicht lesenswert
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.

: Bearbeitet durch User
von Arduino Fanboy D. (ufuf)


Bewertung
0 lesenswert
nicht lesenswert
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...

;-)

: Bearbeitet durch User
von Huh (Gast)


Bewertung
0 lesenswert
nicht lesenswert
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---

von Joachim B. (jar)


Bewertung
0 lesenswert
nicht lesenswert
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?

: Bearbeitet durch User

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.