Revistas en disco
 Fanzine Nº1 - Julio 1992
Anterior
Menú
Logotipo

Fanzine
Número 1 - JULIO 1992

CURSO DE CODIGO MAQUINA AVANZADO PARA EL AMIGA

  Curso escrito y dirigido por:
                        SPANISH ARCHER / DARKNESS
  CAPITULO I:Una pequeña introducción.                     © S.A.1992

Habla Warlord: Hace unos días le propuse a este buen amigo, que hiciera un curso avanzado para el 68000. La idea le gustó, así que planificó la estructura que tendría este cursillo: Comandos del copper, utilización del blitter... Sin embargo, por razones de tiempo me vi obligado a pedirle que lo hiciera en tan sólo un par de horas (tenía que coger el tren y llevarme conmigo el artículo). Así que me reuní con él en su casa, y decidimos hacer de este capítulo una pequeña introducción, sobre lo que es la programación con el Amiga. Para ello tomamos una rutina que lo que hacía era simplemente inicializar la pantalla, aunque posteriormente, improvisando consiguió, sin muchos cambios, hacer que se viera "agüilla" en la pantalla. Esta rutina es la que aquí se comenta.

Pedimos perdón por los conceptos que no ha podido explicar, pero que ha prometido lo hará en posteriores números, iniciando así el cursillo de una forma más lógica y estructurada.

Para seguir este curso es indispensable haberse leido un libro sobre los comandos del 68000 (se recomienda el de Anaya),así como de disponer de otro de programación más avanzada como puede ser el AMIGA HARDWARE REFERENCE MANUAL disponible ya en Español (NORSOFT).

Seguramente habrá cosas que no entendáis, pero como ya os dije, esto es solo una pequeña introducción, y explicarlo todo lo que se utiliza aquí es difícil, pero no preocuparos que seguro que más adelante os enteraréis de todo y este programa os parecerá muy fácil.

Por último, queremos agradecerle su indispensable colaboración para con nuestra, (y vuestra) revista. ¡GRACIAS!


CAPITULO I: Una pequeña rutina (INTRODUCCION)

Bueno, vamos a empezar por lo básico de todo demo-adicto: COMO INICIALIZAR UNA PANTALLA (suena fácil pero ...).

Como dije antes para este cursillo hacen falta ciertos conocimientos previos acerca del 68000 y algo del amiga, por ello no voy a explicar todo con absoluto detalle, sino que voy a ir a lo mas importante.

A lo nuestro:

En primer lugar hay que reservar la memoria para la pantalla, esto depende de que pantalla quieras inicializar. La formula para ello es:

(ANCHO/8)*ALTO*no de BIT PLANOS.

En nuestro caso vamos a inicializar una pantalla de 4 Bit-planos (16 colores) en baja resolución sin entrelazar, con unas dimensiones de 320*256 (PAL), por lo tanto el nº. de bytes a inicializar serán

(320/8)*256*4=45960.

¿Como se le dice al sistema que quieres memoria?. Fácil, el sistema provee una serie de rutinas contenidas en las famosas librerías que sirven para el control de la memoria. En nuestro caso las rutinas necesarias estan en la librería principal la EXEC.LIBRARY.

Para acceder a una rutina de librería hay que:

- Abrir la librería (Excepto la EXEC.LIBRARY que siempre esta abierta).
- Poner la base de la librería (obtenida al abrirla) en A6
- Conocer el offset (salto indirecto) de la rutina deseada.
- Conocer e inicializar los parametros de la rutina.
- saltar a la subrutina con JSR-OFFSET(a6).

En este caso la base de la EXEC esta siempre apuntada en la dirección 4. Por lo tanto seria:

                 move.l 4,a6           ponemos la base de EXEC en A6
                 move.l #45960,d0      en d0 la cantidad de bytes a reservar
                 move.l #$10002,d1     (*)tipo de memoria
                 jsr    -$c6(a6)        salto a allocmem (offset=$c6)
                 move.l d0,bp0          d0 retorna la dirección de la memoria.

(*) tipos de memoria:
#$10002=Chip memory (accesibles por los coprocesadores)
#$10004=Fast Memory (no accesibles por los copro. pero de mas rapido acceso para el 68000)

Una vez que hemos reservado memoria para la pantalla hay que decirle al copper (coprocesador de refresco de pantalla, el cual lo veremos mucho más a fondo en otro articulo debido a su importancia) donde estan los Bit-planos.

Para ello hay que crear una lista copper. Una lista copper son una serie de instrucciones que contienen una cadena de comandos que solo entiende el copper y que permiten hacer muchas cosas al tener acceso a los registros del sistema. Esta vez vamos a hacer una lista copper hiper-básica ya que sólo va a refrescar los registros de los bit-planes. Para ello tenemos que meter la dirección de cada uno de los cuatro bit-planos en los registros del sistema para este proposito. Estos registros son de 16 bits.Por lo tanto hay dos registros para cada bit-planes. Estos son BPLxPTH y PBLxPTL (donde x es el no. de bit-plane ). Van del $0e0 y 0e2 para el bit-plano 0 al $0f4 y $0f6 para el bit-plano 5.(mirar aspecto de la lista copper al final del listado para tener una cierta referencia)

Como el copper tiene que acceder al su lista en la chip-mem hay reservar espacio para la lista-copper en chip-mem tal como hicimos antes:

                  move.l #listacopper,d1
                  move.l #listacopperfin,d0
                  sub.l  d1,d0                                
                  move.l d0,copperlong      halla la longitud en bytes de la
                  move.l #$10002,d1         lista copper
                  jsr    -$c6(a6)           allocmem con la cantidad de memo-
                  move.l d0,copperl         ria de la lista cooper

Una vez creada la lista copper hay que meterle las direcciones de los bit-planos en la lista copper para que los refresque. Así:

                  move.l  bp0,d0
                  add.l   #10240,d0
                  move.l  d0,bp1
                  add.l   #10240,d0
                  move.l  d0,bp2
                  add.l   #10240,d0
                  move.l  d0,bp3
                  move.l  bp0,d0
                  move.w  d0,cbp05
                  swap    d0
                  move.w  d0,cbp0
                  move.l  bp1,d0
                  move.w  d0,cbp15
                  swap    d0
                  move.w  d0,cbp1
                  move.l  bp2,d0
                  move.w  d0,cbp25
                  swap    d0
                  move.w  d0,cbp2
                  move.l  bp3,d0
                  move.w  d0,cbp35
                  swap    d0
                  move.w  d0,cbp3

Ahora vamos a abrir la librería GRAPHIC.LIBRARY para obtener posteriormente la dirección de la lista copper actual para no perder la pantalla del DOS.

                  movea.l  4,a6
                  lea      grafname,a1
                  clr.l    d0
                  jsr      -$198(a6)
                  move.l   d0,grafbase
           *************** copper y pantalla ***********************

Ahora, paso la nuestra lista-copper (que no sabemos si esta en chip o en fast mem) a la chip mem que reservamos anteriormente. Con un simple bucle basta:

                  movea.l   copperl,a0
                  lea       listacop,a1
                  move.l    copperlong,d2
      copb        move.b    (a1)+,(a0)+
                  subi      #1,d2
                  bne       copb

Ahora vamos a acceder directamente a ciertos registros del sistema, para ello hay que sumar $dff000 al numero de registro para obtener su dirección efectiva. P. Ej: Si queremos acceder al registro del color 0 ($180) con el 68000 seria $180+$dff000=$dff180. Así primeramente desconectamos los canales DMA (otro día sera la susodicha explicación) con el registro DMACONW ($096)

                  move.w    #$01a0,$dff096

(ver apéndices del (*) AMIGA HARDWARE MANUAL para los contenidos de cada bit de los registros).

Ahora le damos la dirección de la lista copper al registro oportuno, para que el copper sepa donde obtener la lista.

                  move.l   copperl,$dff080                                
                  clr.w    $dff088                  Activa el copper!!
                  move.w   #$3081,$dff08e  |
                  move.w   #$30c1,$dff090   \ tamaño de la ventana (ver (*)AHM)
                  move.w   #$0038,$dff092   /
                  move.w   #$00d0,$dff094  |

Ahora vamos a decir el tipo de pantalla que vamos inicializar. Para este objetivo tenemos el registro BPLCON0 ($100), cuyos bits describo ahora:

                     BIT no.   NOMBRE                FUNCION
                     -----------------------------------------------
                       15      HIRES        ACTIVA LA ALTA RESOLUCION
                       14      BPU2         }
                       13      BPU1         } NO. DE BIT-PLANES
                       12      BPU0         }
                       11      HOMOD        ACTIVA MODO HAM
                       10      DBLPF        ACTIVA DUAL-PLAYFIELD
                                             (otro día sera...)
                        9      COLOR        ACTIVA EL COLOR
                        8      GAUD         AUDIO PARA EL GENLOCK
                        7      ----         }
                        6      ----         }  NO USADOS
                        5      ----         }
                        4      ----         }
                        3      LPEN         PARA EL LAPIZ OPTICO
                        2      LACE         ACTIVA EL ENTRELAZADO
                        1      ERSY         PARA SINCRONIZAR CON FUENTE
                                               EXTERNA (GENLOCK...)
                        0      ----         NO USADO

Por lo tanto en nuestro ejemplo sera (no hi-res, %100 para el no de bit-planos, no HAM, no DUAL, color activo, sin entrelazar, etc...)

                     move.w                #%0100001000000000,$dff100 
                     clr.w   $dff102 |
                     clr.w   $dff104  \módulos de las pantallas
                     clr.w   $dff108  /(ver AHM)
                     clr.w   $dff10a |
                     move.w  #$87c0,$dff096     Activa canales DMA!!
                     move.w  #$000,$dff180     pone negro el color de fondo

y listo... ya tenemos una hermosa pantalla en negro con la que podemos hacer futuras maravillas.

                   ****************programa principal**************** 

Bueno, ahora vienen las chorradas de ultima hora para la utilización de la pantalla. Ahí va la mía:

                move.w    #$f00,$dff182
                move.w    #$0f0,$dff184   colores
                move.w    #$00f,$dff186
     bucle      move.w    #20480,d0
                move.l    bp0,a0
                move.l    4,a1
     aguilla    move.w    $dff006,d1   toma el valor de la pos del electrón
                add.w     (a1)+,d1             (pseudoaleatoria)
                add.w     d1,(a0)+     pone en pantalla la parida.
                subi.w    #1,d0
                bne     aguilla
                btst.b    #6,$bfe001   comprueba el estado del botón izquierdo
                beq     salida         del ratón
                bra     bucle
                  ************** salida del programa ***************

Una vez que queremos salir de nuestro programa hemos de decirle al sistema que hemos dejado libre la memoria anteriormente ocupada por los bp y la lista-copper. Para ello estan las rutina freemem de la alloc.lib. Además tenemos que cerrar las librerías abiertas y inicializar la pantalla del DOS.

Ahí va:

   salida      move.l   grafbase,a4   tomo la base de graphics.library en a4
               move.w   #$0580,$dff096   Quito canales DMA

La base de la lista copper del DOS esta en la 38 después de la base de la graphics.l Así, le digo al copper donde anda la lista copper del dos:

               move.l     38(a4),$dff080     
               clr.w     $dff088          Copper activo!
               move.w     #$83a0,$dff096  DMA activos!
               movea.l    4,a6            en a6, la base de EXEC.lib
               move.l     copperl,a1      a1=dirección de list.copper
               move.l     copperlong,d0   longitud del bloque a liberar
               jsr        -$d2(a6)        Freemem     (offset $d2)
               move.l     bp0,a1          a1=dirección de los bit-planos
               move.l     #45960,d0       longitud a liberar
               jsr        -$d2(a6)        Freemem de nuevo
               move.l     grafbase,a1     
               jsr        -$19e(a6)       Close library (offset= $19e)
               clr.l     d0
               rts                        retorna al DOS
                    ****** listas copper ************
    listacopper
    listacop               dc.w   $e0
    cbp0                   ds.w   1
                           dc.w   $e2
    cbp05                  ds.w   1
                           dc.w   $e4
    cbp1                   ds.w   1
                           dc.w   $e6
    cbp15                  ds.w   1
                           dc.w   $e8
    cbp2                   ds.w   1
                           dc.w   $ea
    cbp25                  ds.w   1
                           dc.w   $ec
    cbp3                   ds.w   1
                           dc.w   $ee
    cbp35                  ds.w   1
                           dc.w   $ffff,$fffe          
    listacopperfin     
                 ****** variables globales*************
      bp0                  ds.l   1
      bp1                  ds.l   1
      bp2                  ds.l   1
      bp3                  ds.l   1
      grafbase             ds.l   1
      copperl              ds.l   1
      copperlong           ds.l   1
      grafname             dc.b   'graphics.library',0
      end

Aquí termina esta primera lección.Espero que os haya sido de utilidad. En el próximo número..... MAS.


Envía esta página web a un amigo:
Esta opción está desactivada temporalmente, rogamos disculpen las molestias

Volver a la página anterior

Al menú principal