Snippets en Z80

[Urusergi]

Y de postre, una rutina que hace lo mismo pero sin emplear tablas
 

Código: Seleccionar todo

DI
LD BC,#BC0F                                          ; Puerto para desbloquear el Asic & contador
XOR A
OUT (C),A                                            ; Inicializa secuencia de desbloqueo
DEC A

bucle_desbloqueo_asic:
OUT (C),A
LD H,A                                               ; H = 7654 3210
RLCA : RLCA                                          ; A = 5432 1076
XOR H : AND %01111111 : XOR H                        ; A = 7432 1076
LD L,A
RLCA                                                 ; A = 4321 0767
XOR L
AND %10001000                                        ; A = 7--- 1--- XOR 4--- 0---
RR H
RES 3,H                                              ; H = -765 -321
OR H
DEC C
JR NZ,bucle_desbloqueo_asic
EI
RET

 
Soy todo ojos si alguien es capaz de optimizarla aun mas.
Me he basado en la figura 2 del documento https://www.cpcwiki.eu/imgs/6/61/Patent_GB2243701A.pdf

[Meta]

Hola Uruseri

Has mirado si con RRCA es más factible? hay cierto patrón ahí pero no me da tiempo hacer más..
te lo dejo por aquí, espero que ayude.

Código: Seleccionar todo

ld a,#ff

xor #88 ;;77

rrca
xor #8 ;;b3

rrca
xor #88 ;;51

rrca ;;a8

rrca
xor #80 ;;d4

rrca
xor #8 ;;62

rrca
xor #8 ;;39

rrca ;;9c

rrca
xor #8 ;;46

rrca
xor #8 ;;2b

rrca
xor #80 ;;15

rrca ;;8a

rrca
xor #88 ;;cd

rrca
xor #8 ;;ee

[Urusergi]

Bien visto! eso que estás intentando ya se me ocurrió, pero no es tan óptimo como el original y sigue haciendo falta una tabla:
 

Código: Seleccionar todo

ORG #4000
DI
LD HL,L4011
LD BC,#BC11
XOR A

L4008:
RRA
XOR (HL)
INC HL
OUT (C),A
DEC C
JR NZ,L4008

EI
RET

L4011:
DB #FF,#7F,#FF,#08,#88,#08,#80,#80
DB #08,#08,#80,#08,#08,#00,#80,#88
DB #88

El patrón es ni mas ni menos que dos registros de desplazamiento a derecha de 4 bits cada uno. El problema es que están separados, y nosotros solo podemos usar desplazamientos de 8 bits de forma óptima. Luego hay que aplicar realimentación por la izquierda de los dos registros con un XOR de los dos bits menos significativos del registro de desplazamiento '0' y otro XOR de dos bits, el mas y el menos significativo del registro de desplazamiento "1". Todo esto se ve muy bien en el esquema eléctrico del enlace que puse en el primer mensaje.

La gracia estaba en intentar conseguir activar el asic sin usar ninguna tabla, y que ocupara menos que la rutina original, pero parece imposible

[Meta]

Con la tabla es más fácil desde luego. Esta claro que nos van lo desafios jeje

Lo que dices me recuerda un poco a la rutina de cpctelera reverse bits (la de sprite espejo).
Me he fijado que la sequencia tambien es espejo acotando el principio y el final (sin contar los 3 primeros FF 00 FF)

77 --> EE 0111 0111 --> 1110 1110
B3 --> CD 1011 0011 --> 1100 1101
51 --> 8A 0101 0001 --> 1000 1010
A8 --> 15 1010 1000 --> 0001 0101
D4 --> 2B 1101 0100 --> 0010 1011
62 --> 46 0110 0010 --> 0100 0110
39 --> 9C 0011 1001 --> 1001 1100

Por esto decia lo del patrón, aunque es probable que sea mejor como tu haces. De hecho ya lo conseguiste, enhorabuena!

Curiosa la patente esta, no la conocia. A ver si le echo un rato para lograr entenderla.

[Urusergi]

Gracias! aunque habría estado genial si mi rutina ocupara menos bytes

Ah, ya entiendo lo que querías decir. Es una pena que no se pueda aprovechar el 'reverse' para hacer una rutina compacta, o por lo menos no veo la manera

[Mode 2]

Llevo un rato echándole un ojo a esto y no veas, y al margen del locuelo del Syx que ya le dije algo cuando inicio este hilo, agradecer a Meta y a Uru los aportes. Anda que no tendré que revisar cosillas en lo picado hasta la fecha, pero ya cuando tenga un rato, ¡Optimización al poder!

[Meta]

Bienvenido Mode!

Espero que te sean útiles

Pongo algo facilón, un relleno de cuadritos con tablita, que intercambiando bits soy malísimo

Código: Seleccionar todo

org #4000

;; globals
SCR_WIDTH EQU #50

run $

ld hl,boxes
call fill_tbl
;;ld hl,frame
;;call fill_tbl

jr $


;;======================================================================
;; FILL TABLE
;; in: HL (table_addr).
;; Destroy A,BC,HL,DE

.fill_tbl:
ld b,(hl):inc hl ;; num items
@ftb_lp
push bc
ld a,(hl):inc hl ;; colour
ld c,(hl):inc hl ;; -width bytes
ld b,(hl):inc hl ;; height
ld e,(hl):inc hl ;; scr addr
ld d,(hl):inc hl ;; scr addr
push hl
ex de,hl ;; scr addr -> HL
call fill_box_color ;; draw box. req: A,BC,HL
pop hl
pop bc
djnz @ftb_lp
ret

;;======================================================================
;; FILL BOX
;; in HL,C,B,A (scr_addr, -width bytes, height, colour).
;; Destroy A,B,C,HL,DE

.fill_box_clear:
xor a ;; colour = 0
.fill_box_color:
ld (@fbox_color+1),a ;; set colour
.fill_box:
ld a,b ;; A = height
ld b,#7
ld d,#c0
@fbox_lp
ld e,c ;; E = -width bytes
@fbox_color
ld (hl),0 ;; colour var -> screen
inc hl
inc e
jr nz,@fbox_color
dec a ;; dec height
ret z
add hl,bc ;; next line
jr nc,@fbox_lp
ld e,SCR_WIDTH
add hl,de ;; next row
jr @fbox_lp

;;======================================================================
;; db num_items
;; db colour, -width_bytes, height: dw scr_addr
.boxes:
db 8
db #f0,-20,35:dw #d390
db #0f,-25,40:dw #e423
db #ff,-10,30:dw #c51c
db #00,-5,20:dw #c4ce

;;.frame
;;db 4
db #10,-1,20:dw #c000
db #f0,-16,1:dw #c001
db #80,-1,20:dw #c011
db #f0,-16,1:dw #d8a1


[Urusergi]

Ponga unos bonitos XORs en su vida.

Ultimamente me ha dado por estudiar el fabuloso Firmware del 6128. Está increible, pero mi 'sentido arácnido'
no ha parado de molestar mientras iba entendiendo las pequeñas subrutinas que lo componen. Si, aunque es un
código extraordinario, hay zonas (demasiadas) que se pueden mejorar rascando bytes y/o ganando velocidad.

Hay muchas mejoras por doquier, pero hay una que me ha llamado la atención porque es de 'pura lógica' y sin
embargo no la han aplicado estos muchachos. Cuando queremos mezclar bits entre el acumulador y otro registro
de 8 bits se suele utilizar lo siguiente:

AND %abcdefgh:LD C,A:LD A,B:AND %ijklmnop:OR C

Pero para esto también están los maravillosos XORs. Cuando, por ejemplo haces XOR C:XOR C todo el mundo sabe
que A continua con el mismo valor. Por lo tanto es equivalente a un doble NOP.
Y ahora puedes pensar ¿Y si metemos un AND %abcdefgh en medio de los XORs?
Exacto! donde coloques un '0' se copiará el bit de esa posición de C en A y dónde pongas un '1' permanecerá el
bit original de esa posición en A.
La ventaja es triple, rascas tres bytes, ganas velocidad (poca), y no haces uso del resto de registros.