mikrocontroller.net

Forum: Compiler & IDEs Wie drehe ich eine Bitreihenfolge um??


Autor: Anfänger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wie drehe ich eine Bitreihenfolge mit WinAVR um??

zB 10000100 in 00100001

Autor: Jörg Wunsch (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Durch Suchen im Forum. ;-)

Autor: Christof Krüger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Spiegeln

Autor: Anfänger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Jörg Wunsch
Wenn ich wüste wonach genau, wäre die antwort OK. Aber ich kann hier
nicht mehrere hundert/Tausend Beiträge auf gut Glück durchlesen, um
eventuell auf ein ähnliches Prolem zu stossen. Ein Denkanstoss wäre
schon nett, dann kann ich nämlich die SuFu verwenden.


@Christof Krüger
JA.

Autor: Andreas Schwarz (andreas) (Admin) Benutzerseite Flattr this
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Airbag (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich würde es erst in eine andre zahlensystem umwandeln z.B in Dezimal
und dann wieder in Binär allerdings mit dem neuen wert.oder mit
Bitweisse logik

Autor: Stefan Kleinwort (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Andreas: ganz schön tiefgründig ;-))

Stefan

Autor: Sebastian Schildt (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich hab da was aus nem Projekt letztes Semester...

/* for bit_reverse: 3, fo an 8 pt FFT, 4 for 16 pt etc...*/
#define BIT_WIDTH 7

//__________________________FFT specific
functions_______________________________
/* Reversing the bits in an integer. No asm instruction
   available for this -> slow */
int bit_reverse(int in) {
 int rev=0;
 int i;

 for (i = 0; i < BIT_WIDTH; i++) {
  rev = (rev << 1) | (in & 1);
  in >>=1;
 }
 return rev;
}

Mit Bitwidth angeben wie lang (in Bit) der unzudrehende Wert ist. Also
beim AVR z.B. 8 für ein uint8_t oder 16 für einen uint16_t

Autor: Airbag (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
mit C++ wäre das keine problem oder? ich meine mit Felder!!!
Gcc ist doch C wenn ich mich nicht irre.

Autor: Hans Mildenberger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
also ich muss das selbe mit einer 8 bit zahl machen.

int bit_reverse(int in) {
 int rev=0;
 int i;

 for (i = 0; i < BIT_WIDTH; i++) {
  rev = (rev << 1) | (in & 1);
  in >>=1;
 }
 return rev;
}

Das habe ich einfach von oben übernommen. ich muss dann bitwidth auf 8 
setzen? Mwin größtes problem ist, das ich nicht weiß wie ich die 
funktion in der main aufrufe. Kann mir das jemand sagen?

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hans Mildenberger schrieb:
> also ich muss das selbe mit einer 8 bit zahl machen.
>
> int bit_reverse(int in) {
>  int rev=0;
>  int i;
>
>  for (i = 0; i < BIT_WIDTH; i++) {
>   rev = (rev << 1) | (in & 1);
>   in >>=1;
>  }
>  return rev;
> }
>
> Das habe ich einfach von oben übernommen. ich muss dann bitwidth auf 8
> setzen? Mwin größtes problem ist, das ich nicht weiß wie ich die
> funktion in der main aufrufe. Kann mir das jemand sagen?

So wie jede andere Funktion auch

   ergebnis = bit_reverse( ausgangswert );

Autor: Michael Appelt (micha54)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich würde, wenns schnell gehen muß, eine Tabelle machen

unsigned char revtab[256] =
{0b00000000, 0b10000000, 0b01000000....

Gruß,
Michael

Autor: zwieblum (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
in wirklichkeit läßt sich das ganze nur durch spiegelneuronen korrekt 
lösen

Autor: Hans Mildenberger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Entschuldige meine delitantische Antwort, aber es geht nicht :-(


int main (int argc, char *argv[])
{
   ausgangswert = 01101100
   ergebnis= bit (ausgangswert);
}
 int bit_reverse(int in) {
  int rev=0;
  int i;

  for (i = 0; i < BIT_WIDTH; i++) {
   rev = (rev << 1) | (in & 1);
   in >>=1;
}
  return rev;
}

Autor: Ch D. (chrisu) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
was geht nicht genau??

probier mal so
int main (int argc, char *argv[])
{
  unsigned char ausgangswert = 01101100
  unsigned char ergebnis= bit (ausgangswert);
}

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
"Es geht nicht" ist keine vernünftige Fehlerbeschreibung.

Wie wäre es mit einem C-Lehrbuch?
#define BIT_WIDTH 8

int bit_reverse(int in) {
  int rev=0;
  int i;

  for (i = 0; i < BIT_WIDTH; i++) {
   rev = (rev << 1) | (in & 1);
   in >>=1;
  }
  return rev;
}

int main (int argc, char *argv[])
{
  int ausgangswert = 0b01101100;   // ist nicht Standard C, aber der gcc kanns
  int ergebnis = bit_reverse(ausgangswert);
}

Autor: Hans Mildenberger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Es kommen fogende fehlermeldungen:

invalid suffix "b01100000" on integer contant
In function ínt main(int, char**)´:
ausgabewert undeclared (first use in function)
(Each undeclareded identifier is reported only once for each function it 
appears in.)
bit reverse undeclared (first use in function)
in function int bit_reverse(int):
int bit reverse(int) used prior to declaration
[Build Error] [main.0] Error 1


1000 Dank das ihr euch die Zeit nehmt.

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Man lese und staune:
>>> // ist nicht Standard C, aber der gcc kanns
Welchen Compiler verwendest du?

Autor: Hans Mildenberger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
dev-c++

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hans Mildenberger schrieb:
> dev-c++



Na dann
#define BIT_WIDTH 8

int bit_reverse(int in) {
  int rev=0;
  int i;

  for (i = 0; i < BIT_WIDTH; i++) {
   rev = (rev << 1) | (in & 1);
   in >>=1;
  }
  return rev;
}

int main (int argc, char *argv[])
{
  int ausgangswert = 0x6C;   // 01101100
  int ergebnis = bit_reverse(ausgangswert);
}

Autor: Hans Mildenberger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Da bleibt nur noch einer übrig.
Die anderen Fehlermeldungen gehen auch weg, wenn ich einfach das ich 
ausgangswqert = 01100001´; geschrieben hätte.

In function ínt main(int, char**)´:
ausgabewert undeclared (first use in function)
(Each undeclareded identifier is reported only once for each function it
appears in.)
[Build Error] [main.0] Error 1

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hans Mildenberger schrieb:
> Da bleibt nur noch einer übrig.
> Die anderen Fehlermeldungen gehen auch weg, wenn ich einfach das ich
> ausgangswqert = 01100001´; geschrieben hätte.

Ja. Nur hätte das etwas ganz anderes gemacht als du dir auch nur in 
deinen wildesten Träumen vorstellen kannst.
Oder sagen dir Oktalzahlen irgendetwas :-)

> In function ínt main(int, char**)´:
> ausgabewert undeclared (first use in function)
> (Each undeclareded identifier is reported only once for each function it
> appears in.)
> [Build Error] [main.0] Error 1

Den behebst du jetzt schön selber.
Der Compiler schreibt ja schon hin, was faul ist.

Autor: avr (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Immer wieder gefragt:
unsigned char umkehr(unsigned char n){
n=((n>>1)&0x55)|((n<<1)&0xaa);
n=((n>>2)&0x33)|((n<<2)&0xcc);
return (n>>4)|(n<<4);
}

avr

Autor: Hans Mildenberger (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#define smax 8
#include <stdio.h>
int bit_reverse(int in) {
    int rev=0;
    int i;
    for ( i=0; i < smax; i++)
        {
               rev = (rev << 1 )| (in & 1);
               in >>1;
        }
   return rev;
}


int main(int argc, char *argv[])
{
 int ausgangswert = 0x6C;
 int ergebnis = bit_reverse(ausgangswert);
    while(1)
     {
 printf("ergebnis = %d\n", ergebnis); }
}

So sieht mein Programm inzwischen aus. Läuft auch fehlerfrei. Allerdings 
bekomme ich immer die Ausgabe "ergebnis = 0".
Kann mir das jemand erklären?

Autor: Sebastian B. (sfreak) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hans Mildenberger schrieb:
> #define smax 8
> #include <stdio.h>
> int bit_reverse(int in) {
>     int rev=0;
>     int i;
>     for ( i=0; i < smax; i++)
>         {
>                rev = (rev << 1 )| (in & 1);
>                in >>1;
>         }
>    return rev;
> }
>
>
> int main(int argc, char *argv[])
> {
>  int ausgangswert = 0x6C;
>  int ergebnis = bit_reverse(ausgangswert);
>     while(1)
>      {
>  printf("ergebnis = %d\n", ergebnis); }
> }
>
> So sieht mein Programm inzwischen aus. Läuft auch fehlerfrei. Allerdings
> bekomme ich immer die Ausgabe "ergebnis = 0".
> Kann mir das jemand erklären?

Wenn du den obigen Code kompilierst, solltest du eine Warnung bekommen:
um.c: In function ‘bit_reverse’:
um.c:9: warning: statement with no effect

Wenn du Dir dann nochmal Zeile 9 anschaust:
                in >>1;

Und mit dem Code von oben vergleichst:
                in >>= 1;

Stellst du fest das da ein Zeichen fehlt.

Sebastian

Autor: Udo R. S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Methode von AVR ist richtig nett (und locker doppelt so schnell wie 
die Schleife), habe ich so noch nicht gesehen, obwohl es eigentlich 
ziemlich logisch ist.
Allerdings nicht unbedingt für Anfänger geeignet, was das Verständnis 
betrifft.
Aber für jemanden der meint er kann schon programmieren eine nette 
Fingerübung zum Nachvollziehen :-)

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Am schönsten gehts aber in 8051 Assembler:
                                ;C:  ACC:
MIRROR:  MOV C, ACC.1           ;1 76543210
         RLC A                  ;7 65432101
         MOV ACC.2, C           ;7 65432701
         MOV C, ACC.3           ;2 65432701
         RLC A                  ;6 54327012
         MOV ACC.4, C           ;6 54367012
         MOV C, ACC.5           ;3 54367012
         RLC A                  ;5 43670123
         MOV ACC.6, C           ;5 45670123
         SWAP A                 ;5 01234567
         RET


Peter

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Diese Routine kann ich direkt verwerten. Bis Dato habe ich jedes Bit 
über C in eine bitadressierbare Variable geschrieben. Danke.

Autor: Udo R. S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Peter,
die ist ja noch besser. Allerdings nur auf Rechner verwendbar bei denen 
man ein bitadressierbares move von und zum Carry hat. Hat der AVR oder 
PIC das?

Wieder was gelernt :-)

Autor: klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Wie drehe ich eine Bitreihenfolge mit WinAVR um??

Man sollte für solche Aufgaben immer eine Funktion verwenden die einen 
anderen Programmierer maximal verwirrt ;-) Just für diesen Zweck habe 
ich vor etwas längerer Zeit folgende C Funktion geschrieben:

size_t bit_swap(size_t x, size_t bits)
{
    return bits ? (x & 1) << (bits - 1) | bit_swap(x >> 1, bits - 1) : 0;
}


Mit x übergibt man die zu spiegelnden Daten, mit bits gibt man die 
Anzahl der Bits die gespiegelt werden. Will man nur ein Byte spiegeln 
nimmt man "bit_swap(x, 8)". Man kann aber auch nur zum Beispiel 5 Bits 
spiegeln lassen oder 13, ganz egal...

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
klaus schrieb:
> Man sollte für solche Aufgaben immer eine Funktion verwenden die einen
> anderen Programmierer maximal verwirrt ;-) Just für diesen Zweck habe
> ich vor etwas längerer Zeit folgende C Funktion geschrieben:

Ziel verfehlt :-)
Damit kannst du gestandene Lisp Programmierer nicht übertölpeln. Die 
schnallen sofort, dass du eine CAR (na ja) / CDR Zerlegung einer Liste 
von Bits auf C Art machst und aus den bearbeiteten Einzelteilen wieder 
eine neue Liste von Bits zusammensetzt :-)

Frei nach dem Motto:
Eine Liste wird umgedreht indem man die Liste in das erste Element und 
den Rest zerlegt. Dann dreht man den Rest um und hängt das erste Element 
hinten drann.

(Schöne Arbeit!)

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Und wie sieht -  bit_swap - aus?

Autor: A. K. (prx)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Martin schrieb:

> Und wie sieht -  bit_swap - aus?

ROFL!

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Und wie sieht -  bit_swap - aus?

Owned!  :D

Autor: klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Und wie sieht -  bit_swap - aus?

Rekursion heißt das Zauberwort :-)

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Antwort die erwartete war:

size_t bit_swap(size_t x, size_t bits)
{
    return bits ? (x & 1) << (bits - 1) | bit_swap(x >> 1, bits - 1) : 
0;
}

Darauf hätte ich geschrieben:

Und wie sieht -  bit_swap - aus?


usw.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hä? Und jetzt noch mal auf Deutsch bitte...

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
klaus schrieb:
>
> size_t bit_swap(size_t x, size_t bits)
> {
>     return bits ? (x & 1) << (bits - 1) | bit_swap(x >> 1, bits - 1) :
> 0;
> }
> 


Ein sehr schönes Beispiel für die Unsinnigkeit von Rekursionen.
Diese Routine maximiert wirklich alles negative:
- höchster Codeverbrauch
- höchster SRAM-Verbrauch
- höchste Zyklenzahl


Peter

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Am schönsten gehts aber in 8051 Assembler:

Nein in ARM (Thumb-2) Assembler: RBIT r0, r0   ;-)

Gruß
Marcus
http://www.doulos.com/arm/

Autor: A. K. (prx)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marcus Harnisch schrieb:

> Nein in ARM (Thumb-2) Assembler: RBIT r0, r0   ;-)

Kommt aber ganz was anderes heraus als bei seinem Mirror. ;-)

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Du läßt wohl keine Werbegelegenheit aus, Marcus.

Autor: Udo R. S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die Rekursion ist auch klasse.
Vor allem wenn man einen Hardwarestack mit der maximalen Tiefe von (4?) 
hat :-))
War das nicht bei einigen Microcontrollern so?
Ich denke wir sind uns alle einig. Die Funktionen sind alle nicht so 
einfach verständlich wie die Schleife, aber manchmal muss es einfach 
schneller sein, und da sind durchaus auch Speziallösungen sinnvoll.
Schön waren die Lösungen allemal.

Gruß, Udo

Autor: Mark Brandis (markbrandis)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
klaus schrieb:
> Man sollte für solche Aufgaben immer eine Funktion verwenden die einen
> anderen Programmierer maximal verwirrt ;-) Just für diesen Zweck habe
> ich vor etwas längerer Zeit folgende C Funktion geschrieben:
>
>
>
> size_t bit_swap(size_t x, size_t bits)
> {
>     return bits ? (x & 1) << (bits - 1) | bit_swap(x >> 1, bits - 1) :
> 0;
> }
> 

Wer auf einem Mikrocontroller rekursive Funktionen programmiert, der 
gehört mindestens erschossen, besser noch sollte er sein Studium 
komplett wiederholen müssen ;-)

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Klaus schrieb:
> Hä? Und jetzt noch mal auf Deutsch bitte...

Das war eine 'rekursive Frage' :-)

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
oh man! Jetzt hab ichs auch verstanden :D Da stand ich wohl etwas auf 
der Leitung... ;)

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wohin gehst du?
Ins kino.
Was läuft?
Quo vadis!
Was bedeutet das?
Wohin gehst du?
Ins kino.
Was läuft?
Quo vadis!
Was bedeutet das?
Wohin gehst du?
Ins kino.
Was läuft?
Quo vadis!
Was bedeutet das?
Wohin gehst du?
Ins kino.
Was läuft?
Quo vadis!
Was bedeutet das?
Wohin gehst du?
Ins kino.
Was läuft?
Quo vadis!
Was bedeutet das?
Wohin gehst du?
Ins kino.
Was läuft?
Quo vadis!
Was bedeutet das?

Autor: Udo R. S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Stack overflow :-)

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
A. K. schrieb:
> Kommt aber ganz was anderes heraus als bei seinem Mirror. ;-)

Na gut, dann eben:
LSL  r0, #24
RBIT  r0, r0

Gruß
Marcus
http://www.doulos.com/arm/

Autor: yalu (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:

> klaus schrieb:
>>
>
>> size_t bit_swap(size_t x, size_t bits)
>> {
>>     return bits ? (x & 1) << (bits - 1) | bit_swap(x >> 1, bits - 1) :
>> 0;
>> }
>>
>
>
> Ein sehr schönes Beispiel für die Unsinnigkeit von Rekursionen.
> Diese Routine maximiert wirklich alles negative:
> - höchster Codeverbrauch
> - höchster SRAM-Verbrauch
> - höchste Zyklenzahl

Rekursionen sind nicht generell unsinnig, sondern werden nur traditio-
nell in manchen Programmiersprachen häufiger genutzt als in anderen.

Da Karl Heinz weiter oben den LISP-Programmierer ins Spiel gebracht hat:
Dieser würde die Funktion (wenn er sich überhaupt in die C-Niederungen
herablässt :)) so schreiben:
size_t bit_swap2h(size_t x, size_t bits, size_t r) {
  return bits ? bit_swap2h(x>>1, bits-1, r<<1|x&1) : r;
}

size_t bit_swap2(size_t x, size_t bits) {
  return bit_swap2h(x, bits, 0);
}

Dabei ist bit_swap2h eine Hilfsfunktion, die von bit_swap2 aufgeru-
fen wird. Da der Compiler in diesem Fall die Rekursion auflöst, brauchen
beide Funktionen zusammen ziemlich genau gleich viel Programmbytes,
Datenbytes und Taktzyklen wie die folgende, C-typischere Implementierung
mittels einer Schleife:
size_t bit_swap3(size_t x, size_t bits) {
  size_t r=0;
  while(bits--) {
    r = r<<1 | x&1;
    x >>= 1;
  }
  return r;
}

Der einzig verbleibende Nachteil der rekursiven Variante ist also, dass
sie für einen C-Only-Programmierer nicht sofort verständlich ist ;-)

Autor: A. K. (prx)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marcus Harnisch schrieb:

> Na gut, dann eben:

Ich hätte zur besseren Verwirrung ja das gemacht:
RBIT  r0, r0
REV r0, r0

Autor: Udo R. S. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Der einzig verbleibende Nachteil der rekursiven Variante ist also, dass
>sie für einen C-Only-Programmierer nicht sofort verständlich ist ;-)

Ok, dann zeig mit doch mal den Lisp Interpreter für den AVR oder PIC :-)
und die Ausführungszeit ist auch genausoschnell wie bei der Variante von 
Peter :-))))

Gruß und Spass, Udo

Merke: nicht jeder nicht-Lisp-Fan ist ein C-Only-Programmierer oder die 
Crux mit der hinreichenden und notwendigen Voraussetzung :-))

Autor: yalu (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Udo R. S. schrieb:
>> Der einzig verbleibende Nachteil der rekursiven Variante ist also,
>> dass sie für einen C-Only-Programmierer nicht sofort verständlich ist
>> ;-)
>
> Ok, dann zeig mit doch mal den Lisp Interpreter für den AVR oder PIC
> :-) und die Ausführungszeit ist auch genausoschnell wie bei der
> Variante von Peter :-))))

Ich habe ja nicht dafür plädiert, auf AVRs und PICs in LISP zu program-
mieren, sondern wollte nur aufzeigen, dass rekursive Programmierung —
richtig eingesetzt — bzgl. der von Peter genannten Kriterien nicht
schlechter als iterative Programmierung sein muss.

Ich behaupte aber auch nicht, dass sie besser ist ;-)

(nicht, dass jetzt alle Programmiereinsteiger meinen, sie dürften keine
Schleifen mehr verwenden)

Autor: Martin (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ist es möglich den Code von Peter noch zu beschleunigen?

                                ;C:  ACC:
MIRROR:  MOV C, ACC.1           ;1 76543210
         RLC A                  ;7 65432101
         MOV ACC.2, C           ;7 65432701
         MOV C, ACC.3           ;2 65432701
         RLC A                  ;6 54327012
         MOV ACC.4, C           ;6 54367012
         MOV C, ACC.5           ;3 54367012
         RLC A                  ;5 43670123
         MOV ACC.6, C           ;5 45670123
         SWAP A                 ;5 01234567
         RET

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Martin schrieb:
> Ist es möglich den Code von Peter noch zu beschleunigen?

;Input:  A
;Output: A

;1.Brute force: 6 / 8 Cycle, 259 Byte
MIRROR1:
  JZ MIRR1    ;0: leave unchanged
  MOVC A, @A+PC    ;mirror 1 to 0FFh (max 255 entries in table!)
MIRR1:
  RET
  MB SET 1
  REPT 255    ;use Keil Assembler to expand this macro
    DB ((MB AND 1) SHL 7)+((MB AND 2) SHL 5)+((MB AND 4) SHL 3)+((MB AND 8) SHL 1)+((MB AND 10h) SHR 1)+((MB AND 20h) SHR 3)+((MB AND 40h) SHR 5)+((MB AND 80h) SHR 7)
    MB SET MB + 1    ;;count up to mirror next byte
  ENDM

;2.Code optimized: 54 Cycle, 10 Byte
MIRROR2:
  MOV R2, #8    ;all 8 Bits
MIRR2:
  RLC A      ;shift out
  XCH A, R3
  RRC A      ;shift in in reverse order
  XCH A, R3
  DJNZ R2 MIRR2
  MOV A, R3    ;get result
  RET

;3.Intelligent: 17 Cycle, 17 Byte
        ;C:  ACC:
MIRROR3:
  MOV C, ACC.1    ;1 76543210
  RLC A      ;7 65432101
  MOV ACC.2, C    ;7 65432701
  MOV C, ACC.3    ;2 65432701
  RLC A      ;6 54327012
  MOV ACC.4, C    ;6 54367012
  MOV C, ACC.5    ;3 54367012
  RLC A      ;5 43670123
  MOV ACC.6, C    ;5 45670123
  SWAP A      ;5 01234567
  RET


Peter

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
es geht doch mit sehr viel weniger code

out porta, R16
in R16, portb

jetzt nur

PinA0 mit PinB7
PinA1 mit PinB6
PinA2 mit PinB5
PinA3 mit PinB4
PinA4 mit PinB3
PinA5 mit PinB2
PinA6 mit PinB1
PinA7 mit PinB0

verbinden und fertig.

Autor: Klaus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
lol :D

Und wie würdest du dann eine optimierte Division machen?

Autor: Lothar Miller (lkmiller) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kein Programm ist so kurz, dass nicht noch Platz für einen Fehler wäre:
out porta, R16
in R16, portb

Bei einem AVR käme sowas besser:
out porta, R16
in R16, pinb

Antwort schreiben

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

Wichtige Regeln - erst lesen, dann posten!

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

Formatierung (mehr Informationen...)

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




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

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