I use one of those in TI-Boy to emulate the SWAP (HL) instruction, which swaps the upper and lower nibbles of (HL).
It works like ld a,(hl) \ rrd.

Indeed, the only time I've ever used it was for BCD. It's useful if you need to recover a number from TI's floating points. For instance:

turnTheEntireOp1ToADecimalStringRegardlessOfSignificateFigures:
ld hl, op1+2
ld c, 7
outerLoop:
ld b, 2
innerLoop:
ld a, $30
rld
ld (de), a
inc de
djnz innerLoop
inc hl
dec c
jr nz, outerLoop
xor a
ld (de), a
ret


I'm glad there are actually uses for that command.  I like the idea of manipulating nibbles, but I don't like the fact that it modifies the source data.  Can you use it on ROM code without any problems? 

You probably shouldn't be manipulating code by nibble Anyway, A contains the correct result even if (HL) can't be changed, IIRC.

Ooh, rrd and rld are some of my favorite instructions! When I was describing what it does in my pocket asm tutorial was this:

rrd/rld the two nibbles from (hl) and the last nibble of 'a' make three nibbles. rrd                
           rotates them right and rld rotates them left.

As for a way to use them, I have a few codes that make excellent use of them. This one is from my program BSPRT. It uses hexadecimal sprite data, so instead of converting the hex string to a location in RAM and then copying it to the screen, I just did both at once (here is the sprite display part):
;Inputs:
;     HL points to the buffer location to draw to
;     DE points to the sprite data

     ld bc,080Ch     ;010C08
Loop:
     call PutNibble  ;CD****
     call PutNibble  ;CD****
     ld a,b          ;78
     ld b,0          ;0600
     add hl,bc       ;09
     ld b,a          ;47
     djnz Loop       ;10F3
     ret             ;C9
PutNibble:
     ld a,(de)       ;1A
     add $C0         ;C6C0
     jr nc,$+4       ;3002
       sub 7         ;D607
     rld             ;ED6F
     inc de          ;13
     ret             ;C9
This is my favorite one, though. When I made a graph shifting routine, I made these to shift 4 pixels very quickly:
ShiftLeft4:
     ld hl,GraphBuf+767
     ld c,64
       xor a
       ld b,12
         rld
         dec hl
         djnz $-3
       dec c
       jr nz,$-9
       ret
ShiftRight4:
     ld hl,GraphBuf
     ld c,64
       xor a
       ld b,12
         rrd
         inc hl
         djnz $-3
       dec c
       jr nz,$-9
       ret
I feel pretty proud of these I think the first can be optimised more, but it is still nice, I think

It is because she wrote [code=something].
Here is what she meant

;Inputs:
;     HL points to the buffer location to draw to
;     DE points to the sprite data

     ld bc,080Ch     ;010C08
Loop:
     call PutNibble  ;CD****
     call PutNibble  ;CD****
     ld a,b          ;78
     ld b,0          ;0600
     add hl,bc       ;09
     ld b,a          ;47
     djnz Loop       ;10F3
     ret             ;C9
PutNibble:
     ld a,(de)       ;1A
     add $C0         ;C6C0
     jr nc,$+4       ;3002
       sub 7         ;D607
     rld             ;ED6F
     inc de          ;13
     ret             ;C9


Quote from: chickendude on December 31, 2011, 05:32:36 am

Unless i'm missing something, the first just says "Array", maybe you pasted the wrong thing?

I am not seeing that... On mine, Hayleia and I have the same thing...

I see "Array" too on yours. Maybe it depends on the browser.
But do you see "BSPRT" next to "code" ? (I don't see it, I had to quote you to see it should be here )

Ah, well with that code, will draw a sprite with hexadecimal data input. By that, I mean . db "3C4281818181423C" as opposed to .db 3Ch,42h,81h,81h,81h,81h,42h,3Ch

The first is what a TI-BASIC string would be like and the program that code is in is designed for TI-BASIC programmers to use.