[PIC] Byte omdraaien

Bestaat er in een PIC een simpel commando om een byte om te draaien?
Dus:

new_bit0 = old_bit7
new_bit1 = old_bit6
new_bit2 = old_bit5
new_bit3 = old_bit4
new_bit4 = old_bit3
new_bit5 = old_bit2
new_bit6 = old_bit1
new_bit7 = old_bit0

welke taal gebruik je?

Robbert

Mmm, assembler of basic. Maakt mij niet uit. Maar IN een pic is in ieder geval assembler (eigk opcode).

[Bericht gewijzigd door elmowww op (40%)]

Alle ASM commando's staan in de datasheet van de desbetreffende PIC. Hetgeen wat er het meeste op lijkt zal iets van SWAPF zijn, alleen is dat volgens mij van toepassing op nibbles.

Ik ben niet thuis in PIC assembler, maar er is (net als bij andere assembly talen) ongetwijfeld een Rotate Left (ROL) of Rotate Right (ROR) commando.

[update]
Ik heb een PIC assembly Language Reference gevonden. ROR en ROL staan er ook in (blz. 13 en verder). Er is niet één commando, meest in de buurt komt SWAP (wissel nibble's) en ROL/ROR (bitniveau). Je kunt iets in een loopje doen met ROL.

De rechttoe rechtaan methode:

RevWReg:
rlf WREG,f 	
rrf reverse,f 	
rlf WREG,f 	
rrf reverse,f 	
rlf WREG,f 	
rrf reverse,f 	
rlf WREG,f 	
rrf reverse,f 	
rlf WREG,f 	
rrf reverse,f 	
rlf WREG,f 	
rrf reverse,f 	
rlf WREG,f 	
rrf reverse,f 	
rlf WREG,f 	
rrf reverse,w
return

Korter maar trager (met een loop)


               movlw 8
               movwf counter
revloop        rrf abuff,R
               rlf bbuff,F
               decfsz counter,F
               goto revloop

En dan nu de slimste methode:

;       input X  = abcdefgh , Output X = hgfedcba
;       Written by Dmitry A. Kiryashov 2000
;       12 clocks/words

reverse8bit:

        swapf   X,W     ;efghabcd
        xorwf   X,W     ;efghabcd
                        ;abcdefgh

        andlw   0x66    ;.fg..bc.
                        ;.bc..fg.

        xorwf   X,F     ;afgdebch
;
        rrf     X,W
        rrf     X,F     ;hafgdebc
;
        andlw   0x55    ;.a.g.e.c
        addwf   X,F     ;h.f.d.b.
                        ;a.g.e.c.
        rrf     X,F     ;.h.f.d.b
                        ;.a.g.e.c

        addwf   X,F     ;ahgfedcb
;
        rlf     X,W
        rlf     X,F     ;hgfedcba
                        ;it can be replaced
                        ;with rlf X,W
                        ;if necessary...

Dit alles met dank aan www.piclist.com :)

Nee, geen commando.

Wel een loopje om het te doen:

CLRF new

MOVLW 0x08
MOVWF teller

loop

RRF old,1
RRL new,1

DECFSZ teller,1
GOTO loop

Als je hetkwijt kunt in PICBasic, kun je het commando REV gebruiken. Die zet de inhoud van de variabele in spiegelbeeld, als dat is wat je bedoeld.

Als je een stukje in picbasic schrijft, compileerd en de ASMcode daar uit haalt, zie je hoe ze het in Assembler hebben gedaan.

[Bericht gewijzigd door Fantomaz op (31%)]

Ah, dankjulliewel allen :)

Had gehoopt dat er toch een wat eenvoudigere manier was ;)

Wat Fantomaz schreef, het gebruik van de operator REV in PIC Basic, is toch eenvoudig?
REV draait de laatste bits om, met het getal achter REV geef je aan hoeveel bits omgedraaid moeten worden.


Variabele = %00110101 
Variabele = Variabele REV 4

'Variabele' krijgt eerst de waarde 00110101
Na het omdraaien van de laatste 4 bits (de 4 achter REV) is 'Variabele' nu 00111010 (de laatste 4 bits zijn omgedraaid).

----

Om alle bits van een BYTE om te draaien plaats je gewoon een 8 achter REV.


Variabele = %00110101 
Variabele = Variabele REV 8

'Variabele' krijgt eerst de waarde 00110101
Na het omdraaien van de 8 bits (de 8 achter REV) draait het hele zakie om.
'Variabele' is nu %10101100.

Dat snap ik wel, ik bedoelde een efficientere methode om het te doen.

Rev in picbasic zal niet het meest efficient werken ;)

...laat maar...

[Bericht gewijzigd door BernardV op (95%)]

Op 7 maart 2008 11:46:20 schreef elmowww:
Dat snap ik wel, ik bedoelde een efficientere methode om het te doen.

Volgens mij heb ik de meest efficiente methode (12 cycles) al gepost, als er een snellere is dan hoor ik dat graag.

Never mind ;). Nog niet wakker enzo ...

[Bericht gewijzigd door Anoniem op (70%)]

is het niet gewoon zo

dim a as byte
dim b as byte

b = 128 - a

Nee.
Maar het is leuk om te zien waarom (in ieder geval) niet:
Als b=128-a zou zijn, dan zouden de opeenvolgende b's steeds 1 verschillen, net als a.
Dat zou dus in het minstwaardige bit zijn. Terwijl opeenvolgende b's juist in het meestwaardige bit zouden moeten verschillen. ;)

/e: Elmowww, ga je FFT's maken?

Volgens mij gaat dat niet.
Want als je waarde 192 binair hebt, en je trekt dat af van je 128, kom je negatief uit.
Dat trekt je pic niet.

misschien zo dan.
b = 255 - a

Gaat ook niet op...
11111111 (255) - 11000000 (192) = 00111111 (63) en geen 00000011 (3)

(kuch) Ik probeer het nog eens:
Als b=255-a zou zijn, dan zouden de opeenvolgende b's steeds de waarde 1 verschillen. Dat zou dus in het minstwaardige bit zijn. Terwijl opeenvolgende b's juist in het meestwaardige bit zouden moeten verschillen. :+

-

[Bericht gewijzigd door Frits Kieftenbelt op (100%)]

Vreemd, Fantomaz's antwoord staat hoger dan de vraag afgebeeld? 23:01 / 23:04

Foutje... zit net een dag verschil in |:(