omdraaien van een WORD

Voor een truckje wil ik de gegevens in een WORD omdraaien
Dus bijv. 0011 0000 0000 0000 moet dan worden
0000 0000 0000 1100
het leek zo simpel maar ik kom er even niet uit

In welke taal/compiler wil je dat doen?

Oo gewoon in Basic

hmmzz.. zet alle letters in een variabele.. en dan met een loop loop alle variabelen achterwaards weer aan elkaar koppelen..

PaWoN

1000STE POST!!!!

Op 16 september 2005 17:30:03 schreef Hans Broersen:
Oo gewoon in Basic

Welke "gewone" basic???

De basic om de microprocesser MC68HC05B6
te voeden

Op 16 september 2005 18:16:26 schreef Hans Broersen:
De basic om de microprocesser MC68HC05B6
te voeden

Laat ik die nou net niet hebben. Wel GWbasic, Qbasic, QB45, visual basic, picbasic, CTbasic en gewoon basic ;-)

Op 16 september 2005 18:24:16 schreef GJ_:
[...]
Laat ik die nou net niet hebben. Wel GWbasic, Qbasic, QB45, visual basic, picbasic, CTbasic en gewoon basic ;-)

TI basic, Proton basic, Pbasic, Linxbasic...

Best veel smaken hoor!

Ik hoop toch
Dat iemand met een serieus antwoord komt

Testen op een bit in je word en indien "true" de waarde van het gespiegelde bit in een hulpvariabele optellen totdat je alle bits hebt gehad. Serieus genoeg? ;)

Ik ben eigenlijk bang dat je ze in een loopje 1 voor 1 moet omdraaien. Ik neem tenminste aan dat als je er 4x 8bits bytes van maakt dat je de bits gewoon kunt lezen en schijven met "variabele.bit"

Kent die basic niet een shift left en right? En kun je als je het ene word de ene kant op shift het bitje dat er uit valt er bij het andere word inschuiven en dan de andere kant op shiften?

Op 16 september 2005 18:42:12 schreef Hans Broersen:
Ik hoop toch
Dat iemand met een serieus antwoord komt

We moeten toch echt een basic hebben, de naam van de compiler en de fabrikant.

Probeer eens te zoeken op swap, en daar een loopje mee maken.

Bij mij is het:
REV:
Reverses the order of the lowest bits in a value. The number of bits to be reversed is from 1 to 32. Its syntax is: -

VAR1 = %10101100 REV 4 ' Sets VAR1 to %10100011

or

DIM DWD AS DWORD
DWD = %10101010000000001111111110101100 REV 4 ' Sets DWD to %10101010000000001111111110100011

Op 16 september 2005 18:54:02 schreef GJ_:
Ik ben eigenlijk bang dat je ze in een loopje 1 voor 1 moet omdraaien. Ik neem tenminste aan dat als je er 4x 8bits bytes van maakt dat je de bits gewoon kunt lezen en schijven met "variabele.bit"

Kent die basic niet een shift left en right? En kun je als je het ene word de ene kant op shift het bitje dat er uit valt er bij het andere word inschuiven en dan de andere kant op shiften?

In de instructieset van de 68HCxxx controller zitten krachtige shift en rotate operatoren, lijkt mij sterk dat zoiets niet terug te vinden is in een bijbehorende basic compiler!

Oke Wist niet dat er zoveel soorten basic prog zijn
waar ik mee zit is een C/control basic van conrad

Schuiven gaat wel door middel vandit voorbeeld

Define Temp WORD[1]
Define poort1 Port[1]

#test
FOR I=1 TO 16

IF (Temp AND 1)=1 THEN Poort1=ON ELSE Poort1=OFF
Temp=Temp SHR 1
NEXT

dan zou je zeggen als ik links om schuif SHL dan BEN IK ER maar dit gaat fout

Ik hoop dat ik duidelijk genoeg ben ...
ben niet zo goed in uitleg.

je moet een rotate instructie hebben ipv een shiftinstructie waarbij de MSB de LSB wordt na elke rotate

[Bericht gewijzigd door shortcircuit op ]

Het is toch moeilijker dan ik dacht
maar ik heb geen rotatie instructie
of heb je een voorbeeldje

de C-control van Conrad...
Daar heb ik de Plus versie nog van gehad..
Alle feedback is in het duits evenals de forums (fora?)
Daarom ben ik daar maar me gestopt.

Ik heb met PIC basic wel een opdracht gezien (in de handleiding) die data serieel uitstuurde naar een andere PIC (ik was op zoek naar communicatiemiddelen tussen 2 PIC's) de tweede PIC fungeert dan als een soort shiftregister, waarbij je ook kon aangeven hoe het op rij kwam te staan. LSB of MSB (ik zag het antwoord van Shortcircuit ook al) Als je dit weer serieel terug laat sturen naar je utilityboard ben je er ook.
Vraag me niet hoe precies, maar volgens mij kun je het zo oplossen.
Voor een specifieke Conrad C-Control oplossing geef ik je weinig kans.
Oder du solst vieleigt im Deutsche sprache reden konte. Oder zo etwas... :-)

als je geen specifieke rotate functie hebt moet je je woord gaan indelen in nibbles en dan de nibbles met shift instructies gaan behandelen en daarna de geshifte nibbles terug gaan vormen naar een word:

uit je uitleg kan ik verstaan dat je basic instructieset toch een AND en een SHIFT L/R heeft dus hier valt wel mee te werken...

WORD bestaat uit NIBBLE4,NIBBLE3,NIBBLE2,NIBBLE1

sla de nibbles in een BYTE (of WORD) op door LOGISCH AND functies toe te passen als volgt:

MASKEREN:
=========
NIBBLE1 = WORD & 0x0F (0000 0000 0000 1111)
NIBBLE2 = WORD & 0xF0 (0000 0000 1111 0000)
NIBBLE3 = WORD & 0xF00 (0000 1111 0000 0000)
NIBBLE4 = WORD & 0xF000 (1111 0000 0000 0000)

als de maskering goed is zou elke NIBBLE een waarde moeten hebben tussen 0 en 15 en dus nooit groter mogen zijn dan 15!

IN JOUW VOORBEELD VOOR NIBBLE 4:
===============================
NIBBLE10 = NIBBLE4 SHL 2

(shift NIBBLE4 twee posities links en plaats in NIBBLE10
NIBBLE4 = 0011
NIBBLE10 = NIBBLE4 SHL 2 dus NIBBLE10 wordt 1100)

NIBBLE20 = NIBBLE3 SHL ?
NIBBLE30 = NIBBLE2 SHL ?
NIBBLE40 = NIBBLE1 SHL ?

EN MAAK VAN DE NIBBLES TERUG EEN WORD:
======================================

moet zoiets worden als:

WORD = NIBBLE40 + NIBBLE30 + NIBBLE20 + NIBBLE10

maar aan elke NIBBLE moet nog een gewicht gekoppeld worden:

WORD = (NIBBLE40*4096) + (NIBBLE30*256) + (NIBBLE20*16) + NIBBLE10

verklaring van die gewichten:

als bv NIBBLE40 = 1111 (0000 0000 0000 1111) hadden we deze dus graag helemaal links gehad, dit kan door die gewichten:

1111 = 15
15*4096 = 61440 = 1111 0000 0000 0000

door aan elke nibble een ander gewicht te koppelen komen deze op een andere plaats terecht. nibble 1 heeft een gewicht van 1 natuurlijk!

door alle gewogen nibbles op te tellen bekomen we als het goed is het totaal WORD value

dus volgens mij:

1/ MASK door logishe AND
2/ SHIFTEN door SHR x / SHL x
3/ TOTAL CALCULATION OF WEIGHTED NIBBLES

[Bericht gewijzigd door shortcircuit op ]

BTW: waarom wil je dit uiteindelijk gaan toepassen ?

HOLA!

moet jij die NIBBLES niet inverteren ipv shiften ?

is een beetje onduidelijk wat je wilt ?

als ik het goed begrijp wil jij

NIBBLE4 op de eerste plaats
NIBBLE3 op de tweede plaats
NIBBLE2 op de derde plaats
NIBBLE1 op de eerste plaats

en dan elke bit in de NIBBLES geinverteerd?

invertern kan door middel van NOT

dus NIBBLE10 = NOT NIBBLE4

in dit geval wordt het:

1/ MASKEREN VAN DE NIBBLES
2/ INVERSIE VAN DE NIBBLES DOOR NOT INSTRUCTIE
3/ GEINVERTEERDE NIBBLES EEN GEWICHT TOEKENNEN
4/ SOMMATIE MAKEN VAN DE GEWOGEN NIBBLES

graag wat meer info...

[Bericht gewijzigd door shortcircuit op ]

Laat ik die nou net niet hebben. Wel GWbasic, Qbasic, QB45, visual basic, picbasic, CTbasic en gewoon basic

en PowerBasic ? ;-)

en het zijn NIBBLES en geen NIPPLES hé :9

Simpel, XOR 65535

De snelle manier is een lookup table gebruiken voor elke afzonderlijke byte.

[Bericht gewijzigd door jojo op ]

Op 17 september 2005 00:55:48 schreef Frits Kieftenbelt:
Simpel, XOR 65535

Inderdaad simpel, maar zeker niet correct