Guten Tag Ich habe ein Problem, ich möchte von 6 Tastern die Reihenfolge merken. (H1,H2,H3,H4,H5,H6). Zu den Tastern gibt es 6 LEDs (L1,L2,L3,L4,L5,L6); Beispiel: die Taster wurden in der folgenden Reihenfolge gedrückt und gedrückt gehalten. H1, H2, H4, H5, H6, H3 L1 leuchtet so lange, bis H1 nicht mehr gedrückt ist. In diesem Moment geht L2 an und leuchtet so lange, bis H2 nicht mehr gedrückt ist. In diesem Moment geht L4 an und leuchtet so lange, bis H4 nicht mehr gedrückt ist, und so weiter. Ich habe keinen Plan wie vorzugehen. Bei drei Tastern hätte ich es geschafft weil weniger Kombinationen vorkämen. Ich dachte an Arrays oder so die, die Reihenfolge abspeichert und dann ausgibt. Aber kann dies nicht umsetzen. Ich wäre sehr Froh wenn ihr mir weiterhelfen könntet.
Elektro F. schrieb: > Ich dachte an Arrays oder > so die, die Reihenfolge abspeichert und dann ausgibt. Zähle einfach den Arrayindex hoch, wenn eine weitere Taste gedrückt wird und speichere dort deren Nummer ab. Zur Ausgabe läufst Du das Array hoch, wenn eine Taste losgelassen wird. Was soll den passieren, wenn das Loslassen in anderer Reihenfolge erfolgt? 6 Tasten gedrückt zu halten, sind das rastende Tasten?
Elektro F. schrieb: > L1 leuchtet so lange, bis H1 nicht mehr gedrückt ist. > > In diesem Moment geht L2 an und leuchtet so lange, bis H2 nicht mehr > gedrückt ist. > > In diesem Moment geht L4 an und leuchtet so lange, bis H4 nicht mehr > gedrückt ist, und so weiter. Das ist keine vollständige Beschreibung des gewünschten Verhaltens. Allenfalls ein Beispiel. Zuerst musst du dir klarwerden wie dein Verhalten sein soll und das so beschreiben dass es jemand anderes verstehen kann. Erst dann kann man das in Software machen.
Peter D. schrieb: > Elektro F. schrieb: >> Ich dachte an Arrays oder >> so die, die Reihenfolge abspeichert und dann ausgibt. > > Zähle einfach den Arrayindex hoch, wenn eine weitere Taste gedrückt wird > und speichere dort deren Nummer ab. > Zur Ausgabe läufst Du das Array hoch, wenn eine Taste losgelassen wird. Versuche dies mal so umzusetzen > Was soll den passieren, wenn das Loslassen in anderer Reihenfolge > erfolgt? dann soll dieser Taster übersprungen werden der in der falschen Reihenfolge losgelassen wird und seine LED wird nicht leuchten, ausser alles startet von Neu. > 6 Tasten gedrückt zu halten, sind das rastende Tasten? Ja Vielen Dank für deine Antwort
Elektro F. schrieb: > Beispiel: die Taster wurden in der folgenden Reihenfolge gedrückt und > gedrückt gehalten. H1, H2, H4, H5, H6, H3 > > L1 leuchtet so lange, bis H1 nicht mehr gedrückt ist. > > In diesem Moment geht L2 an und leuchtet so lange, bis H2 nicht mehr > gedrückt ist. > > In diesem Moment geht L4 an und leuchtet so lange, bis H4 nicht mehr > gedrückt ist, und so weiter. Nette Schulaufgabe, mal was Neues... ;-) Was soll passieren, wenn die H2 vor der H1 losgelassen wird? Zur Problemlösung: Du musst ein Progamm schreiben, das laufend 1. die Tasten abfragt und bei einer "Einschaltflanke" (die kann pyhsikalisch steigend oder fallend sein, je nachdem wie die Taster angeschlossen sind) den Tasterdruck in einen Ringpuffer schreiben. Und dann muss das Programm 2. die "nächste Taste" im Ringpuffer auslesen, die zugejörige Lampe einschalten und kontrollieren, ob die Taste noch immer gedrückt ist. Falls nicht, dann wird die Lampe ausgeschaltet und der Index für die "nächste Taste" hochgezählt.
:
Bearbeitet durch Moderator
Elektro F. schrieb: > ausser alles startet von Neu. Und was ist das Kriterium dafür? Wann startet alles 'Neu'? Was soll passieren wenn H1, H2, und H3 nacheinander gedrückt wurden, dann H1 losgelassen wird und L2 leuchtet, dann aber H1 wieder gedrückt wird? Du siehst, daß deine Beschreibung diverse Fälle noch nicht abdeckt.
Elektro F. schrieb: > Dann wird H1 wieder hintenangestellt. Und "vorne" rausgelöscht? Das wird langsam doch nett aufwendig. Denn jetzt musst du auch noch die "Loslassflanke" erkennen und das Array umsortieren oder Einträge darin invalidieren. Ich denke, du solltest da mal die komplette Bedienlogik mit allen diesen Ausnahme- und Sonderfällen genau spezifizieren.
Elektro F. schrieb: > Dann wird H1 wieder hintenangestellt. Und bei Tasten, die noch nicht an der Reihe waren? Und Du siehst wirklich noch selber durch, was das Ganze werden soll?
Diese die Tasten die nicht an der Reihe waren, kommen einfach nicht dran. Wisst ihr wie ich eine for schleife mache die an eine Bedingung geknüpft ist? Wenn ein Taster gedrückt wird auf positive Flanke, soll die for Schleife nur eins raufzählen.
Also ein Array wäre ja dann doch sehr komplex, bedingt durch das mitten drin löschen, sortieren, hinten doch wieder einfügen usw. Dann dachte ich an FIFO, aber da wirds auch net besser mit zwischen drin was herauslöschen usw. Eigentlich wären ja verkettete Listen dafür perfekt :-D Kurz umhängen oder hinten anhängen...
:
Bearbeitet durch User
Adam P. schrieb: > Also ein Array wäre ja dann doch sehr komplex, > bedingt durch das mitten drin löschen, sortieren, hinten doch wieder > einfügen usw. > > Dann dachte ich an FIFO, aber da wirds auch net besser mit zwischen drin > was herauslöschen usw. > > Eigentlich wären ja verkettete Listen dafür perfekt :-D > Kurz umhängen oder hinten anhängen... Ok davon habe ich kein Plan
Es wird Zeit für ein gutes Buch über die Einführung ins Programmieren. So mit Schleifen, Arrays, Kontrollstrukturen etc. Prgrammieren ist mehr als Copy&Paste.
Elektro F. schrieb: > Ok davon habe ich kein Plan Also das geht schon mit Arrays, aber da sollte man dann doch schon wissen wie und was man macht. Das ist nicht eben mal eine for-Schleife und 2-3 if-Abfragen.
Elektro F. schrieb: > Wenn ein Taster gedrückt wird auf positive Flanke, soll die for Schleife > nur eins raufzählen. Deine Denkweise und der daraus resultierende Ansatz ist nicht zur Problemlösung geeignet. Es ist einfach so: du hast genau 1 Schleife in deinem Programm. Das ist die Hauptschleife. Die wird so schnell wie möglich so oft wie möglich durchlaufen. In dieser Hauptschleife liest du pro Durchlauf die Eingänge ein, erkennst Flanken und aktualisierst deine "Tastentabelle" entsprechend. Dann rechnest du aus den Eingängen und dem aktuellen Zustand in der "Tastentabelle" den ein- oder auszuschaltenden Ausgang und aktualiserst diesen. Danach ist ein Schleifendurchlauf zu Ende und du fängst sofort wieder von vorn an. Pro Sekunde darf die Hauptschleife ruhig 10000 mal oder noch öfter durchgerechnet werden.
:
Bearbeitet durch Moderator
Weiterhin solltest du auf folgende Situation achten: Erste Taste wird nicht losgelassen, die anderen werden wild herumgedrückt, sprich immer wieder neu eingereiht => Dies würde zu einem Buffer Overflow führen oder wenn du dies abfängst, kannst du keine neuen Ereignisse speichern. Das sollte man sich erstmal alles grob aufzeichnen und durchdenken.
Adam P. schrieb: > Also ein Array wäre ja dann doch sehr komplex, > bedingt durch das mitten drin löschen, sortieren, hinten doch wieder > einfügen usw. Ganz so schlimm ist das nicht. Es wird ja nur der erste Eintrag gelöscht, also einfach das Array um 1 nach unten kopieren. Für einen Neuling erscheint mir diese Aufgabe aber auch zu komplex. Man hat es ja schon schwer, den Ablauf zu verstehen. @Elektro F. Hat das irgend einen praktischen Hintergrund oder ist alles nur Spielerei?
Adam P. schrieb: > Dies würde zu einem Buffer Overflow führen Wenn es nur 6 Tasten gibt, dann braucht man nur einen Buffer mit 6 Speicherplätzen... Man könnte sich z.B. auch nicht die Reihenfolge der 6 Tasten speichern, sondern Betätigungszeitpunkte. Und wenn ich so drüber nachdenke, hätte dieser Ansatz einige Vorteile ;-)
Lothar M. schrieb: > Wenn es nur 6 Tasten gibt, dann braucht man nur einen Buffer mit 6 > Speicherplätzen... Ja da waren meine Finger schneller :-D Klar hast ja recht, da bei jedem loslassen, dass Array neu sortiert wird.
Dann scheint es ja gar net so wild zu sein. Die Stellen im Array sind im unbenutztem Zustand immer 0. Die Tasten bekommen Werte von 1-6. Und bei jeder "loslass"-Flanke checkt man das Array und entfernt die Taste daraus bzw. schiebt alles eins nach vorne. Hab da zuerst viel zu komplex gedacht...
:
Bearbeitet durch User
Und als aller erstes die Entprellung der Tasten nicht vergessen. Ansonsten wird das lustig mit der Flankenerkennung.
N. M. schrieb: > Und als aller erstes die Entprellung der Tasten nicht vergessen. > Ansonsten wird das lustig mit der Flankenerkennung. Wenn man genau drüber nachdenkt, dann ist das bei der Anwendung hier allerdings unkritisch. Höchstens einer drückt die Tasten im ms-Abstand UND es kommt dann tatsächlich noch auf die Reihenfolge an... Aber dann muss man gleich auch die Frage beantworten: was gilt denn dann als "zuerst betätigt"? Der Taster, der zuerst Kontakt gegeben hat, oder der, der sich zuerst "beruhigt" hat?
:
Bearbeitet durch Moderator
Lothar M. schrieb: > was gilt denn dann > als "zuerst betätigt"? Der Taster, der zuerst Kontakt gegeben hat, oder > der, der sich zuerst "beruhigt" hat? Ich glaub das wäre egal, wenn man die Tasten alle 1ms einliest. Beim Interrupt würde ich vllt. die Flanke nehmen, aber ohne könnte auch folgendes passieren: - beide Taster sind 0 (Zeitpunkt 0.0ms) - T1 wird gedrückt (Zeitpunkt 0.2ms) - T2 wird gedrückt (Zeitpunkt 0.8ms) - Tasten werden eingelesen => beide 1 (Zeitpunkt 1.0ms) Was war dann nun zu erst - beide gleichzeitig? Aber das liegt dann an der Abtastung. Kommt auf die Anforderung an.
:
Bearbeitet durch User
Adam P. schrieb: > Beim Interrupt Zur Lösung dieser Aufgabe wird (zumindest nach bisherigen Anforderungen) kein Interrupt benötigt (bisher noch nicht mal der des millis()-Timers, der sowieso läuft). > Was war dann nun zu erst - beide gleichzeitig? Jetzt wirds philosophisch, denn im echten Leben passiert nichts "gleichzeitig". Da sind immer ein paar fs oder gar ps dazwischen. Schon insofern kann man sich diese "Gleichzeitigkeitsdiskussion" schenken. Und natürlich besonders auch, weil Mechanik bis hin zum mechanischen Kontakt im Spiel ist und Spiel hat.
Lothar M. schrieb: > Wenn man genau drüber nachdenkt, dann ist das bei der Anwendung hier > allerdings unkritisch. Was den Endzustand angeht wahrscheinlich schon. Ich habe mir gerade nur das Feuerwerk im Hintergrund vorgestellt bzgl. Listen oder Reihenfolgen umsortieren wenn die Taster prellen. Lothar M. schrieb: > was gilt denn dann als "zuerst betätigt"? Der Taster, der zuerst Kontakt > gegeben hat, oder der, der sich zuerst "beruhigt" hat? Man könnte ja auch entprellen und sich den Timestamp der Pegelwechsel (ungefiltert) merken.
N. M. schrieb: > Man könnte ja auch entprellen und sich den Timestamp der Pegelwechsel > (ungefiltert) merken. Mit einem Timestamp ist es noch einfacher: man fragt einfach in jedem Durchlauf ab, ob der Taster x gedrückt ist. Falls nicht, trägt man die aktuelle Zeit in den Speicherplatz für den Taster x ein. Aber falls der Taster x gedrückt ist, dann wird nichts geändert und es bleibt der letzte Zeitpunkt drin, an dem er nicht betätigt war.
:
Bearbeitet durch Moderator
Vielleicht sollte man die ganze Entprell-Geschichte hier vorerst beenden und den TO erstmal die Hauptfunktionalität schreiben lassen :) Einfach jede 10 oder 100ms einlesen und schauen ob der Rest funktioniert, verfeinern kann man immer noch. Hab da so den Eindruck, dass solche Diskussionen (auch wenn wichtig) einige Anfänger eher überfordern als helfen.
Adam P. schrieb: > Einfach jede 10 oder 100ms einlesen Nein, ich würde hier die Zeit samt Prellen komplett ignorieren. Man muss sich nicht in Zeiten pressen, wo keine Zeit nötig ist. Denn auch wenn es allzu menschlich ist, in Zeiten statt in Zuständen zu denken, so sind hier zu Lösung der Aufgabe nur Zustände interessant. Denn wenn der H1 und der H2 nacheinander gedrückt wurden, dann der H3 gedrückt wird und prellt, und danach der H4 gedrückt wird und prellt, dann muss halt der zeitliche Abstand zwischen dem Betätigen von H3 und H4 so lang sein, dass das Prellen kein Thema ist. Und dann wird durch das Prellen nur am Ende der Tabelle der H3 ein paar mal eingetragen und wieder gelöscht.
:
Bearbeitet durch Moderator
Es sind schlussendlich auch keine Taster sondern Helligkeitstransistoren, ich wollte es einfach zum vereinfacht darzustellen mit Taster zeigen.
Elektro F. schrieb: > Es sind schlussendlich auch keine Taster sondern > Helligkeitstransistoren Je nach Beschaltung, hätten wir uns da aber die ganze Entprell-Geschichte sparen können! ...
Adam P. schrieb: > Je nach Beschaltung, hätten wir uns da aber die ganze > Entprell-Geschichte sparen können! ... Welche ganze Geschichte denn? Entprellen ist doch nur die Lib im Timerinterrupt einbinden und dann im Main das Eventbit testen. Da die Mainloop keinerlei Zeit benötigt, geht aber auch ein 10ms Delay für den Libaufruf. Oder auch meine Macrovariante.
Peter D. schrieb: > Entprellen ist doch nur die Lib Ja...die eine Sache ist, einfach was verwenden und nich wissen was da eigentlich passiert - oder - es verstehen und selbst schreiben. Ich verwende selbst bei Arduino so gut es geht keine Libs. Die können so funktionieren wie man es sich wünscht, müssen aber nicht, schon alles erlebt. Es war auf das ganze Gespräch bzgl. Entprellen bezogen.
Adam P. schrieb: > Ich verwende selbst bei Arduino so gut es geht keine Libs. Ich verwende auch nur wenige. Aber ich gucke gerne von open-source ab, deswegen finde ich schon gut, dass so vieles veröffentlicht wurde.
Elektro F. schrieb: > Es sind schlussendlich auch keine Taster sondern Helligkeitstransistoren Und das Ganze ist final auch nur ein Teil der üblichen Salami...
:
Bearbeitet durch Moderator
tldr; Was ich vermisse in der ganzen Diskussion ist das Stichwort 'queue'...
Klaus schrieb: > Was ich vermisse in der ganzen Diskussion ist das Stichwort 'queue'... Das ist der neudeutsche Ausdruck für einen Ringpuffer. Und der war schon recht bald im Gespräch. Ein weiterer Name wäre auch Fifo. Allerdings funkt dabei das "loslassen und nochmal drücken" ganz heftig dazwischen...
:
Bearbeitet durch Moderator
Lothar M. schrieb: > Mit einem Timestamp ist es noch einfacher: man fragt einfach in jedem > Durchlauf ab, ob der Taster x gedrückt ist. > Falls nicht, trägt man die aktuelle Zeit in den Speicherplatz für den > Taster x ein. Der beigefügte Entwurf versucht die Idee umzusetzen. Ist etwas gesprächig, Led 99 meint keine LED an.
1 | Neu 2 |
2 | Led aus 99 |
3 | Led an 2 |
4 | Neu 0 |
5 | Neu 1 |
6 | Weg 2 |
7 | Led aus 2 |
8 | Led an 0 |
9 | # Zeit
|
10 | 0 8404 |
11 | 1 10150 |
12 | 2 0 |
13 | 3 0 |
14 | 4 0 |
15 | 5 0 |
16 | Weg 0 |
17 | Led aus 0 |
18 | Led an 1 |
19 | Weg 1 |
20 | Led aus 1 |
21 | Led an 99 |
Gelegentliches Prellen inklusive, stört aber nicht weiter
1 | Neu 0 |
2 | Neu 5 |
3 | Weg 5 |
4 | Neu 5 |
5 | Weg 5 |
6 | Neu 5 |
7 | Weg 5 |
Auch "Warteschlange" wäre richtig, wird allerdings von jedem verstanden.
LostInMusic schrieb: > Auch "Warteschlange" wäre richtig, wird allerdings von jedem verstanden. Das darf natürlich nicht sein, ist zu einfach.
Elektro F. schrieb: > Es sind schlussendlich auch keine Taster sondern > Helligkeitstransistoren, ich wollte es einfach zum vereinfacht > darzustellen mit Taster zeigen. beschreib doch mal dein PROBLEM (den Anwendungsfall), und nicht deine vermeintliche LÖSUNG. (Tasten, Lampen an oder aus etc)
Lothar M. schrieb: > Klaus schrieb: >> Was ich vermisse in der ganzen Diskussion ist das Stichwort 'queue'... > Das ist der neudeutsche Ausdruck für einen Ringpuffer. Und der war schon > recht bald im Gespräch. Ein weiterer Name wäre auch Fifo. Genau das meine ich damit: Mit jedem dieser Begriffe kann Elektro F. offensichtlich absolut gar nichts anfangen. Merkt denn keiner, dass ihr den guten Mann komplett überfordert? Und dann noch ablenkende Zwischenrufe wie "Listen oder Reihenfolgen umsortieren wenn die Taster prellen"... Leute, bitte !!! Ich hab so eine dumpfe Ahnung, dass Elektro F. eigentlich was total Banales bauen will. Der verquirkten Beschreibung nach bin ich mir da sogar fast sicher. Irgendwas wie 6 Lichtschranken/Bewegungsmelder (in sich kreuzenden Fluren?), dazu 6 Leuchten, die er der Reihe nach einschalten will - und die sich verzögert wieder ausschalten sollen? Aber macht mal wie ihr denkt, für so komplexe Probleme bin ich zu einfältig...
Klaus schrieb: > Mit jedem dieser Begriffe kann Elektro F. offensichtlich absolut gar > nichts anfangen. Darf man deshalb diese Begriffe nicht verwenden? Muss man sich eine weichgespülte Version dieser Begriffe überlegen? > Und dann noch ablenkende Zwischenrufe wie "Listen oder Reihenfolgen > umsortieren wenn die Taster prellen"... Ja, da hätte er leichter mal gleich nicht mit Tastern angefangen, die kurz danach wie Schalter rasten und letztlich dann nocht zu Transistoren mutieren. > Irgendwas wie 6 Lichtschranken/Bewegungsmelder > dazu 6 Leuchten, die er der Reihe nach einschalten will > und die sich verzögert wieder ausschalten sollen? Und wofür bräcuhte man da eine Abhängigkeit untereinander? Aber ich hätte da auch noch ein paar solcher Ideen, die würden den TO aber noch mehr verwirren. > Ich hab so eine dumpfe Ahnung Ja, da kann nur einer Licht ins Dunkel bringen. Und der beste Ansatz ist eben wie üblich, nicht die geplante Lösung, sondern die eigentliche Aufgabe zu beschreiben. Elektro F. schrieb: > Bei drei Tastern hätte ich es geschafft Dann zeig doch mal, wie du das mit 3 Tasten machen würdest. Vielleicht klappt ja der Weg übers Reengineering besser... ;-)
:
Bearbeitet durch Moderator
Ich denke ich würde die Pins für Taster und LED-Diode in ein Struct packen. Für die Reihenfolge kommt dann eine doppelt verkettete Liste zum Einsatz. Das sieht dann ungefähr so aus:
1 | struct ButtonLedThingy {
|
2 | PIN buttonPin; |
3 | bool lastButtonState; |
4 | |
5 | struct ButtonLedThingy *next; |
6 | struct ButtonLedThingy *prev; |
7 | |
8 | PIN ledPin; |
9 | } |
10 | |
11 | #define COUNT 6 |
12 | struct ButtonLedThingy thingies[COUNT] = { ... };
|
13 | struct ButtonLedThingy *DVListStart = nullptr; |
Die Flankenerkennung ob ein Taster gedrückt oder losgelassen wird sieht dann so aus:
1 | void checkButton(struct ButtonLedThingy *thingie) |
2 | {
|
3 | auto state = digitalRead(thingie->buttonPin); |
4 | |
5 | if(state != thingie->lastButtonState) |
6 | {
|
7 | if(state == false) |
8 | {
|
9 | removeThingie(thingie); |
10 | } |
11 | else |
12 | {
|
13 | addThingie(thingie); |
14 | } |
15 | } |
16 | |
17 | thingie->lastButtonState = state; |
18 | } |
19 | |
20 | void updateButtons() |
21 | {
|
22 | for(int x=0; x<COUNT; x++) |
23 | {
|
24 | checkButton(&thingies[x]); |
25 | } |
26 | } |
Dann fehlen noch removeThingie() und addThingie(), die die doppelt verkettete Liste verwalten. Als Startpunkt dient hier DVListStart. next und prev dienen zum durchhangeln durch die Liste. Eventuell sollten removeThingie() und addThingie() noch das Update der LEDs übernehmen.
Anbei mal ein fertiger Code (ungetestet). Die Pins habe ich von 1..12 durchnumeriert, da muß man dann die gewünschte Zuordnung eintragen. Ein Entprellen ist nicht nötig. Zur Übersicht habe ich alle Schritte in kleine Funktionen unterteilt. In der Loop sieht man schön das EVA-Prinzip. Der mit Abstand schwerste Schritt war aus den verschiedensten Textschnipseln den (hoffentlich korrekten) Ablauf herzuleiten.
Peter D. schrieb: > Anbei mal ein fertiger Code (ungetestet). läuft perfekt mit zwei Ergänzungen: a) in Setup() die pinModes festlegen, sonst sieht man nichts
1 | for (uint8_t i = 0; i < KEY_COUNT; i++) |
2 | {
|
3 | pinMode(key_pins[i], INPUT_PULLUP); |
4 | pinMode(led_pins[i], OUTPUT); |
5 | }
|
b) in input_keys() musste ich negieren, bei meiner "Hardware" ist key pressed LOW/FALSE
1 | key_input[i] = !digitalRead( key_pins[i] ); // low is key pressed |
Bin ja gespannt ob sich der TO nochmal meldet.
:
Bearbeitet durch User
Helmut H. schrieb: > Bin ja gespannt ob sich der TO nochmal meldet. Ja evtl. war das alles mal wieder für die Katz...
Danke Leute für die vielen Beispiele und Denkenssprünge. Ich habe es nun geschaft, ich werde den Code noch ein wenig verschönern und den Variablen bessere Namen geben. Anschliessend lade ich den Code hier rauf.
Hier ist noch der fertige Code
1 | //Initialisierung Helligkeitssensor
|
2 | char H1 = 8; |
3 | char H2 = 9; |
4 | char H3 = 10; |
5 | char H4 = 11; |
6 | char H5 = 12; |
7 | char H6 = 13; |
8 | |
9 | //Initialisierung LEDs
|
10 | char L1 = 2; |
11 | char L2 = 3; |
12 | char L3 = 4; |
13 | char L4 = 5; |
14 | char L5 = 6; |
15 | char L6 = 7; |
16 | |
17 | char x1 = 0; |
18 | char x2 = 0; |
19 | char x3 = 0; |
20 | char x4 = 0; |
21 | char x5 = 0; |
22 | char x6 = 0; |
23 | |
24 | //Initialisierung Hilfsvariablen
|
25 | char Schritt1 = 0; |
26 | char Schritt2 = 0; |
27 | char Schritt3 = 0; |
28 | char Schritt4 = 0; |
29 | char Schritt5 = 0; |
30 | char Schritt6 = 0; |
31 | |
32 | char LED_war_H = 0; |
33 | char LED_war_H_2 = 0; |
34 | char LED_war_H_3 = 0; |
35 | char LED_war_H_4 = 0; |
36 | char LED_war_H_5 = 0; |
37 | char LED_war_H_6 = 0; |
38 | |
39 | char Prufung1 = 0; |
40 | char Prufung2 = 0; |
41 | char Prufung3 = 0; |
42 | char Prufung4 = 0; |
43 | char Prufung5 = 0; |
44 | char Prufung6 = 0; |
45 | |
46 | char Schritt1_Sensor_var = 0; |
47 | char Schritt2_Sensor_var = 0; |
48 | char Schritt3_Sensor_var = 0; |
49 | char Schritt4_Sensor_var = 0; |
50 | char Schritt5_Sensor_var = 0; |
51 | char Schritt6_Sensor_var = 0; |
52 | |
53 | char Sensorprufung[4] = {1,2,3,4}; |
54 | |
55 | |
56 | char LED_ist_wieder_L = 0; |
57 | char LED_ist_wieder_L_2 = 0; |
58 | char LED_ist_wieder_L_3 = 0; |
59 | char LED_ist_wieder_L_4 = 0; |
60 | char LED_ist_wieder_L_5 = 0; |
61 | char LED_ist_wieder_L_6 = 0; |
62 | |
63 | char Flanke_S1 = 2; |
64 | char Flanke_S2 = 2; |
65 | char Flanke_S3 = 2; |
66 | char Flanke_S4 = 2; |
67 | char Flanke_S5 = 2; |
68 | char Flanke_S6 = 2; |
69 | |
70 | char Flank1 = 0; |
71 | char Flank2 = 0; |
72 | char Flank3 = 0; |
73 | char Flank4 = 0; |
74 | char Flank5 = 0; |
75 | char Flank6 = 0; |
76 | |
77 | char Erster_Durchlauf = 0; |
78 | |
79 | char Flankenerkennung1 = 0; |
80 | char Flankenerkennung2 = 0; |
81 | char test = 0; |
82 | char test1 = 0; |
83 | char test2 = 0; |
84 | char test3 = 0; |
85 | char test4 = 0; |
86 | char test5 = 0; |
87 | char test6 = 0; |
88 | float Schritte[6]= {0,0,0,0,0,0}; |
89 | float Pruefen[6]= {0,0,0,0,0,0}; |
90 | float Flanke[6] = {0,0,0,0,0,0}; |
91 | |
92 | char step1 = 0; |
93 | char step2 = 0; |
94 | char step3 = 0; |
95 | char step4 = 0; |
96 | char step5 = 0; |
97 | char step6 = 0; |
98 | |
99 | char step1_immer_noch_H = 0; |
100 | char step2_immer_noch_H = 0; |
101 | char step3_immer_noch_H = 0; |
102 | char step4_immer_noch_H = 0; |
103 | char step5_immer_noch_H = 0; |
104 | char step6_immer_noch_H = 0; |
105 | |
106 | void setup() { |
107 | pinMode(H1,INPUT); |
108 | pinMode(H2,INPUT); |
109 | pinMode(H3,INPUT); |
110 | pinMode(H4,INPUT); |
111 | pinMode(H5,INPUT); |
112 | pinMode(H6,INPUT); |
113 | |
114 | pinMode(L1,OUTPUT); |
115 | pinMode(L2,OUTPUT); |
116 | pinMode(L3,OUTPUT); |
117 | pinMode(L4,OUTPUT); |
118 | pinMode(L5,OUTPUT); |
119 | pinMode(L6,OUTPUT); |
120 | |
121 | Serial.begin(9600); |
122 | |
123 | }
|
124 | void loop() |
125 | {
|
126 | |
127 | float LEDs[6] = {L1,L2,L3,L4,L5,L6}; |
128 | float Sensoren[6] = {H1,H2,H3,H4,H5,H6}; |
129 | float Sensoren_variable[6] = {H1,H2,H3,H4,H5,H6}; |
130 | |
131 | |
132 | Sensoren[0] = digitalRead(H1); |
133 | Sensoren[1] = digitalRead(H2); |
134 | Sensoren[2] = digitalRead(H3); |
135 | Sensoren[3] = digitalRead(H4); |
136 | Sensoren[4] = digitalRead(H5); |
137 | Sensoren[5] = digitalRead(H6); |
138 | // digitalWrite(L4, HIGH);
|
139 | /*
|
140 | if((Sensoren[0] == LOW)||(Sensoren[1] == LOW)||(Sensoren[2] == LOW)||(Sensoren[3] == LOW)||(Sensoren[4] == LOW)||(Sensoren[5] == LOW)){
|
141 | Serial.println("Nix");
|
142 |
|
143 | } */
|
144 | Serial.println(Flank1,DEC); |
145 | |
146 | //Schritt1------------------------------------------------------------------------------------------------------------
|
147 | if(((Sensoren[0] == HIGH)||(Sensoren[1] == HIGH)||(Sensoren[2] == HIGH)||(Sensoren[3] == HIGH)||(Sensoren[4] == HIGH)||(Sensoren[5] == HIGH)) &&((Flank1 == 0)||(Flank1 == 6))){ |
148 | |
149 | |
150 | for(int x = 0; x < 6 ; x ++){ |
151 | |
152 | if ((Schritte[0] == 0) && (Sensoren[x] == HIGH)&&(Flanke[x]== 0)){ //zb 1 |
153 | |
154 | Schritt1 = Sensoren_variable[x]; // sensor variable damit nicht schritt 1 HIGH zugewiesen wird |
155 | Schritte[0] = LEDs[x]; // zb 1 |
156 | Flanke[x] = 1; |
157 | x1 = x; |
158 | Flank1 = 1; |
159 | test = 1; |
160 | |
161 | }
|
162 | }
|
163 | }
|
164 | |
165 | step1 = digitalRead(Schritt1); |
166 | |
167 | if((step1 == HIGH)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L == 1))||(Erster_Durchlauf == 0))){ |
168 | digitalWrite(Schritte[0],HIGH); |
169 | if(test == 1){ |
170 | LED_ist_wieder_L = 0; |
171 | //Serial.println("1");
|
172 | step1_immer_noch_H = 1; |
173 | }
|
174 | |
175 | }
|
176 | |
177 | if(step1 == LOW){ |
178 | digitalWrite(Schritte[0],LOW); |
179 | Flanke[x1] = 0; |
180 | LED_ist_wieder_L = 1; |
181 | //Serial.println("10");
|
182 | //löschen
|
183 | Schritte[0] = 0; |
184 | Schritt1 = 0; |
185 | step1 = 0; |
186 | test = 0; |
187 | step1_immer_noch_H = 0; |
188 | }
|
189 | |
190 | |
191 | //Ende Schritt 1 ---------------------------------------------------------------------------------------------------------
|
192 | |
193 | |
194 | //Schritt2 ---------------------------------------------------------------------------------------------------------------
|
195 | if(((Sensoren[0] == HIGH)||(Sensoren[1] == HIGH)||(Sensoren[2] == HIGH)||(Sensoren[3] == HIGH)||(Sensoren[4] == HIGH)||(Sensoren[5] == HIGH)) &&(Flank1 == 1)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt |
196 | |
197 | delay(100); |
198 | Sensoren[0] = digitalRead(H1); |
199 | Sensoren[1] = digitalRead(H2); |
200 | Sensoren[2] = digitalRead(H3); |
201 | Sensoren[3] = digitalRead(H4); |
202 | Sensoren[4] = digitalRead(H5); |
203 | Sensoren[5] = digitalRead(H6); |
204 | |
205 | for(int x = 0; x < 6 ; x ++){ |
206 | |
207 | if ((Sensoren[x] == HIGH)&&(Flanke[x] == 0)&&(Schritte[1] == 0)){ //zb 1 |
208 | //Entprellen
|
209 | delay(100); |
210 | Sensoren[x] = digitalRead(Sensoren[x]); |
211 | |
212 | if (Sensoren[x] == HIGH){ |
213 | Pruefen[1] = Sensoren_variable[x]; |
214 | Prufung2 = Sensorprufung[x]; |
215 | |
216 | Schritte[1] = LEDs[x]; |
217 | Schritt2 = Sensoren_variable[x]; // sensor variable damit nicht schritt 1 HIGH zugewiesen wird |
218 | Flanke[x] = 1; |
219 | Flank1 = 2; |
220 | Flank2 = Flank1; |
221 | Schritt2_Sensor_var = Sensoren_variable[x]; |
222 | test2 = 1; |
223 | digitalWrite(LED_BUILTIN, LOW); |
224 | x2 = x; |
225 | |
226 | }
|
227 | // }
|
228 | }
|
229 | }
|
230 | |
231 | |
232 | }
|
233 | |
234 | step2 = digitalRead(Schritt2); |
235 | |
236 | if((step2 == HIGH)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_2 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)){ |
237 | digitalWrite(Schritte[1],HIGH); |
238 | if(test2 == 1){ |
239 | LED_ist_wieder_L_2 = 0; |
240 | // Serial.println("2");
|
241 | step2_immer_noch_H = 1; |
242 | }
|
243 | }
|
244 | |
245 | |
246 | |
247 | if(step2 == LOW){ |
248 | digitalWrite(Schritte[1],LOW); |
249 | Flanke[x2] = 0; |
250 | LED_ist_wieder_L_2 = 1; |
251 | //Serial.println("20");
|
252 | //löschen
|
253 | Schritte[1] = 0; |
254 | Schritt2 = 0; |
255 | step2 = 0; |
256 | test2 = 0; |
257 | step2_immer_noch_H = 0; |
258 | }
|
259 | |
260 | |
261 | //Ende Schritt 2 ------------------------------------------------------------------------------------------------------------
|
262 | //Schritt3 ---------------------------------------------------------------------------------------------------------------
|
263 | if(((Sensoren[0] == HIGH)||(Sensoren[1] == HIGH)||(Sensoren[2] == HIGH)||(Sensoren[3] == HIGH)||(Sensoren[4] == HIGH)||(Sensoren[5] == HIGH)) &&(Flank1 == 2)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt |
264 | |
265 | delay(100); |
266 | Sensoren[0] = digitalRead(H1); |
267 | Sensoren[1] = digitalRead(H2); |
268 | Sensoren[2] = digitalRead(H3); |
269 | Sensoren[3] = digitalRead(H4); |
270 | Sensoren[4] = digitalRead(H5); |
271 | Sensoren[5] = digitalRead(H6); |
272 | |
273 | for(int x = 0; x < 6 ; x ++){ |
274 | |
275 | if ((Sensoren[x] == HIGH)&&(Flanke[x] == 0)&&(Schritte[2] == 0)/*&&((Sensoren_variable[x] != Schritt1_Sensor_var)|| (LED_ist_wieder_L == 0))*/){ //zb 1 |
276 | //Entprellen
|
277 | |
278 | step2 = digitalRead(Schritt2); |
279 | step1 = digitalRead(Schritt1); |
280 | |
281 | |
282 | Pruefen[2] = Sensoren_variable[x]; |
283 | |
284 | Prufung3 = Sensorprufung[x]; |
285 | |
286 | Schritte[2] = LEDs[x]; |
287 | Schritt3 = Sensoren_variable[x]; // sensor variable damit nicht schritt 1 HIGH zugewiesen wird |
288 | // test1 = LEDs[x];
|
289 | Flanke[x] = 1; |
290 | Flank1 = 3; |
291 | Schritt3_Sensor_var = Sensoren_variable[x]; |
292 | x3 = x; |
293 | Flank3 = Flank1; |
294 | test3 = 1; |
295 | // digitalWrite(LED_BUILTIN, HIGH);
|
296 | // }
|
297 | |
298 | // }
|
299 | }
|
300 | }
|
301 | |
302 | |
303 | }
|
304 | |
305 | step3 = digitalRead(Schritt3); |
306 | |
307 | if((step3 == HIGH)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_3 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)){ |
308 | digitalWrite(Schritte[2],HIGH); |
309 | if(test3 == 1){ |
310 | LED_ist_wieder_L_3 = 0; |
311 | //Serial.println("3");
|
312 | step3_immer_noch_H = 1; |
313 | }
|
314 | }
|
315 | |
316 | if(step3 == LOW){ |
317 | digitalWrite(Schritte[2],LOW); |
318 | Flanke[x3] = 0; |
319 | LED_ist_wieder_L_3 = 1; |
320 | // Serial.println("30");
|
321 | //löschen
|
322 | Schritte[2] = 0; |
323 | Schritt3 = 0; |
324 | step3 = 0; |
325 | test3 = 0; |
326 | step3_immer_noch_H = 0; |
327 | }
|
328 | |
329 | |
330 | |
331 | //Ende Schritt 3 ------------------------------------------------------------------------------------------------------------
|
332 | |
333 | //Schritt4 ---------------------------------------------------------------------------------------------------------------
|
334 | if(((Sensoren[0] == HIGH)||(Sensoren[1] == HIGH)||(Sensoren[2] == HIGH)||(Sensoren[3] == HIGH)||(Sensoren[4] == HIGH)||(Sensoren[5] == HIGH)) &&(Flank1 == 3)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt |
335 | |
336 | delay(100); |
337 | Sensoren[0] = digitalRead(H1); |
338 | Sensoren[1] = digitalRead(H2); |
339 | Sensoren[2] = digitalRead(H3); |
340 | Sensoren[3] = digitalRead(H4); |
341 | Sensoren[4] = digitalRead(H5); |
342 | Sensoren[5] = digitalRead(H6); |
343 | |
344 | |
345 | for(int x = 0; x < 6 ; x ++){ |
346 | |
347 | if ((Sensoren[x] == HIGH)&&(Flanke[x] == 0)&&(Schritte[3] == 0)){ //zb 1 |
348 | //Entprellen
|
349 | delay(100); |
350 | Sensoren[x] = digitalRead(Sensoren[x]); |
351 | |
352 | |
353 | if(Sensoren[x] == HIGH){ |
354 | Pruefen[2] = Sensoren_variable[x]; |
355 | |
356 | Prufung4 = Sensorprufung[x]; |
357 | |
358 | Schritte[3] = LEDs[x]; |
359 | Schritt4 = Sensoren_variable[x]; // sensor variable damit nicht schritt 1 HIGH zugewiesen wird |
360 | //test2 = LEDs[x];
|
361 | Flanke[x] = 1; |
362 | Flank1 = 4; |
363 | x4 = x; |
364 | Schritt4_Sensor_var = Sensoren_variable[x]; |
365 | Flank4 = Flank1; |
366 | test4 = 1; |
367 | |
368 | //digitalWrite(LED_BUILTIN, HIGH);
|
369 | }
|
370 | }
|
371 | }
|
372 | }
|
373 | |
374 | |
375 | |
376 | //step2 = digitalRead(Schritt1);
|
377 | step4 = digitalRead(Schritt4); |
378 | |
379 | if((step4 == HIGH)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1)&&(LED_ist_wieder_L_4 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L_3 == 1)){ |
380 | digitalWrite(Schritte[3],HIGH); |
381 | if(test4 == 1){ |
382 | LED_ist_wieder_L_4 = 0; |
383 | //Serial.println("4");
|
384 | step4_immer_noch_H = 1; |
385 | }
|
386 | }
|
387 | |
388 | if(step4 == LOW){ |
389 | digitalWrite(Schritte[3],LOW); |
390 | Flanke[x4] = 0; |
391 | LED_ist_wieder_L_4 = 1; |
392 | //Serial.println("40");
|
393 | //löschen
|
394 | Schritte[3] = 0; |
395 | Schritt4 = 0; |
396 | step4 = 0; |
397 | test4 = 0; |
398 | step4_immer_noch_H = 0; |
399 | }
|
400 | |
401 | //Ende Schritt 4 ------------------------------------------------------------------------------------------------------------
|
402 | |
403 | |
404 | //Schritt5 ---------------------------------------------------------------------------------------------------------------
|
405 | if(((Sensoren[0] == HIGH)||(Sensoren[1] == HIGH)||(Sensoren[2] == HIGH)||(Sensoren[3] == HIGH)||(Sensoren[4] == HIGH)||(Sensoren[5] == HIGH))&&(Flank1 == 4)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt |
406 | |
407 | delay(100); |
408 | Sensoren[0] = digitalRead(H1); |
409 | Sensoren[1] = digitalRead(H2); |
410 | Sensoren[2] = digitalRead(H3); |
411 | Sensoren[3] = digitalRead(H4); |
412 | |
413 | for(int x = 0; x < 6 ; x ++){ |
414 | |
415 | if ((Sensoren[x] == HIGH)&&(Flanke[x] == 0)&&(Schritte[4] == 0)){ //zb 1 |
416 | //Entprellen
|
417 | delay(100); |
418 | Sensoren[x] = digitalRead(Sensoren[x]); |
419 | |
420 | |
421 | if(Sensoren[x] == HIGH){ |
422 | |
423 | Schritte[4] = LEDs[x]; |
424 | Schritt5 = Sensoren_variable[x]; |
425 | |
426 | Flanke[x] = 1; |
427 | Flank1 = 5; |
428 | x5 = x; |
429 | Flank5 = Flank1; |
430 | Schritt5_Sensor_var = Sensoren_variable[x]; |
431 | test5 = 1; |
432 | |
433 | |
434 | }
|
435 | }
|
436 | }
|
437 | }
|
438 | |
439 | |
440 | |
441 | //step2 = digitalRead(Schritt1);
|
442 | step5 = digitalRead(Schritt5); |
443 | |
444 | if((step5 == HIGH)&&(((LED_ist_wieder_L_6 == 1)&&(LED_ist_wieder_L_5 == 1))||(Erster_Durchlauf == 0))&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_4 == 1)){ |
445 | digitalWrite(Schritte[4],HIGH); |
446 | if(test5 == 1){ |
447 | LED_ist_wieder_L_5 = 0; |
448 | step5_immer_noch_H = 1; |
449 | }
|
450 | }
|
451 | |
452 | if(step5 == LOW){ |
453 | digitalWrite(Schritte[4],LOW); |
454 | Flanke[x5] = 0; |
455 | LED_ist_wieder_L_5 = 1; |
456 | step5_immer_noch_H = 0; |
457 | //löschen
|
458 | Schritte[4] = 0; |
459 | Schritt5 = 0; |
460 | step5 = 0; |
461 | test5 = 0; |
462 | }
|
463 | |
464 | |
465 | //Ende Schritt 5 ------------------------------------------------------------------------------------------------------------
|
466 | |
467 | //Schritt6 ---------------------------------------------------------------------------------------------------------------
|
468 | if(((Sensoren[0] == HIGH)||(Sensoren[1] == HIGH)||(Sensoren[2] == HIGH)||(Sensoren[3] == HIGH)||(Sensoren[4] == HIGH)||(Sensoren[5] == HIGH)) &&(Flank1 == 5)){ //kann direkt hier rein weil Flanke bei schritt 1 direkt auf 1 gesetzt wird muss ausschliessen dass es mit dem gleichen High hier rein kommt |
469 | |
470 | delay(100); |
471 | Sensoren[0] = digitalRead(H1); |
472 | Sensoren[1] = digitalRead(H2); |
473 | Sensoren[2] = digitalRead(H3); |
474 | Sensoren[3] = digitalRead(H4); |
475 | |
476 | for(int x = 0; x < 6 ; x ++){ |
477 | |
478 | if ((Sensoren[x] == HIGH)&&(Flanke[x] == 0)&&(Schritte[5] == 0)){ //zb 1 |
479 | //Entprellen
|
480 | delay(100); |
481 | Sensoren[x] = digitalRead(Sensoren[x]); |
482 | |
483 | |
484 | if(Sensoren[x] == HIGH){ |
485 | |
486 | Schritte[5] = LEDs[x]; |
487 | Schritt6 = Sensoren_variable[x]; // sensor variable damit nicht schritt 1 HIGH zugewiesen wird |
488 | //test4 = LEDs[x];
|
489 | Flanke[x] = 1; |
490 | Flank1 = 6; |
491 | Flank6 = 6; |
492 | Erster_Durchlauf = 1; |
493 | x6 = x; |
494 | test6 = 1; |
495 | |
496 | Schritt6_Sensor_var = Sensoren_variable[x]; |
497 | |
498 | |
499 | }
|
500 | }
|
501 | }
|
502 | }
|
503 | |
504 | step6 = digitalRead(Schritt6); |
505 | |
506 | if((step6 == HIGH)&&(LED_ist_wieder_L == 1)&&(LED_ist_wieder_L_2 == 1)&&(LED_ist_wieder_L_3 == 1)&&(LED_ist_wieder_L_4 == 1)&&(LED_ist_wieder_L_5 == 1)){ |
507 | digitalWrite(Schritte[5],HIGH); |
508 | if(test6 == 1){ |
509 | LED_ist_wieder_L_6 = 0; |
510 | step6_immer_noch_H = 1; |
511 | }
|
512 | }
|
513 | |
514 | |
515 | |
516 | if(step6 == LOW){ |
517 | digitalWrite(Schritte[5],LOW); |
518 | Flanke[x6] = 0; |
519 | LED_ist_wieder_L_6 = 1; |
520 | step6_immer_noch_H = 0; |
521 | //löschen
|
522 | Schritte[5] = 0; |
523 | Schritt6 = 0; |
524 | step6 = 0; |
525 | test6 = 0; |
526 | }
|
527 | |
528 | |
529 | //Ende Schritt 6 ------------------------------------------------------------------------------------------------------------
|
530 | |
531 | |
532 | //Bei vielen Wdh und step ist immer noch H
|
533 | if((Flank1 == 5)&&(step6_immer_noch_H == 1)){ |
534 | Flank1 = 6; |
535 | }
|
536 | if((Flank1 == 4)&&(step5_immer_noch_H == 1)){ |
537 | Flank1 = 5; |
538 | }
|
539 | if((Flank1 == 3)&&(step4_immer_noch_H == 1)){ |
540 | Flank1 = 4; |
541 | }
|
542 | if((Flank1 == 2)&&(step3_immer_noch_H == 1)){ |
543 | Flank1 = 3; |
544 | }
|
545 | if((Flank1 == 1)&&(step2_immer_noch_H == 1)){ |
546 | Flank1 = 2; |
547 | }
|
548 | if((Flank1 == 6)&&(step1_immer_noch_H == 1)){ |
549 | Flank1 = 1; |
550 | }
|
551 | |
552 | |
553 | }
|
Was, glaubst Du, hat wohl diese Zeile zu bedeuten?: Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang Man, wie ich diese 12 Meter langen Postings hasse...!
das sollte die Forensoftware mal blockieren oder automatisch in Anhang wandeln wenn Text in C oder Code Tags länger als ein Limit sind.
Elektro F. schrieb: > Hier ist noch der fertige Code Wirst Du nach Programmzeilen bezahlt? Da siehst Du ja nichtmal selber mehr durch. Was soll der Quatsch, einem float ein bool zuzuweisen?
Sorry, erst im nachhinein gemerkt. Hier nochmals als Datei:
Ich bin schwer beeindruckt! u.A. auch von der Unzahl Warnungen Leider kann ich dem Programm keinen Sinn und Zweck entnehmen. Und deinen Beschreibungen hier im Thread auch nicht wirklich. Das alles ist wirklich gut verschlüsselt. Ich kann das Programm nicht "lesen". Ein paar Sachen stören mich beim "lesen" - durchnummerierte Variablen - Funktionen mit über 25 Zeilen, naja - komplizierte Bedingungen in if Statements - geschachtelte if Blöcke, so ab ca 2 bis 3 Wenn ich nur begreifen würde, was es tun soll ....
Thread beobachten
Seitenaufteilung abschaltenBitte 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
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.