Anfängerhilfe - Projekt Modellbau Leuchtturm beleuchten

Christian S. OP #5172964
Lesenswert?
• ▲
▼ 
Hallo zusammen,

ich bin ganz neu hier und auch blutiger Anfänger in C.
Habe mir lange überlegt ob ich eure Hilfe in Anspruch nehme...
Bitte zerreißt mich nicht gleich in der Luft ;-)
Ich habe gegooglet, mir div. Tutorial angeschaut, ein teures Buch 
gekauft aber ich komme einfach nicht weiter.
Die Aufgaben und Beispiele sind alle zu aufwendig und ich möchte doch 
nur etwas einfaches realisieren und vor allem verstehen.

Ich habe ein aTeVaL (Microchip AVR Evaluationsboard) von ehajo
Ich arbeite mit Atmel Studio 7
Im Board habe ich z.Zt. einen ATtiny2313A

Wie in der Überschrift schon angedeutet habe ich mir ein (vermeintlich) 
einfaches Projekt für den Anfang vorgenommen:
Es soll ein Modellleuchtturm beleuchtet werden.
Modell: Westerhever Sand
Was soll leuchten?
Leuchtfeuer mit original Kennung 10 sek an, 1 sek aus, 1 sek an, 1 sek 
aus, 1 sek an, 1 sek aus
Es gibt zwei Leuchtturmwärter Häuschen dort sollen jeweils zwei LEDs 
verbaut werden.
Wohnzimmer und Bad
Das Leuchtfeuer soll dauernd vor sich hin leuchten und die vier anderen 
LEDs sollen ein belebtes Haus simulieren.
Wohnzimmer Licht an, ab und zu Licht im Bad an und wieder aus, dann 
Licht im Wohnzimmer auch aus.

Das Leuchtfeuer habe ich zum Blinken gebracht habe aber keine Ahnung wie 
ich die anderen LEDs ansteuern soll, da ich eine Endlosschleife habe die 
nie endet.
Wie löst man so etwas?
Mit einem Timer? Wenn ja wie?
Andere Lösungsansätze für mich?

Bin für jede Hilfe dankbar!

Viele Grüße

Christian


Hier mein bisheriger Code:

/*
 * LED mit Kennung Westerhever Sand
 * 10 sek an 1 sek aus 1 sek an 1 sek aus 1 sek an 1 sek aus
 * AtmelStudio 7.0
 * ATtiny2313A
 */

#
#ifndef F_CPU
#define F_CPU 1000000UL
#endif

#include <avr/io.h>
#include <util/delay.h>



//////////////////////////////////////////////////////////////////////// 
///////////////////////////
int main(void) {

  DDRD |= (1 << 6);      // Port D Pin PC6 als Ausgang

  while (1)  {          // Beginn Schleife
    PORTD ^= (1 << 6);     // flip state
    _delay_ms(10000);    // delay 10 Sekunden an
    PORTD ^= (1 << 6);     // flip state
    _delay_ms(1000);    // delay 1 Sekunde aus
    PORTD ^= (1 << 6);     // flip state
    _delay_ms(1000);    // delay 1 Sekunde an
    PORTD ^= (1 << 6);     // flip state
    _delay_ms(1000);    // delay 1 Sekunde aus
    PORTD ^= (1 << 6);     // flip state
    _delay_ms(1000);    // delay 1 Sekunde an
    PORTD ^= (1 << 6);     // flip state
    _delay_ms(1000);    // delay 1 Sekunde aus

  }

  return(0);
}
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Stefan F. Gast #5172969
Lesenswert?
• ▲
▼ 
> Wie löst man so etwas?

Du willst im Grunde genommen mehrere Leuchtmuster parallel abarbeiten. 
Ein für µC gangiger Lösungsansatz dazu ist der Zustandsautomat. Lies mal 
die ersten Absätze von http://stefanfrings.de/net_io/protosockets.html 
dann siehst du, was ich damit meine.

In meinem Buch http://stefanfrings.de/mikrocontroller_buch/index.html 
Band 3 findest du ein paar konkrete Anwendungsbeispiele. Achte dabei mal 
darauf, wie ich Enumerations für die switch() Anweisungen verwendet 
habe.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Christian S. OP #5172988
Lesenswert?
• ▲
▼ 
Danke für die schnelle Antwort!
Noch mehr zu lesen für mich ;-)
Sieht aber für mich als Anfänger auf den ersten Blick sehr aufwendig aus 
und ich verstehe nur Bahnhof...
Werde das mal alles durcharbeiten und auf mich wirken lassen.

Wenn jemand noch einen Beispiel-Code für mich hat, wie so etwas aussehen 
könnte, wäre ich nicht abgeneigt.
Mit einem Beispiel fällt mir das Verstehen leichter.

Ich dachte man arbeitet in Blöcken:
LED1 soll dies machen
LED2 soll das machen....
Oder mit mehreren Dateien.
Dem ist wohl nicht so :-/
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Michael B. #5172995
Lesenswert?
• ▲
▼ 
Christian S. schrieb:
> habe aber keine Ahnung wie ich die anderen LEDs ansteuern soll,
> da ich eine Endlosschleife habe die nie endet.

Offenkundig ist _delay die falsche Wahl.

Eine Schleife, die die Sekunden zählt
1
while(1)

2
{

3
    _delay_ms(1000);

4
}

kann bei jedem Durchlauf das ein- oder ausschalten, was als nächstes 
kommt:
1
char westhafen[16]={1,1,1,1,1,1,1,1,1,1,0,1,0,1,0};

2
while(1)

3
{

4
    sekunde++; if(sekunde>=15) sekunde=0;

5
    if(westhafen[sekunde])

6
    {

7
        PORTD |= (1 << 6); // LED an

8
    }

9
    else

10
    {

11
        PORTD &= ~(1 << 6); // LED aus

12
    }

13
    _delay_ms(1000);

14
}

da Zimmerbeluchtungen eher minutenweise gehen:
1
int sekunde,minute;

2
char westhafen[60]={1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0};

3
char wohnzimmer[10]={1,1,1,1,1,1,1,0,0,0};

4
char bad[10]={0,0,0,0,0,0,0,1,0,0};

5
while(1)

6
{

7
    sekunde++; if(sekunde>=60) 

8
    { 

9
        sekunde=0; minute++; if(minute>=10) { minute=0; }

10
    }

11
    if(westhafen[sekunde])

12
    {

13
        PORTD |= (1 << 6); // LED an

14
    }

15
    else

16
    {

17
        PORTD &= ~(1 << 6); // LED aus

18
    }

19
    if(wohnzimmer[minute])

20
    {

21
        PORTD |= (1 << 5); // LED an

22
    }

23
    else

24
    {

25
        PORTD &= ~(1 << 5); // LED aus

26
    }

27
    if(bad[minute])

28
    {

29
        PORTD |= (1 << 4); // LED an

30
    }

31
    else

32
    {

33
        PORTD &= ~(1 << 4); // LED aus

34
    }

35
    _delay_ms(1000);

36
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Stefan F. Gast #5173001
Lesenswert?
• ▲
▼ 
> Ich dachte man arbeitet in Blöcken:
Ja eben. Für jede LED schreibst du einen Zustandsautomaten (also ein 
switch() Konstrukt).

In der Hauptschleife führst du dann beide quasi parallel aus.

> Dem ist wohl nicht so :-/
Doch.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Dussel Gast #5173009
Lesenswert?
• ▲
▼ 
Michaels Ansatz kann man nehmen, aber es wäre 'professioneller', das 
Delay durch einen Timer zu ersetzen. Im Interrupt setzt du ein Flag und 
wartest in der Hauptschleife, bis das Flag gesetzt ist. Etwa so
1
_ISR(Timer0_OVF)  // Oder so ähnlich, ich kann mir das nie merken

2
{

3
    Flag=1;

4
}

5


6
main()

7
{

8
    while(1)

9
    {

10
        while(Flag!=1);  // Schleife, bis Flag 1 ist

11
        Flag=0;

12
        SchalteLeuchtturm();

13
        SchalteHauslicht();

14
    }

15
}

In dem Beispiel ist das kein großer Unterschied, aber wenn der Code 
länger wird, wird mit Delay auch die Zeit zwischen den Durchläufen 
länger. Mit dem Timer hast du immer das gleiche Intervall.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Christian S. OP #5173019
Lesenswert?
• ▲
▼ 
Also erst mal vielen lieben Dank für eure Hilfe! :-)
Bilder gibts leider noch nicht...

Habe jetzt mal probiert das zusammen zu bekommen:

1
/*

2
 * LED mit Kennung Westerhever Sand

3
 * 10 sek an 1 sek aus 1 sek an 1 sek aus 1 sek an 1 sek aus

4
 * AtmelStudio 7.0

5
 * ATtiny2313A 

6
 */

7
 

8
#

9
#ifndef F_CPU          

10
#define F_CPU 1000000UL      

11
#endif

12


13
#include <avr/io.h>        

14
#include <util/delay.h>  

15


16
#define LED_Bad    (1<<PD4)

17
#define LED2_WZ    (1<<PD5)

18
#define LED3_LT    (1<<PD6)

19


20
///////////////////////////////////////////////////////////////////////////

21
int main(void) {

22
  

23
  DDRD |= LED_Bad | LED2_WZ | LED3_LT      // Port D Pins als Ausgang

24
  

25
  int sekunde,minute;

26
  char westhafen[60]={1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0};

27
  char wohnzimmer[10]={1,1,1,1,1,1,1,0,0,0};

28
  char bad[10]={0,0,0,0,0,0,0,1,0,0};

29
  while(1)

30
  {

31
    sekunde++; if(sekunde>=60)

32
    {

33
      sekunde=0; minute++; if(minute>=10) { minute=0; }

34
    }

35
    if(westhafen[sekunde])

36
    {

37
      PORTD |= LED3_LT; // LED an

38
    }

39
    else

40
    {

41
      PORTD &= ~LED3_LT; // LED aus

42
    }

43
    if(wohnzimmer[minute])

44
    {

45
      PORTD |= LED2_WZ; // LED an

46
    }

47
    else

48
    {

49
      PORTD &= ~LED2_WZ; // LED aus

50
    }

51
    if(bad[minute])

52
    {

53
      PORTD |= LED_Bad; // LED an

54
    }

55
    else

56
    {

57
      PORTD &= ~LED_Bad; // LED aus

58
    }

59
    _delay_ms(1000);

60
  }


Geht leider nicht.
Was habe ich falsch gemacht?
Fehlermeldungen siehe screenshot

PS der Code wird nicht länger werden und wenn es geht auch in einen 
tiny13A passen
Angehängte Dateien:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas E. #5173062
Lesenswert?
• ▲
▼ 
Christian S. schrieb:
> PS der Code wird nicht länger werden und wenn es geht auch in einen
> tiny13A passen

Der Code schon, aber nicht die Daten. Allein die 3 Arrays sind schon 80 
Byte, die du irgendwie in 64 Byte RAM stapeln musst.

Sieh dir im Tutorial an, wie man Konstanten im Flash ablegt und wie man 
darauf zugreift. Ob alles in die 1K reinpasst, ist eine andere Frage.

Die Tiny 25/45/85 sind pinkompatibel zum Tiny 13. Mit denen hättest du 
wesentlich meht Luft nach oben.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Christian S. OP #5173134
Lesenswert?
• ▲
▼ 
So da bin ich schon wieder...
Dachte es geht alles habe aber festgestellt dass etwas nicht stimmt mit 
PD4 und 5.
Also habe ich den Code angepasst und nun sollten PD4 und 5 abwechselt an 
und aus sein...
Aber PD5 ist immer an und PD4 nach 3x an und 2x aus also 5 Minuten 
dauernd an.
Oh eben ist PD5 nach 10 Minuten doch mal aus gegangen.
Jetzt leuchten wieder PD4 und 5 dauerhaft.
PD6 blinkt wie es soll.
Also irgendwo ist da noch der Wurm drin!?
Außerdem ist 1 Minute keine Minute sondern eher 44 Sekunden.
Takt Controller? Wo korrigieren?


1
/*

2
 * LED mit Kennung Westerhever Sand

3
 * 10 sek an 1 sek aus 1 sek an 1 sek aus 1 sek an 1 sek aus

4
 * AtmelStudio 7.0

5
 * ATtiny2313A 

6
 */

7
 

8
#

9
#ifndef F_CPU          

10
#define F_CPU 1000000UL      

11
#endif

12


13
#include <avr/io.h>        

14
#include <util/delay.h>  

15


16
#define LED_Bad   (1<<PD4)

17
#define LED_WZ    (1<<PD5)

18
#define LED_LT    (1<<PD6)

19


20
///////////////////////////////////////////////////////////////////////////

21
int main(void) {

22
  

23
  DDRD |= LED_Bad | LED_WZ | LED_LT;     // Port D Pins als Ausgang

24
  

25
  int sekunde,minute;

26
  char leuchtfeuer[60]={1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1,0};

27
  char wohnzimmer[10]={0,1,0,1,0,1,0,1,0,1};

28
  char bad[10]={1,0,1,0,1,0,1,0,1,0};

29
  while(1)

30
  {

31
    sekunde++; if(sekunde>=60)

32
    {

33
      sekunde=0; minute++; if(minute>=10) { minute=0; }

34
    }

35
    if(leuchtfeuer[sekunde])

36
    {

37
      PORTD |= LED_LT; // LED an

38
    }

39
    else

40
    {

41
      PORTD &= ~LED_LT; // LED aus

42
    }

43
    if(wohnzimmer[minute])

44
    {

45
      PORTD |= LED_WZ; // LED an

46
    }

47
    else

48
    {

49
      PORTD &= ~LED_WZ; // LED aus

50
    }

51
    if(bad[minute])

52
    {

53
      PORTD |= LED_Bad; // LED an

54
    }

55
    else

56
    {

57
      PORTD &= ~LED_Bad; // LED aus

58
    }

59
    _delay_ms(1000);

60
  }

61
return(0);

62
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Michael B. #5173176
Lesenswert?
• ▲
▼ 
Christian S. schrieb:
> festgestellt dass etwas nicht stimmt

Sagte schon Thomas, der Speicher reicht wohl nicht, weil die an/aus bits 
recht grosszügig deklariert wurden.

1
/*

2
 * LED mit Kennung Westerhever Sand

3
 * 10 sek an 1 sek aus 1 sek an 1 sek aus 1 sek an 1 sek aus

4
 * AtmelStudio 7.0

5
 * ATtiny2313A 

6
 */

7
 

8
#

9
#ifndef F_CPU          

10
#define F_CPU 1300000UL      

11
#endif

12


13
#include <avr/io.h>        

14
#include <util/delay.h>  

15


16
#define LED_Bad   (1<<PD4)

17
#define LED_WZ    (1<<PD5)

18
#define LED_LT    (1<<PD6)

19


20
///////////////////////////////////////////////////////////////////////////

21
int main(void) {

22
  

23
  int sekunde,minute;

24
  static int leuchtfeuer=0x2BFF;

25
  static int wohnzimmer=0x155;

26
  static int bad=0x2AA;

27
  DDRD |= LED_Bad | LED_WZ | LED_LT;     // Port D Pins als Ausgang

28
  while(1)

29
  {

30
    sekunde++; if(sekunde>=60)

31
    {

32
      sekunde=0; minute++; if(minute>=10) { minute=0; }

33
    }

34
    if(leuchtfeuer&(1<<(sekunde%15)))

35
    {

36
      PORTD |= LED_LT; // LED an

37
    }

38
    else

39
    {

40
      PORTD &= ~LED_LT; // LED aus

41
    }

42
    if(wohnzimmer&(1<<minute))

43
    {

44
      PORTD |= LED_WZ; // LED an

45
    }

46
    else

47
    {

48
      PORTD &= ~LED_WZ; // LED aus

49
    }

50
    if(bad&(1<<minute))

51
    {

52
      PORTD |= LED_Bad; // LED an

53
    }

54
    else

55
    {

56
      PORTD &= ~LED_Bad; // LED aus

57
    }

58
    _delay_ms(1000);

59
  }

60
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
light_house Gast #5173292
Lesenswert?
• ▲
▼ 
> Vielleicht könntest du das auch für eine Landratte und einen
> Nicht-Funkamteur in eine verständliche Form bringen?

> Oc(3) WRG 15s   [(1)+2+(1)+2(1)+8 s]

Licht: 1s(aus) - 2s(ein) - 1s(aus) - 2s(ein) - 1s(aus) - 8s(ein)

NB Info für Nicht-Funkamateure: dies ist kein Morsecode
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Christian S. OP #5173382
Lesenswert?
• ▲
▼ 
Noch ein Ergebnis für heute:
Ich habe PD4 und 5 getauscht und jetzt scheint alles so abzulaufen wie 
gewünscht.
Erklärungen für dieses Phänomen?

Vorher (LEDs schalten willkürlich bzw. mir nicht erklärbar):
1
#define LED_Bad   (1<<PD4)

2
#define LED_WZ    (1<<PD5)

3
#define LED_LT    (1<<PD6)


Nachher (LEDs schalten wie gewünscht):
1
#define LED_LT    (1<<PD6)

2
#define LED_Bad   (1<<PD5)

3
#define LED_WZ    (1<<PD4)


Noch etwas ist mir aufgefallen:
Vorher Speicher zu 68% belegt.
Nachher zu 59% belegt.

????????Komisch????????
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Patrick J. #5173587
Lesenswert?
• ▲
▼ 
Hi

Hatte vorhin, beim überfliegen der ersten Posts, den Gedanken, ob man 
ein Array nicht auch als boolean (statt byte/int/char/whatever) erzeugen 
kann - dann müsste der Compiler halt 8 dieser Werte zu einen Byte 
zusammen schustern und irgendwo in den Tiefen des RAM/Flash unter 
bringen.
(im Endeffekt das Gleiche, wie 'laberkopp' Es schon in Seinem Code 
angepasst hatte)
Wobei man ggf. auch einfach die 64 (bei Sekunden wohl nur 60) Bit als 
binäre Zahl angeben könnte - wobei hier dann das Auszählen wieder 
fehleranfällig wird.

MfG
Antwort Zitieren Bearbeiten Löschen Beitrag melden
LFV Gast #5173615
Lesenswert?
• ▲
▼ 
Patrick J. schrieb:
> Hatte vorhin, beim überfliegen der ersten Posts, den Gedanken, ob man
> ein Array nicht auch als boolean (statt byte/int/char/whatever) erzeugen
> kann - dann müsste der Compiler halt 8 dieser Werte zu einen Byte
> zusammen schustern und irgendwo in den Tiefen des RAM/Flash unter
> bringen.

Man kann es auch als verkettete Liste mit Texten "Ein" und "Aus" 
ablegen.

Einfacher wäre es aber wohl, das Muster einfach Bitweise in ein uint16_t 
zu packen. Die Kennung ist 15s lang und passt dort wunderbar rein, wenn 
jedes Bit 1s repräsentiert. Zusätzlich braucht man einen Zähler, der 
immer von 0 bis 14 zählt.

HildeK schrieb:
> Vielleicht könntest du das auch für eine Landratte und einen
> Nicht-Funkamteur in eine verständliche Form bringen?

Das hat mit Funken überhaupt nichts zu tun:
Oc(3) heißt "Unterbrochen Gruppe 3" (oc  (en) =occulted), d.h. 3 
Unterbrechungen hintereinander. Die Zeiten in Klammern sind die 
Dunkelphasen, die Zeiten ohne Klammer die Hellphasen, also wie oben 
schon genannt

Westerhever Sand
1
Oc(3) 15s   [(1)+2+(1)+2(1)+8 s] 

2
_oo_oo_oooooooo

http://www.deutsche-leuchtfeuer.de/nordsee/westerheversand.html
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas E. #5173635
Lesenswert?
• ▲
▼ 
LFV schrieb:
> Zusätzlich braucht man einen Zähler, der immer von 0 bis 14 zählt

Nein, dazu braucht man eine Maske. Die startet mit 1 und dieses Bit wird 
nach jeder Sekunde um 1 nach links geschoben. Die verknüpft man dann mit 
dem Ausgabemuster und schaltet den Pin entsprechend.

Dann muß das Delay raus. Nicht, weil es sich so gehört, sondern damit 
die LED im Leuchtturm nicht hart blinkt, wie eine LED nun mal blinkt, 
sondern mit Fading, wie bei einem richtigen Leuchtturm. Und dafür 
braucht man einen Timer, der die PWM und das ganze Timing macht.

Das soll natürlich auf einen Tiny13. Mal grob geschätzt: Passt locker.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
light_house Gast #5173675
Lesenswert?
• ▲
▼ 
>> Vielleicht könntest du das auch für eine Landratte und einen
>> Nicht-Funkamteur in eine verständliche Form bringen?

> Das hat mit Funken überhaupt nichts zu tun:

Nur der Vollständigkeit halber: Eher selten strahlen Leuchtürme aber
auch im Morse-Code ab. Eine typische Kennung lautet dann beispielsweise:
Mo (V)

Mo   Hinweis auf Morse-Code
V    Buchstabe V (Punkt – Punkt – Punkt – Strich)

Hierbei gilt für das jeweilige Morsezeichen:

n    Länge eines Punktes
n    Länge der Pause zwischen Punkt/Strich
3n   Länge eines Striches

Beim Leuchfeuer Westerhever Sand liegt schon deshalb kein Morse-Code
vor, weil der Blinkrhythmus nicht nach diesem Zeitplan gestaltet ist.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Christian S. OP #5173795
Lesenswert?
• ▲
▼ 
Danke für eure Anregungen den Code weiter zu verbessern oder das mit dem 
fading klingt auch interessant.
Ich bitte euch aber nicht zu vergessen, dass ich das Board erst seit 
einer Woche und ich somit wirklich noch null Ahnung habe.
Wenn ihr Lust habt, könnt ihr euch ja gern daran austoben.
Damit ich es aber verstehe und nachvollziehen kann wäre es nett wenn ihr 
mir dann den kompletten Code postet und etwas //kommentiert.
Es muss übrigens nicht auf einen tiny passen ich hätte auch noch 
ATMega8A-PU da, der dürfte ausreichend sein ;-)
Nur nicht noch größer, es handelt sich um ein Spur N Modell.
Wenn das Projekt fertig ist möchte ich es auch hier im Forum mit Bildern 
posten und den Code natürlich für alle zugänglich machen...
Noch mal vielen Dank für eure Unterstützung!
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Wolfgang Gast #5173822
Lesenswert?
• ▲
▼ 
Thomas E. schrieb:
> Nein, dazu braucht man eine Maske. Die startet mit 1 und dieses Bit wird
> nach jeder Sekunde um 1 nach links geschoben. Die verknüpft man dann mit
> dem Ausgabemuster und schaltet den Pin entsprechend.

Was heißt "nein"?

Ob du nun deiner Maske auf die Finger guckst oder das ganze Pattern 
verschiebst und immer das unterste Bit beguckst ist nun ziemlich egal.
Wenn man bei der Maskenmethode nicht mit 1 startet, sondern mit 2^14 und 
dann nicht nach links, sondern nach rechts schiebt, weiß man gleich, 
wann man wieder von vorne anfangen muss - nämlich wenn 0 in der Maske 
steht.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren