Linear rückgekoppeltes Schieberegister unter AVR-Programmieren

[Matthias .. (chillin)]

Ich möchte mit AVR ein Linear rückgekoppeltes Schieberegister 
programmieren um damit in einer Modellbahnwelt die lichter "zufällig" an 
und aus zu schalten.

Ich finde aber leider keinen ansatz wie ich das programmieren muss.

hat zufällig jemand den Quellcode dafür, bzw. ein ähnliches beispiel?

[Johannes M. (johnny-m)]

Wo genau liegt das Problem? Wenn Du weißt, welche Bits rückgekoppelt 
werden müssen, dann ist der Rest doch trivial: Einmal schieben und die 
EXOR-verknüpften Bits hinten dranhängen.

[Matthias .. (chillin)]

kann ich den einzelne bits exor'en oder nur zwei register?

[Johannes M. (johnny-m)]

Matthias P. wrote:
> kann ich den einzelne bits exor'en oder nur zwei register?
Du musst Dir die Werte so schieben, dass die zu verknüpfenden Bits an 
der selben Position liegen (idealerweise an Position 0). Dann das 
(bitweise) EXOR drauf loslassen, das Ergebnis mit 1 verUNDen und zum 
Schieberegister dazuODERn...

[Jochen M. (taschenbuch)]

Matthias,

Google nach LFSR und lese den gleichlautenden Artikel bei Wikipedia.
Da steht alles was du benötigst. Google findet für dich auch listen mit 
sogenannten TAPS, also den Abgriffen zum xodern für unterschieldliche 
Bit-Anzahlen.

Jochen Müller

[Jochen M. (taschenbuch)]

Matthias,

Das X-Odern ist eine sog. Parity-Berechnung.
Es geht also nur darum, ob die Anzahl der Rückführbits die 1 sind gerade 
oder ungerade ist. Das lässt sich in Assembler sehr leicht machen:

für jeden Bitabgriff wird ein Zähler erhöht wenn das bit=1 ist.
dann wird der zähler rechts ins carry geschoben, bit-0 des zählers ist 
also im carry. das carry wird dann rechts in das lfsr-byte geschoben.

wichtig: lfsr klappt nur, wenn das lfsr-byte anfangs ungleich null ist, 
also eine initialisierung einbauen.

;========================
; 8Bit LFSR für data
;========================
LFSR:     clr   count
          sbrc  data,7
    inc   count
    sbrc  data,5
          inc   count
    sbrc  data,4
          inc   count
    sbrc  data,3
          inc   count
          ror   count
          rol   data
          brne  lfsrx
          ldi   data,128
lfsrx:    ret

Jochen Müller

[... .. (docean)]

Hier mal was für C

volatile static uint8_t Feld[3];

void takt(void)
{
  int i;
  uint8_t tmp_sreg;  // temporaerer Speicher fuer das Statusregister
 
  tmp_sreg = SREG;   // Statusregister (also auch das I-Flag darin) sichern
  cli();             // Interrupts global deaktivieren
  
  i= (Feld[2] & 1<<7) ^ (Feld[2] & 1<<4);
  
  Feld[2]<<=1;

  if(Feld[1] & 1<<7)
    Feld[2]++;

  Feld[1]<<=1;

  if(Feld[0] & 1<<7)
    Feld[1]++;

  Feld[0]<<=1;

  if(i)
    Feld[0]++; //ergebins dex xor reinschreiben

  SREG = tmp_sreg;     // Interrupt Status-Register wieder herstellen 
}

void main (void)
{
  Feld[0]=1;
  Feld[1]=0;
  Feld[2]=0;

  for(;;)
  {
      takt();

      //Feld[0]-[2] auf Ausgänge schreiben

      //ein bißchen warten

   }
}

[Matthias .. (chillin)]

Danke für die Hilfe!

denke ich habs verstanden, werde da mal ein bisschen rumschreiben, mir 
hat der richtige denkanstoß gefehlt...

jetzt sollte es klappen

Danke nochmal!

[Johann L. (gjlayde)]

Hier noch was für avr-gcc.

Ich verwende den Pseudozufalls-Algorithmus wie im c-File.

Nach dem Start wird durch den zufälligen RAM-Inhalt eine seed berechnet, 
alles andere ist Arithmetik über nem endlichen Galois-Feld der 
Charakteristik 2, also sehr effizient zu berechnen.

Hier noch der Header:

#ifndef _PARIT_15_H_
#define _PARIT_15_H_

extern uint16_t prandom(void);

#endif // _PARIT_15_H_

[Jörg W. (dl8dtl) (Moderator)]

Die avr-libc besitzt eine erprobte Implementierung eines LFSR-basierten
rand() bzw. random().