Forum: Mikrocontroller und Digitale Elektronik Millis in while-Schleife


Millis in while-Schleife
von Asdf A. (eizi)

Lesenswert?
• ▲
▼ 
Hallo,


ich habe ein sehr merkwürdiges Problem welches mich verrückt macht, ich 
benutze die millis()-Funktion um eine while-Schleife nach 30 Sekunden zu 
verlassen, jedoch wird diese immer zu  verschiedenen Zeiten (meist nach 
ca 20 Sekunden) verlassen und nicht bei 30 Sekunden..habe bei den oder 
ähnlichen Einstellungen Timern nichts verstellt.


Hier die Schleife die Probleme macht:

1
if (newcode == 3 && rightcode == 6) {

2
    //Serial.println("In der Programmierabfrage");

3
    newcode = 0;

4
5
    for (int i = 0; i < 6; i++) {

6
      NeuerCode[i] = 10;

7
      NeuerCode2[i] = 10;

8
    }

9
10
11
12
13
14
    while (schleifenexit1 == 0) {

15
      //Serial.println("In der 1 While Schleife");

16
17
18
      digitalWrite(ledgruen, HIGH);

19
      digitalWrite(ledrot, HIGH);

20
21
22
23
      //Sendet Statusupdate an Server

24
      if (neuprogrammierstatus == 0) {

25
        Udp.beginPacket(serverip, serverport);

26
        Udp.print("9993");

27
        Udp.endPacket();

28
        Serial.println("Neu Programmierstatus-Anfang versendet");

29
        neuprogrammierstatus = 1;

30
      }

31
32
33
      schleifenstartzeit = millis();

34
      if (schleifenstartzeit - schleifenendzeit > 30000) {

35
        Serial.println("Schleifenstartzeit");

36
        Serial.println(schleifenstartzeit);

37
        Serial.println("Schleifenendzeit");

38
        Serial.println(schleifenendzeit);

39
        schleifenendzeit = schleifenstartzeit;

40
        Serial.println("Schleifenbreak");

41
        schleifenexit1 = 1;

42
        schleifenexit2 = 1;

43
      }

44
45
46
      tastereingabe();

47
48
49
      //Entprellen: Der Code bis zur Einschreiben im Array befindet sich in dem Millis-IF-Statement. Danach gibt die Variable Schritt zur Gleichheitsprüfung weiter.

50
51
      if (Taster0 == 1 || Taster1 == 1 || Taster2 == 1 || Taster3 == 1 || Taster4 == 1 || Taster5 == 1 || Taster6 == 1 || Taster7 == 1 || Taster8 == 1 || Taster9 == 1 || resetpinstatus == 1 || absenden == 1) {

52
53
54
55
        if (Taster0 == 1) {

56
          NeuerCode[schrittzaehler3] = 0;

57
          Serial.println("Im Array:");

58
          Serial.println(NeuerCode[schrittzaehler3]);

59
          Serial.println("Schrittzaehler3:");

60
          Serial.println(schrittzaehler3);

61
          schrittzaehler3++;

62
        }

63
        if (Taster1 == 1) {

64
          NeuerCode[schrittzaehler3] = 1;

65
          Serial.println("Im Array:");

66
          Serial.println(NeuerCode[schrittzaehler3]);

67
          Serial.println("Schrittzaehler3:");

68
          Serial.println(schrittzaehler3);

69
          schrittzaehler3++;

70
        }

71
        if (Taster2 == 1) {

72
          NeuerCode[schrittzaehler3] = 2;

73
          Serial.println("Im Array:");

74
          Serial.println(NeuerCode[schrittzaehler3]);

75
          Serial.println("Schrittzaehler3:");

76
          Serial.println(schrittzaehler3);

77
          schrittzaehler3++;

78
        }

79
        if (Taster3 == 1) {

80
          NeuerCode[schrittzaehler3] = 3;

81
          Serial.println("Im Array:");

82
          Serial.println(NeuerCode[schrittzaehler3]);

83
          Serial.println("Schrittzaehler3:");

84
          Serial.println(schrittzaehler3);

85
          schrittzaehler3++;

86
        }

87
        if (Taster4 == 1) {

88
          NeuerCode[schrittzaehler3] = 4;

89
          Serial.println("Im Array:");

90
          Serial.println(NeuerCode[schrittzaehler3]);

91
          Serial.println("Schrittzaehler3:");

92
          Serial.println(schrittzaehler3);

93
          schrittzaehler3++;

94
        }

95
        if (Taster5 == 1) {

96
          NeuerCode[schrittzaehler3] = 5;

97
          Serial.println("Im Array:");

98
          Serial.println(NeuerCode[schrittzaehler3]);

99
          Serial.println("Schrittzaehler3:");

100
          Serial.println(schrittzaehler3);

101
          schrittzaehler3++;

102
        }

103
        if (Taster6 == 1) {

104
          NeuerCode[schrittzaehler3] = 6;

105
          Serial.println("Im Array:");

106
          Serial.println(NeuerCode[schrittzaehler3]);

107
          Serial.println("Schrittzaehler3:");

108
          Serial.println(schrittzaehler3);

109
          schrittzaehler3++;

110
        }

111
        if (Taster7 == 1) {

112
          NeuerCode[schrittzaehler3] = 7;

113
          Serial.println("Im Array:");

114
          Serial.println(NeuerCode[schrittzaehler3]);

115
          Serial.println("Schrittzaehler3:");

116
          Serial.println(schrittzaehler3);

117
          schrittzaehler3++;

118
        }

119
        if (Taster8 == 1) {

120
          NeuerCode[schrittzaehler3] = 8;

121
          Serial.println("Im Array:");

122
          Serial.println(NeuerCode[schrittzaehler3]);

123
          Serial.println("Schrittzaehler3:");

124
          Serial.println(schrittzaehler3);

125
          schrittzaehler3++;

126
        }

127
        if (Taster9 == 1) {

128
          NeuerCode[schrittzaehler3] = 9;

129
          Serial.println("Im Array:");

130
          Serial.println(NeuerCode[schrittzaehler3]);

131
          Serial.println("Schrittzaehler3:");

132
          Serial.println(schrittzaehler3);

133
          schrittzaehler3++;

134
        }

135
        if (resetpinstatus == 1) {

136
          schrittzaehler3 = 0;

137
          schrittzaehler3 = 0;

138
          rightcode2 = 0;

139
          schleifenexit1 = 0;

140
          Serial.println("Array geloescht!");

141
        }

142
        if (schrittzaehler3 > 5) schrittzaehler3 = 0;

143
      }

144
145
146
147
      if (absenden == 1) {

148
149
150
        for (int i = 0; i < 6; i++) {

151
          if (NeuerCode[i] < 10) {

152
            arrayvoll++;

153
            Serial.println("Codestellenanzahl");

154
            Serial.println(arrayvoll);

155
156
          }//IF-Abfrage Beenden

157
          else {

158
            schleifenexit1 = 1;

159
            schleifenexit2 = 1;

160
            arrayvoll = 0;

161
            schrittzaehler3 = 0;

162
            Serial.println("Schleife wird verlassen");

163
          }

164
        } //For-Schleifen Beenden

165
166
        if (arrayvoll < 6) arrayvoll = 0;

167
        if (arrayvoll == 6) {

168
          Serial.println("6 Zahlen eingegeben");

169
          schleifenexit1 = 1;

170
          digitalWrite(ledgruen, LOW);

171
          digitalWrite(ledrot, LOW);

172
        }

173
        //else { schleifenexit1=0;

174
        //Serial.println("Zu wenig zahlen eingegeben");

175
176
        // } //Else beenden

177
178
179
      }//Absenden beenden

180
181
182
183
    } //While Beenden




Sieht jemand einen typischen Fehler den ich übersehe?

  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Hugo Gruffy Duck (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hi, was für Werte sind denn schleifenstartzeit und so? Sind es 
vielleicht "nur" 8/16bit-Variablen (ggf. mit Vorzeichen), die vielleicht 
zu "klein" sind von der Bitbreite?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Asdf A.
        (eizi)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hallo,

es sind unsigned long, die Wertdeklarierung stimmt 100%ig :)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Hugo Gruffy Duck (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Max E. schrieb:
> Hallo,
>
> es sind unsigned long, die Wertdeklarierung stimmt 100%ig :)

War nur ne Idee, weil ich vor kurzem das Problem mit dem falschen 
Zahlenformat hatte :-)

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        SF6 (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Wirf mal alles Unnütze aus der Schleife und schau ob der Abbruch nach 
30s alleine funktioniert.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Asdf A.
        (eizi)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Ok, nun erledigt - klappt immer noch nicht, interessant ist aber das in 
einer neuen Datei in einer While-Schleife der gleiche Millis-Code brav 
30 Sekunden wartet.


Wie kann das sein, wenn der Code in der Schleife ausgeführt wird kann 
doch der vorhergehende Code nicht reinpfuschen oder? Die Variablen 
welche die Zeit halten werden nur in der While-Schleife verwendet.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Asdf A.
        (eizi)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
So habe nun weiter herumexperimentiert und komme einfach zu keiner 
Lösung, wenn ich die gesamte Schleife und die Variablendeklaration 
kopiere, in ein neues Dokument einfüge und auf den Arduino lade läuft 
die Schleife perfekt und wird nach 30 Sekunden verlassen.

Bei meinem Orginalsourcecode in dem die Schleife integriert ist dies 
nicht der Fall, die Schleife funktioniert ohne Probleme jedoch verlässt 
der Arduino diese schon bei ca 20 Sekunden..wie bereits erwähnt die 
Variablen wurden mit dem richtigen Wertebreich deklariert und die 
Zeitvariablen werden auch nur in der Schleife verwendet.

Hat jemand noch irgendeine Idee?

Hier die gesamte Source, vielleicht findet jemand den Fehler auch ohne 
den Hintergrund zu verstehen..


1
#include <MD5.h>

2
#include <SPI.h>

3
#include <Ethernet.h>

4
#include <EthernetUdp.h>

5
#define UDP_TX_PACKET_MAX_SIZE 200

6
7
8
//########################################################################################################################################################################

9
10
11
// Pins definieren ohne Variablendeklaration spart Ressourcen.

12
13
#define  pinnull   9

14
#define  pineins   8

15
#define  pinzwei   7

16
#define  pindrei   6

17
#define  pinvier   5

18
#define  pinfuenf  4

19
#define  resetpin  3

20
#define  absendepin 2

21
22
#define  ledgruen  20

23
#define  ledrot    21

24
#define  hubmagnet 51

25
26
27
/*#######################################################*/

28
/*                                                       */

29
/**/  byte Code[6] = {1, 2, 3, 4, 5, 6}; /* Hier Code Eingeben */

30
/*                                                       */

31
/*#######################################################*/

32
33
byte Codeeingabe[6]; //Arrays

34
byte NeuerCode[6];

35
byte NeuerCode2[6];

36
37
38
//Tasterdeklaration

39
byte Taster0 = 0; //Die Taster werden mit int definiert da Minuszahlen vorkommen.

40
byte Taster1 = 0;

41
byte Taster2 = 0;

42
byte Taster3 = 0;

43
byte Taster4 = 0;

44
byte Taster5 = 0;

45
byte Taster6 = 0;

46
byte Taster7 = 0;

47
byte Taster8 = 0;

48
byte Taster9 = 0;

49
byte resetpinstatus = 0;

50
51
52
//Passwort überprüfen

53
byte rightcode = 0;

54
byte rightcode3 = 0;

55
byte absenden = 0;

56
byte schrittzaehler4 = 0;

57
byte schrittzaehler3 = 0;

58
byte schrittzaehler2 = 0;

59
byte schrittzaehler = 0;

60
61
62
63
//Neu Programmieren

64
65
66
byte arrayvoll = 0;

67
byte arrayvoll2 = 0;

68
byte newcode = 0;

69
byte schleifenexit1 = 0;

70
byte schleifenexit2 = 0;

71
byte rightcode2 = 0;

72
73
unsigned long schleifenstartzeit = 0;

74
unsigned long schleifenendzeit = 0;

75
76
unsigned long schleifenbreak = 30000;

77
78
79
80
//Blinken im Programmiermodus

81
unsigned long BlinkStarttimer = 0;

82
unsigned long BlinkEndtimer = 0;

83
84
85
byte ledState = LOW;

86
87
88
//Keypad

89
90
#include <Keypad.h>

91
92
const byte ROWS = 4; // Vier Reihen

93
const byte COLS = 3; // Drei Spalten

94
95
//Tastenfeld wird definiert

96
97
char singlekeys[ROWS][COLS] = {

98
99
  {'1', '2', '3'},

100
  {'4', '5', '6'},

101
  {'7', '8', '9'},

102
  {'*', '0', '#'}

103
};

104
105
//Hier werden die einzelnen Reihen mit dem Arduino verbunden. (4)

106
byte rowPins[ROWS] = { 28, 29, 30, 31 }; //Orange

107
//Hier werden die einzelnen Spalten mit dem Arduino verbunden. (3)

108
byte colPins[COLS] = { 22, 23, 24 };  //Grün

109
110
// Erstelle das Tasterfeld

111
Keypad  tasterpad = Keypad( makeKeymap(singlekeys), rowPins, colPins, ROWS, COLS );

112
113
114
115
#include <EEPROM.h> //Array in Flash speichern

116
byte EEsize = 6; //Größe des SPeicherbereiches

117
118
119
//########################################################################################################################################################################

120
121
//Networking

122
int udppacket = 0;

123
int arraygroesse = 0;

124
char recieveddata[100];

125
126
//########################################################################################################################################################################

127
//Polls

128
129
//Servervariablen/Arrays

130
131
byte serverpollzeitsize;

132
char serverpollzeithashbuffer[100];

133
134
//Clientvariablen/Arrays

135
136
char clienthasharray[100]; //Ein MD5 Hash hat 32 Zeichen, hier von 0-31, die Zeichen 32-34 dient zur Zuordnung des Hashes, die restlichen fuer die Clientzeit

137
char clientzeitbuffer[100];

138
139
boolean pollidstate1 = 0;

140
boolean pollidstate2 = 0;

141
boolean pollidstate3 = 0;

142
143
//########################################################################################################################################################################

144
145
//Verschlüsselung

146
147
/*#################################################################*/

148
/*                                                                 */

149
/**/  char keyphrase[4] = {'4', '6', '1', '6'}; /* Hier Code Eingeben */

150
/*                                                                 */

151
/*#################################################################*/

152
153
154
//########################################################################################################################################################################

155
156
157
//Nicht zugeordnet

158
159
160
byte hashzaehler = 0;

161
unsigned long clientzeit = 0;

162
163
164
//########################################################################################################################################################################

165
166
//Statusupdates

167
168
byte openstatus = 0;

169
byte closestatus = 0;

170
byte neuprogrammierstatus = 0;

171
172
173
174
//########################################################################################################################################################################

175
176
//Lokale Adresse:

177
178
byte clientmac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEB };

179
IPAddress clientip(192, 168, 3, 2);

180
IPAddress clientsubnet(255, 255, 255, 0);

181
IPAddress gateway(192, 168, 3, 1);

182
int clientport = 8002; //Lokaler Port

183
184
//Serveradresse:

185
186
IPAddress serverip(192, 168, 3, 1); //Address to send UDP packe to

187
IPAddress servergateway(292, 168, 3, 1);

188
int serverport = 8001;

189
190
191
char packetbuffer[UDP_TX_PACKET_MAX_SIZE]; //Bufferspeicher um Empfangene Pakete bis zur Bearbeitung zu speichern.

192
EthernetUDP Udp; //Beginnt eine UDP-Instanz

193
194
//########################################################################################################################################################################

195
196
197
198
void setup() {

199
200
201
  Ethernet.begin(clientmac, clientip, clientsubnet, gateway);

202
  Udp.begin(clientport);

203
204
  //Codeeingabe

205
  pinMode(absendepin, INPUT_PULLUP);

206
  pinMode(pinnull, INPUT_PULLUP);

207
  pinMode(pineins, INPUT_PULLUP);

208
  pinMode(pinzwei, INPUT_PULLUP);

209
  pinMode(pindrei, INPUT_PULLUP);

210
  pinMode(pinvier, INPUT_PULLUP);

211
  pinMode(pinfuenf, INPUT_PULLUP);

212
  pinMode(resetpin, INPUT_PULLUP);

213
  pinMode(ledrot, OUTPUT);

214
  pinMode(ledgruen, OUTPUT);

215
  pinMode(hubmagnet, OUTPUT);

216
  Serial.begin(115200);

217
}

218
219
//########################################################################################################################################################################

220
221
222
223
void loop() {

224
225
226
  udppacket = Udp.parsePacket();

227
  if (udppacket) {

228
    Serial.println("Paketgroesse");

229
    Serial.println(udppacket);

230
231
    Udp.read(packetbuffer, udppacket);

232
233
    //Speichert die Empfangenen Daten in ein char Array

234
    for (int i = 0; i < udppacket; i++) {

235
      recieveddata[i] = packetbuffer[i];

236
    }

237
    Serial.println("Empfangene Daten:");

238
    Serial.println(recieveddata);

239
240
    //Ermittelt die tatsächliche größe des Arrays

241
    arraygroesse = (unsigned)strlen(recieveddata);

242
    Serial.println("Arraygroesse ");

243
    Serial.println(arraygroesse);

244
    //  arraygroees2=arraygroesse; /

245
  }

246
247
248
  //########################################################################################################################################################################

249
250
  //Pollteil

251
252
  if (arraygroesse) { //<10 da die maximale Zeit vor überlaufen der unsigned long Variable 10 Stellen hat.

253
254
255
    arraygroesse = arraygroesse - 1;

256
    if (recieveddata[arraygroesse] == '3') {

257
      arraygroesse = arraygroesse - 1;

258
      if (recieveddata[arraygroesse] == '2') {

259
        arraygroesse = arraygroesse - 1;

260
        if (recieveddata[arraygroesse] == '1') {

261
262
263
264
          Serial.println("Pollanfrage eingegangen!");

265
266
          for (int i = 0; i < arraygroesse; i++) {

267
            serverpollzeithashbuffer[i] = recieveddata[i];

268
          }

269
          Serial.println("Empfangene Serverzeit im Array");

270
          Serial.println(serverpollzeithashbuffer);

271
272
273
274
          //Hier wird der PIN-Code an die Serverzeit gehängt

275
          serverpollzeitsize = (unsigned)strlen(serverpollzeithashbuffer);

276
277
          Serial.println("Empfangene Serverzeit-Stellen");

278
          Serial.println(serverpollzeitsize);

279
280
281
          //Das Serverzeitidsize Array ist Zero indexed während die serverzeitid Ausabe bei 1 zu zählen beginnt, somit muss hier nur 2x addiert werden für 3 ID-Stellen

282
          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[0];

283
284
          serverpollzeitsize = serverpollzeitsize + 1;

285
          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[1];

286
287
          serverpollzeitsize = serverpollzeitsize + 1;

288
          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[2];

289
290
          serverpollzeitsize = serverpollzeitsize + 1;

291
          serverpollzeithashbuffer[serverpollzeitsize] = keyphrase[3];

292
293
          Serial.println("Empfangene Serverzeit+PIN");

294
          Serial.println(serverpollzeithashbuffer);

295
296
297
298
299
300
          Serial.println("HASH fuer Server erstellen");

301
          unsigned char* hash = MD5::make_hash(serverpollzeithashbuffer);

302
          char *md5str = MD5::make_digest(hash, 16);

303
          free(hash);

304
305
          for (int i = 0; i < 32; i++) {

306
            clienthasharray[i] = md5str[i];

307
          }

308
309
          free(md5str);

310
311
          //Hängt an den Hash eine ID-an um Server Polls von Befehlen zu unterscheiden.

312
          clienthasharray[32] = '1';

313
          clienthasharray[33] = '2';

314
          clienthasharray[34] = '3';

315
          Serial.println("Clienthash+ID");

316
          Serial.println(clienthasharray);

317
318
319
320
          //Versendet den generierten Hash

321
          Serial.println("Versende ClientHash+ID");

322
          Udp.beginPacket(serverip, serverport);

323
          Udp.print(clienthasharray);

324
          Udp.endPacket();

325
          Serial.println("Clienthash versendet");

326
327
328
          memset(recieveddata, 0, sizeof(recieveddata));

329
          memset(serverpollzeithashbuffer, 0, sizeof(serverpollzeithashbuffer));

330
          arraygroesse = 0;

331
          memset(clientzeitbuffer, 0, sizeof(clientzeitbuffer));

332
          memset(clienthasharray, 0, sizeof(clienthasharray));

333
          pollidstate1 = 0;

334
          pollidstate2 = 0;

335
          pollidstate3 = 0;

336
337
        } //IF3

338
      } //IF2

339
    } //IF1

340
  } //Arraygroesse

341
342
343
  //########################################################################################################################################################################

344
  //Codeeingabeteil

345
346
347
  for (int a = 0; a < EEsize; a++) //Falls der Code vergessen wurde, hier Code[a] = EEPROM.read(a); auskommentieren und denn Standardcode 123456 verwenden, danach den Arduinio einen neuen Code programmieren und diese Zeile wieder wirkbar machen.

348
  {

349
    Code[a] = EEPROM.read(a); //Liest das Array aus dem EEPROM in das Code Array ein

350
    //Serial.print("EEPROM position: ");

351
    //Serial.print(a);

352
    //Serial.print(" contains ");

353
    //Serial.println(Code[a]);

354
355
  }

356
357
  schleifenexit1 = 0; //Die Bedingungen um den Pin-Code einzutippen werden ungültig

358
  schleifenexit2 = 0;

359
360
  //Eingabe

361
362
  tastereingabe();

363
364
365
  //Entprellen: Der Code bis zur Einschreiben im Array befindet sich in dem Millis-IF-Statement. Danach gibt die Variable Schritt zur Gleichheitsprüfung weiter.

366
367
368
  if (Taster0 == 1 || Taster1 == 1 || Taster2 == 1 || Taster3 == 1 || Taster4 == 1 || Taster5 == 1 || Taster6 == 1 || Taster7 == 1 || Taster8 == 1 || Taster9 == 1 || resetpinstatus == 1 || absenden == 1) {

369
370
371
    if (Taster0 == 1) {

372
      Codeeingabe[schrittzaehler] = 0;

373
      Serial.println("Im Array:");

374
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

375
    }

376
    if (Taster1 == 1) {

377
      Codeeingabe[schrittzaehler] = 1;

378
      Serial.println("Im Array:");

379
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

380
    }

381
    if (Taster2 == 1) {

382
      Codeeingabe[schrittzaehler] = 2;

383
      Serial.println("Im Array:");

384
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

385
    }

386
    if (Taster3 == 1) {

387
      Codeeingabe[schrittzaehler] = 3;

388
      Serial.println("Im Array:");

389
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

390
    }

391
    if (Taster4 == 1) {

392
      Codeeingabe[schrittzaehler] = 4;

393
      Serial.println("Im Array:");

394
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

395
    }

396
    if (Taster5 == 1) {

397
      Codeeingabe[schrittzaehler] = 5;

398
      Serial.println("Im Array:");

399
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

400
    }

401
    if (Taster6 == 1) {

402
      Codeeingabe[schrittzaehler] = 6;

403
      Serial.println("Im Array:");

404
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

405
    }

406
    if (Taster7 == 1) {

407
      Codeeingabe[schrittzaehler] = 7;

408
      Serial.println("Im Array:");

409
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

410
    }

411
    if (Taster8 == 1) {

412
      Codeeingabe[schrittzaehler] = 8;

413
      Serial.println("Im Array:");

414
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

415
    }

416
    if (Taster9 == 1) {

417
      Codeeingabe[schrittzaehler] = 9;

418
      Serial.println("Im Array:");

419
      Serial.println(Codeeingabe[schrittzaehler]); /*Serial.println("Schrittzaehler:"); Serial.println(schrittzaehler);*/ schrittzaehler++;

420
    }

421
    if (resetpinstatus == 1) {

422
      schrittzaehler = 0;

423
      schrittzaehler2 = 0;

424
      rightcode = 0;

425
      arrayreset();

426
      Serial.println("Array gelöscht!");

427
      newcode = 0;

428
    }

429
    if (schrittzaehler > 5) schrittzaehler = 0; //Es dürfen nur sechs Stellen Code eingegeben werden, 0-5 z.B. wenn 456789123456 eingegeben wird, zählen nur die letzten sechs stellen also 123456

430
431
432
433
    if (absenden == 1) { //Zweimal Raute drücken um in den Programmiermodus zu kommen, jedoch muss der Zähler dreimal Zählen da beim absenden des Codes um das Schließfach zu öffnen ebenfalls die #-Taste benutzt wird.

434
      newcode++;

435
      Serial.println("Schleife-Betreten bei 3x# gedrueckt");

436
      Serial.println(newcode);

437
    }

438
439
    if (newcode > 3) { //Wenn die #-Taste öfter gedrückt wird z.B. vor der ersten Codeeingabe zum Öffnen des Schließfaches würde setzt diese Funktion den Wert zurück.

440
      newcode = 3;

441
      Serial.println("Newcode-Begrenzung");

442
      Serial.println(newcode);

443
    }

444
  }

445
446
447
448
  if (absenden == 1) { //Hier wird der eingebene Pin auf Gleichheit mit dem gespeicherten PIN überprüft

449
450
    Serial.println("Absendebutton funktioniert, Code wird nun uberprüft"); //Absendebutton funktioniert

451
452
    for (schrittzaehler2 = 0; schrittzaehler2 < 6; schrittzaehler2++) {

453
      if (Codeeingabe[schrittzaehler2] == Code[schrittzaehler2]) {

454
        Serial.println("Schleife funktioniert"); //Schleife funktioniert

455
        rightcode++;

456
        Serial.println("Rightcode");

457
        Serial.println(rightcode);

458
      }

459
460
      else {

461
        Serial.println("Rightcode Reset");

462
        rightcode = 0;

463
        schrittzaehler2 = 0;

464
        arrayreset();

465
      }

466
    }

467
  }

468
469
470
  if (rightcode > 6) rightcode = 6; //Wenn die Absendetaste versehentlich 2x oder öfter gedrückt wurde, setzt diese IF-Abfrage den Wert wieder auf 6 zurück.

471
472
473
  if (rightcode == 6) {

474
475
    //Serial.println("Rightcode Zahl");

476
    //Serial.println(rightcode);

477
    digitalWrite(ledgruen, HIGH);

478
    digitalWrite(ledrot, LOW);

479
    digitalWrite(hubmagnet, HIGH);

480
  }

481
482
  else {

483
484
    digitalWrite(ledgruen, LOW);

485
    digitalWrite(ledrot, HIGH);

486
    digitalWrite(hubmagnet, LOW);

487
488
  }

489
490
491
  //########################################################################################################################################################################

492
  //Statusupdateteil

493
494
495
  if (rightcode == 0 && closestatus == 0) {

496
497
498
    Udp.beginPacket(serverip, serverport);

499
    Udp.print("9991");

500
    Udp.endPacket();

501
    Serial.println("Geschlossen versendet");

502
    closestatus = 1;

503
    openstatus = 0;

504
  }

505
506
507
508
  if (rightcode == 6 && openstatus == 0) {

509
510
511
    Udp.beginPacket(serverip, serverport);

512
    Udp.print("9992");

513
    Udp.endPacket();

514
    Serial.println("Geoeffnet versendet");

515
    openstatus = 1;

516
    closestatus = 0;

517
  }

518
519
520
521
522
  if (neuprogrammierstatus == 1) {

523
524
    Udp.beginPacket(serverip, serverport);

525
    Udp.print("9994");

526
    Udp.endPacket();

527
    Serial.println("Neu Programmierstatus-Ende versendet");

528
    neuprogrammierstatus = 0;

529
  }

530
531
532
533
  //###############################################################################################################################################

534
  //Programmiermodus

535
536
537
  if (newcode == 3 && rightcode == 6) {

538
    //Serial.println("In der Programmierabfrage");

539
    newcode = 0;

540
541
    for (int i = 0; i < 6; i++) {

542
      NeuerCode[i] = 10;

543
      NeuerCode2[i] = 10;

544
    }

545
546
547
    while (schleifenexit1 == 0) {

548
      //Serial.println("In der 1 While Schleife");

549
550
551
      digitalWrite(ledgruen, HIGH);

552
      digitalWrite(ledrot, HIGH);

553
554
555
556
      //Sendet Statusupdate an Server

557
      if (neuprogrammierstatus == 0) {

558
        Udp.beginPacket(serverip, serverport);

559
        Udp.print("9993");

560
        Udp.endPacket();

561
        Serial.println("Neu Programmierstatus-Anfang versendet");

562
        neuprogrammierstatus = 1;

563
      }

564
565
566
      schleifenstartzeit = millis();

567
      if (schleifenstartzeit - schleifenendzeit > 30000) {

568
        Serial.println("Schleifenstartzeit");

569
        Serial.println(schleifenstartzeit);

570
        Serial.println("Schleifenendzeit");

571
        Serial.println(schleifenendzeit);

572
        schleifenendzeit = schleifenstartzeit;

573
        Serial.println("Schleifenbreak");

574
        schleifenexit1 = 1;

575
        schleifenexit2 = 1;

576
      }

577
578
      tastereingabe();

579
580
581
      //Entprellen: Der Code bis zur Einschreiben im Array befindet sich in dem Millis-IF-Statement. Danach gibt die Variable Schritt zur Gleichheitsprüfung weiter.

582
583
      if (Taster0 == 1 || Taster1 == 1 || Taster2 == 1 || Taster3 == 1 || Taster4 == 1 || Taster5 == 1 || Taster6 == 1 || Taster7 == 1 || Taster8 == 1 || Taster9 == 1 || resetpinstatus == 1 || absenden == 1) {

584
585
586
587
        if (Taster0 == 1) {

588
          NeuerCode[schrittzaehler3] = 0;

589
          Serial.println("Im Array:");

590
          Serial.println(NeuerCode[schrittzaehler3]);

591
          Serial.println("Schrittzaehler3:");

592
          Serial.println(schrittzaehler3);

593
          schrittzaehler3++;

594
        }

595
        if (Taster1 == 1) {

596
          NeuerCode[schrittzaehler3] = 1;

597
          Serial.println("Im Array:");

598
          Serial.println(NeuerCode[schrittzaehler3]);

599
          Serial.println("Schrittzaehler3:");

600
          Serial.println(schrittzaehler3);

601
          schrittzaehler3++;

602
        }

603
        if (Taster2 == 1) {

604
          NeuerCode[schrittzaehler3] = 2;

605
          Serial.println("Im Array:");

606
          Serial.println(NeuerCode[schrittzaehler3]);

607
          Serial.println("Schrittzaehler3:");

608
          Serial.println(schrittzaehler3);

609
          schrittzaehler3++;

610
        }

611
        if (Taster3 == 1) {

612
          NeuerCode[schrittzaehler3] = 3;

613
          Serial.println("Im Array:");

614
          Serial.println(NeuerCode[schrittzaehler3]);

615
          Serial.println("Schrittzaehler3:");

616
          Serial.println(schrittzaehler3);

617
          schrittzaehler3++;

618
        }

619
        if (Taster4 == 1) {

620
          NeuerCode[schrittzaehler3] = 4;

621
          Serial.println("Im Array:");

622
          Serial.println(NeuerCode[schrittzaehler3]);

623
          Serial.println("Schrittzaehler3:");

624
          Serial.println(schrittzaehler3);

625
          schrittzaehler3++;

626
        }

627
        if (Taster5 == 1) {

628
          NeuerCode[schrittzaehler3] = 5;

629
          Serial.println("Im Array:");

630
          Serial.println(NeuerCode[schrittzaehler3]);

631
          Serial.println("Schrittzaehler3:");

632
          Serial.println(schrittzaehler3);

633
          schrittzaehler3++;

634
        }

635
        if (Taster6 == 1) {

636
          NeuerCode[schrittzaehler3] = 6;

637
          Serial.println("Im Array:");

638
          Serial.println(NeuerCode[schrittzaehler3]);

639
          Serial.println("Schrittzaehler3:");

640
          Serial.println(schrittzaehler3);

641
          schrittzaehler3++;

642
        }

643
        if (Taster7 == 1) {

644
          NeuerCode[schrittzaehler3] = 7;

645
          Serial.println("Im Array:");

646
          Serial.println(NeuerCode[schrittzaehler3]);

647
          Serial.println("Schrittzaehler3:");

648
          Serial.println(schrittzaehler3);

649
          schrittzaehler3++;

650
        }

651
        if (Taster8 == 1) {

652
          NeuerCode[schrittzaehler3] = 8;

653
          Serial.println("Im Array:");

654
          Serial.println(NeuerCode[schrittzaehler3]);

655
          Serial.println("Schrittzaehler3:");

656
          Serial.println(schrittzaehler3);

657
          schrittzaehler3++;

658
        }

659
        if (Taster9 == 1) {

660
          NeuerCode[schrittzaehler3] = 9;

661
          Serial.println("Im Array:");

662
          Serial.println(NeuerCode[schrittzaehler3]);

663
          Serial.println("Schrittzaehler3:");

664
          Serial.println(schrittzaehler3);

665
          schrittzaehler3++;

666
        }

667
        if (resetpinstatus == 1) {

668
          schrittzaehler3 = 0;

669
          schrittzaehler3 = 0;

670
          rightcode2 = 0;

671
          schleifenexit1 = 0;

672
          Serial.println("Array geloescht!");

673
        }

674
        if (schrittzaehler3 > 5) schrittzaehler3 = 0;

675
      }

676
677
678
679
      if (absenden == 1) {

680
681
682
        for (int i = 0; i < 6; i++) {

683
          if (NeuerCode[i] < 10) {

684
            arrayvoll++;

685
            Serial.println("Codestellenanzahl");

686
            Serial.println(arrayvoll);

687
688
          }//IF-Abfrage Beenden

689
          else {

690
            schleifenexit1 = 1;

691
            schleifenexit2 = 1;

692
            arrayvoll = 0;

693
            schrittzaehler3 = 0;

694
            Serial.println("Schleife wird verlassen");

695
          }

696
        } //For-Schleifen Beenden

697
698
        if (arrayvoll < 6) arrayvoll = 0;

699
        if (arrayvoll == 6) {

700
          Serial.println("6 Zahlen eingegeben");

701
          schleifenexit1 = 1;

702
          digitalWrite(ledgruen, LOW);

703
          digitalWrite(ledrot, LOW);

704
        }

705
        //else { schleifenexit1=0;

706
        //Serial.println("Zu wenig zahlen eingegeben");

707
708
        // } //Else beenden

709
710
711
      }//Absenden beenden

712
713
714
715
    } //While Beenden

716
717
718
719
720
    //###############################################################################################################################################

721
    //2. Codeeingabe

722
723
724
725
    while (schleifenexit2 == 0) {

726
      // Serial.println("In der 2 While Schleife");

727
728
      BlinkStarttimer = millis();

729
      if (BlinkStarttimer - BlinkEndtimer > 200) {

730
        BlinkEndtimer = BlinkStarttimer;

731
732
733
        if (ledState == LOW)

734
          ledState = HIGH;

735
        else

736
          ledState = LOW;

737
738
        digitalWrite(ledgruen, ledState);

739
        digitalWrite(ledrot, ledState);

740
      }

741
742
743
744
      tastereingabe();

745
746
747
      //Entprellen: Der Code bis zur Einschreiben im Array befindet sich in dem Millis-IF-Statement. Danach gibt die Variable Schritt zur Gleichheitsprüfung weiter.

748
749
      if (Taster0 == 1 || Taster1 == 1 || Taster2 == 1 || Taster3 == 1 || Taster4 == 1 || Taster5 == 1 || Taster6 == 1 || Taster7 == 1 || Taster8 == 1 || Taster9 == 1 || resetpinstatus == 1 || absenden == 1) {

750
751
752
753
        if (Taster0 == 1) {

754
          NeuerCode2[schrittzaehler4] = 0;

755
          Serial.println("Im Array:");

756
          Serial.println(NeuerCode2[schrittzaehler4]);

757
          Serial.println("Schrittzaehler4:");

758
          Serial.println(schrittzaehler4);

759
          schrittzaehler4++;

760
        }

761
        if (Taster1 == 1) {

762
          NeuerCode2[schrittzaehler4] = 1;

763
          Serial.println("Im Array:");

764
          Serial.println(NeuerCode2[schrittzaehler4]);

765
          Serial.println("Schrittzaehler4:");

766
          Serial.println(schrittzaehler4);

767
          schrittzaehler4++;

768
        }

769
        if (Taster2 == 1) {

770
          NeuerCode2[schrittzaehler4] = 2;

771
          Serial.println("Im Array:");

772
          Serial.println(NeuerCode2[schrittzaehler4]);

773
          Serial.println("Schrittzaehler4:");

774
          Serial.println(schrittzaehler4);

775
          schrittzaehler4++;

776
        }

777
        if (Taster3 == 1) {

778
          NeuerCode2[schrittzaehler4] = 3;

779
          Serial.println("Im Array:");

780
          Serial.println(NeuerCode2[schrittzaehler4]);

781
          Serial.println("Schrittzaehler4:");

782
          Serial.println(schrittzaehler4);

783
          schrittzaehler4++;

784
        }

785
        if (Taster4 == 1) {

786
          NeuerCode2[schrittzaehler4] = 4;

787
          Serial.println("Im Array:");

788
          Serial.println(NeuerCode2[schrittzaehler4]);

789
          Serial.println("Schrittzaehler4:");

790
          Serial.println(schrittzaehler4);

791
          schrittzaehler4++;

792
        }

793
        if (Taster5 == 1) {

794
          NeuerCode2[schrittzaehler4] = 5;

795
          Serial.println("Im Array:");

796
          Serial.println(NeuerCode2[schrittzaehler4]);

797
          Serial.println("Schrittzaehler4:");

798
          Serial.println(schrittzaehler4);

799
          schrittzaehler4++;

800
        }

801
        if (Taster6 == 1) {

802
          NeuerCode2[schrittzaehler4] = 6;

803
          Serial.println("Im Array:");

804
          Serial.println(NeuerCode2[schrittzaehler4]);

805
          Serial.println("Schrittzaehler4:");

806
          Serial.println(schrittzaehler4);

807
          schrittzaehler4++;

808
        }

809
        if (Taster7 == 1) {

810
          NeuerCode2[schrittzaehler4] = 7;

811
          Serial.println("Im Array:");

812
          Serial.println(NeuerCode2[schrittzaehler4]);

813
          Serial.println("Schrittzaehler4:");

814
          Serial.println(schrittzaehler4);

815
          schrittzaehler4++;

816
        }

817
        if (Taster8 == 1) {

818
          NeuerCode2[schrittzaehler4] = 8;

819
          Serial.println("Im Array:");

820
          Serial.println(NeuerCode2[schrittzaehler4]);

821
          Serial.println("Schrittzaehler4:");

822
          Serial.println(schrittzaehler4);

823
          schrittzaehler4++;

824
        }

825
        if (Taster9 == 1) {

826
          NeuerCode2[schrittzaehler4] = 9;

827
          Serial.println("Im Array:");

828
          Serial.println(NeuerCode2[schrittzaehler4]);

829
          Serial.println("Schrittzaehler4:");

830
          Serial.println(schrittzaehler4);

831
          schrittzaehler4++;

832
        }

833
        if (resetpinstatus == 1) {

834
          schrittzaehler4 = 0;

835
          schrittzaehler4 = 0;

836
          rightcode2 = 0;

837
          schleifenexit2 = 0;

838
          Serial.println("Array geloescht!");

839
        }

840
        if (schrittzaehler4 > 5) schrittzaehler4 = 0;

841
842
843
      } //Entprellen beenden

844
845
846
847
      if (absenden == 1) {

848
849
        for (int a = 0; a < 6; a++)  {

850
          if (NeuerCode2[a] < 10)  {

851
            arrayvoll2++;

852
            Serial.println("Codestellenanzahl 2");

853
            Serial.println(arrayvoll2);

854
          }//IF-Abfrage Beenden

855
856
          else {

857
            schleifenexit1 = 1;

858
            schleifenexit2 = 1;

859
            arrayvoll = 0;

860
            schrittzaehler4 = 0;

861
            Serial.println("Schleife wird verlassen");

862
          }

863
        } //For-Schleifen Beenden

864
865
866
        if (arrayvoll2 < 6) arrayvoll2 = 0;

867
        if (arrayvoll2 == 6) {

868
          Serial.println("6 Zahlen eingegeben");

869
          schleifenexit2 = 1;

870
871
        }

872
873
        // else {

874
875
        //schleifenexit1=0;

876
        //Serial.println("Nicht Arrayvoll1");

877
878
        //} //Else beenden

879
      }//Absenden beenden

880
881
882
    } //2. While Schleife beenden

883
884
885
886
887
888
889
    //###############################################################################################################################################

890
    //Code wird in das Code[] Array eingetragen-

891
892
893
894
    if (rightcode2 > 6) rightcode = 6;

895
896
    if (arrayvoll == 6 && arrayvoll2 == 6) {

897
      arrayvoll = 0;

898
      arrayvoll2 = 0;

899
900
901
902
      for (int b = 0; b < 6; b++) {

903
        if (NeuerCode[b] == NeuerCode2[b]) {

904
          rightcode2++;

905
          Serial.println("Arrayabgleich (Rightcode");

906
          Serial.println(rightcode2);

907
        }

908
909
        else {

910
          Serial.println("Code Falsch");

911
912
        }//Else Beenden

913
      } //FOR-Beenden

914
915
916
      for (int c = 0; c < 6; c++) {

917
        if (rightcode2 == 6) {

918
          Serial.println("Codeänderung");

919
920
          Code[c] = NeuerCode[c];

921
          rightcode3++;

922
          Serial.println(NeuerCode[c]);

923
          Serial.println(Code[c]);

924
          rightcode = 0;

925
926
        }//IF-Beenden

927
      }//For-Beenden

928
929
930
      //EEPROM Write

931
932
      if (rightcode3 == 6) {

933
        Serial.println("Schreibe Neuen Code in EEPROM");

934
        for (int i = 0; i < EEsize; i++) {

935
          EEPROM.write(i, Code[i]);

936
        }

937
        rightcode3 = 0;

938
        rightcode2 = 0;

939
      }

940
941
942
    } //Arrayvoll-IF

943
  } //IF-Beenden

944
} //Gesamten Code beenden

945
946
947
948
//########################################################################################################################################################################

949
950
951
952
//Funktionen

953
954
void arrayreset() {

955
956
  for (int i = 0; i < 6; i++) {

957
    Codeeingabe[i] = 10;

958
  }

959
}

960
961
962
963
void tastereingabe() {

964
965
966
967
968
  byte key = tasterpad.getKey(); //Key Libary wartet auf gedrückte Tasten

969
  //Eingabe

970
  if (key == 48) {

971
    Taster0 = 1;

972
  }   //Bei nur einem Befehl im IF/Else-Statement kann man sich eigentlich die geschwungenen Klammenrn {} sparen.

973
  else                            {

974
    Taster0 = 0;

975
  }

976
  if (key == 49) {

977
    Taster1 = 1;

978
  }

979
  else                            {

980
    Taster1 = 0;

981
  }

982
  if (key == 50) {

983
    Taster2 = 1;

984
  }

985
  else                            {

986
    Taster2 = 0;

987
  }

988
  if (key == 51) {

989
    Taster3 = 1;

990
  }

991
  else                            {

992
    Taster3 = 0;

993
  }

994
  if (key == 52) {

995
    Taster4 = 1;

996
  }

997
  else                            {

998
    Taster4 = 0;

999
  }

1000
  if (key == 53) {

1001
    Taster5 = 1;

1002
  }

1003
  else                            {

1004
    Taster5 = 0;

1005
  }

1006
  if (key == 54) {

1007
    Taster6 = 1;

1008
  }

1009
  else                            {

1010
    Taster6 = 0;

1011
  }

1012
  if (key == 55) {

1013
    Taster7 = 1;

1014
  }

1015
  else                            {

1016
    Taster7 = 0;

1017
  }

1018
  if (key == 56) {

1019
    Taster8 = 1;

1020
  }

1021
  else                            {

1022
    Taster8 = 0;

1023
  }

1024
  if (key == 57) {

1025
    Taster9 = 1;

1026
  }

1027
  else                            {

1028
    Taster9 = 0;

1029
  }

1030
  if (key == 35) {

1031
    absenden = 1;

1032
  }

1033
  else                            {

1034
    absenden = 0;

1035
  }

1036
  if (key == 42) {

1037
    resetpinstatus = 1;  //RESET: Wenn der Code falsch eingegeben wurde werden hier die Zähler & das Array zurückgesetzt.

1038
  }

1039
  else                            {

1040
    resetpinstatus = 0;

1041
  }

1042
}

1043
1044
//########################################################################################################################################################################


  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Quark (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Max E. schrieb:
> Hier die gesamte Source,
Was ist an "Längeren Sourcecode nicht im Text einfügen, sondern als 
Dateianhang" nicht zu verstehen?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Bitflüsterer (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Quark schrieb:
> Max E. schrieb:
>> Hier die gesamte Source,
> Was ist an "Längeren Sourcecode nicht im Text einfügen, sondern als
> Dateianhang" nicht zu verstehen?

Ich nehme mal an, was nicht zu verstehen ist, ist: "Längeren Sourcecode 
nicht im Text einfügen, sondern als Dateianhang" Und da so einfach Sätze 
schon hinter dem Horizont liegen, traktieren uns die lieben Frager noch 
mit so'm blöden Zeug, dass ihnen ohnehin nichts nützt, wenn wir es 
verstehen.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Asdf A.
        (eizi)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Tut mir leid, ich habs einfach überlesen. Werds beim nächsten mal anders 
machen da ich den Beitrag nun nicht mehr bearbeiten kann.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Walter (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
schleifenendzeit wird nur ein Mal auf 0 initialisiert

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        Walter (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
oops, übersehen!
Aber was ist mit Überlauf?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Millis in while-Schleife
  


  

    

      von
      
        J. T.
        (chaoskind)
        
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Fuses falsch gesetzt?

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.