src/leds.asm

   1 ; vim: set filetype=asx8051 et sw=4 sts=4 :
   2
   3 ; Módulo y opciones
   4 .module     leds
   5 .optsdcc    -mmcs51 --model-small
   6
   7 ; Constantes "públicas"
   8 LEDS_MAX_COLS    = 32       ; Cantidad máxima de columnas
   9
  10 ; Variables públicas
  11 .globl  _leds_matrix_len    ; unsigned char
  12 .globl  _leds_matrix        ; unsigned int[LEDS_MAX_COLS]
  13 .globl  _leds_delay         ; unsigned char
  14
  15 ; Funciones públicas
  16 .globl  _leds_init          ; void leds_init();
  17 .globl  _leds_test          ; void leds_test();
  18 .globl  _leds_write         ; void leds_write(unsigned int);
  19 .globl  _leds_write_low     ; void leds_write_low(unsigned char);
  20 .globl  _leds_write_high    ; void leds_write_high(unsigned char);
  21 .globl  _leds_delay_update  ; void leds_delay_update();
  22 .globl  _leds_lock          ; void leds_lock();
  23 .globl  _leds_unlock        ; void leds_unlock();
  24 .globl  _leds_timer2_isr    ; void leds_timer2_isr() interrupt 5;
  25
  26
  27 ; Constantes
  28 INTERVAL        = 666 ; 0.1ms (por el clock de 8MHz)
  29 LEDS_LOW        = 0x0080
  30 LEDS_HIGH       = 0x00c0
  31 DELAY_BASE      = 11 ; 16 columnas anda bien con 28 - (len / 2) == 20
  32
  33 ; Área de bancos de registros
  34 .area   REG_BANK_0    (REL,OVR,DATA)
  35     .ds     8
  36     ; Usamos siempre banco 0
  37     ar0     = 0x00
  38     ar1     = 0x01
  39     ar2     = 0x02
  40     ar3     = 0x03
  41     ar4     = 0x04
  42     ar5     = 0x05
  43     ar6     = 0x06
  44     ar7     = 0x07
  45
  46 ; Variables es memoria RAM común
  47 .area   DSEG    (DATA)
  48 _leds_matrix_len::  ; Cantidad de columnas de la matriz
  49     .ds     1
  50 _leds_delay::       ; Retardo de dibujado configurado
  51     .ds     1
  52 delay:              ; Contador del retardo actual
  53     .ds     1
  54 curr_col:           ; Columna que se está dibujando actualmente
  55     .ds     1
  56
  57 ; Variables en memoria RAM extendida indirecta (8052)
  58 .area   ISEG    (DATA)
  59 _leds_matrix::      ; Matriz a dibujar
  60     .ds     LEDS_MAX_COLS * 2  ; 2 bytes por columna
  61
  62 ; Variables de bit
  63 .area   BSEG    (BIT)
  64 lock:               ; Variable utilizada para el 'locking', indica si el timer
  65     .ds     1       ; estaba andando al momento de lockear para que el unlock
  66                     ; pueda reactivarlo de ser necesario
  67
  68 ; Configuramos el vector de interrupciones para atender el timer2
  69 ;.area   INTV    (ABS, CODE)
  70 ;    .org    0x002b
  71 ;    clr     tf2 ; limpio bit de interrupción porque para el timer2 no es autom.
  72 ;    ljmp    timer2_isr
  73
  74
  75 ; Área de código del programa
  76 .area   CSEG    (CODE)
  77
  78 ; Inicializa leds.
  79 ; Primitiva de C:
  80 ;                   void leds_init();
  81 ;
  82 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
  83 _leds_init::
  84     ; guardo registros que uso
  85     push    ar0
  86     push    ar1
  87     push    ar2
  88
  89     ; leo de la ROM el tamaño por default
  90     mov     dptr, #DEFAULT_MATRIX_LEN
  91     clr     a
  92     movc    a, @a+dptr
  93     mov     _leds_matrix_len, a
  94     clr     c
  95     rlc     a ; multiplicamos por 2 porque hay 2 bytes por columna
  96     mov     r2, a ; tamaño en bytes de la matriz
  97
  98     ; Cargo milisegundos
  99     lcall   _leds_delay_update
 100     mov     delay, _leds_delay
 101
 102     ; copio imagen por default de la ROM a la RAM
 103     mov     dptr, #DEFAULT_MATRIX
 104     mov     r0, #0              ; indice del "array" en la ROM
 105     mov     r1, #_leds_matrix   ; dirección de memoria de la RAM
 106     mov     a, r0
 107 proximo$:
 108     movc    a, @a+dptr         ; leo de la ROM con el índice
 109     mov     @r1, a ; escribo en el puntero a la RAM
 110     inc     r1 ; incremento puntero
 111     inc     r0 ; incremento índice
 112     mov     a, r0 ; para comparar
 113     cjne    a, ar2, proximo$ ; veo si quedan más bytes por leer
 114
 115     ; cargo los capture registers
 116     mov     rcap2l, #<(-INTERVAL) ; low byte del intervalo
 117     mov     rcap2h, #>(-INTERVAL) ; high byte del intervalo
 118
 119     mov     t2con, #0x00; setup del timer2 (auto-reload), no lo arrancamos
 120     setb    tr2 ; largo a correr el timer2
 121
 122     mov     curr_col, #0  ; inicializo el contador de columna en 0
 123
 124     ; Limpiamos stack
 125     pop     ar2
 126     pop     ar1
 127     pop     ar0
 128
 129     ret
 130
 131
 132 ; Hace una prueba simple de los leds
 133 ; Primitiva de C:
 134 ;                   void leds_test();
 135 ;
 136 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
 137 _leds_test::
 138     ; escribo patrones en los leds
 139     mov     dptr, #0xffff
 140     lcall   _leds_write
 141     lcall   sleep
 142
 143     mov     dptr, #0xaaaa
 144     lcall   _leds_write
 145     lcall   sleep
 146
 147     mov     dptr, #0x5555
 148     lcall   _leds_write
 149     lcall   sleep
 150
 151     mov     dptr, #0x0000
 152     lcall   _leds_write
 153     lcall   sleep
 154
 155     ret
 156
 157
 158 ; Escribe en los leds.
 159 ; Primitiva de C:
 160 ;                   void leds_write(unsigned int);
 161 ;
 162 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
 163 _leds_write::
 164     ; guardamos en r0 la parte alta que imprimimos despues
 165     push    ar0
 166     mov     r0, dph
 167     ; parte baja
 168     mov     a, dpl ; de C me viene la parte baja del argumento en el dpl
 169     mov     dptr, #LEDS_LOW
 170     cpl     a ; complemento para ver encendidos los "1"
 171     movx    @dptr, a
 172     ; parte alta
 173     mov     a, r0 ; de C me viene la parte alta del argumento en el dph
 174     mov     dptr, #LEDS_HIGH
 175     cpl     a ; complemento para ver encendidos los "1"
 176     movx    @dptr, a
 177     ; devolvemos r0
 178     pop     ar0
 179     ret
 180
 181
 182 ; Escribe en los leds del primer latch.
 183 ; Primitiva de C:
 184 ;                   void leds_write_low(unsigned char);
 185 ;
 186 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
 187 _leds_write_low::
 188     ; parte baja
 189     mov     a, dpl       ; de C me viene el argumento en el dpl
 190     mov     dptr, #LEDS_LOW
 191     cpl     a ; complemento para ver encendidos los "1"
 192     movx    @dptr, a
 193     ret
 194
 195
 196 ; Escribe en los leds del segundo latch.
 197 ; Primitiva de C:
 198 ;                   void leds_write_high(unsigned char);
 199 ;
 200 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
 201 _leds_write_high::
 202     ; parte baja
 203     mov     a, dpl       ; de C me viene el argumento en el dpl
 204     mov     dptr, #LEDS_HIGH
 205     cpl     a ; complemento para ver encendidos los "1"
 206     movx    @dptr, a
 207     ret
 208
 209
 210 ; Actualiza el retardo de la matriz según la cantidad de columnas
 211 ; Primitiva de C:
 212 ;                   void leds_delay_update();
 213 ;
 214 ; La fórmula utilizada es: (DELAY_BASE - (leds_matrix_len / 2)) * 0.1 ms
 215 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
 216 _leds_delay_update::
 217     mov     a, _leds_matrix_len
 218     clr     c
 219     rrc     a ; divido por 2
 220     mov     dpl, a
 221     mov     a, #DELAY_BASE
 222     subb    a, dpl
 223     mov     _leds_delay, a
 224     ret
 225
 226
 227 ; Bloquea el timer de los leds cuando se accede a una zona crítica (P0 y/o P2).
 228 ; Primitiva de C:
 229 ;                   void leds_lock();
 230 ;
 231 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
 232 _leds_lock::
 233     mov     c, et2      ; En lock me queda si está el timer andando o no.
 234     mov     lock, c
 235     clr     et2         ; Sea como sea, lo paro.
 236     ret
 237
 238
 239 ; Desbloquea el timer de los leds.
 240 ; Primitiva de C:
 241 ;                   void leds_unlock();
 242 ;
 243 ; C se encarga de hacer push y pop del dptr, a y psw si lo necesita.
 244 _leds_unlock::
 245     jnb     lock, 1$    ; Si no estába andando, no hago nada
 246     setb    et2         ; Si estaba andando lo prendo
 247 1$:
 248     ret
 249
 250
 251 ; Manejador de la interrupción del timer2 para el uso de los leds.
 252 ; Primitiva de C:
 253 ;                   void leds_timer2_isr() interrupt 5;
 254 ;
 255 _leds_timer2_isr::
 256     ; limpiamos flag del timer2
 257     clr     tf2
 258     ; vemos si todavía hay que seguir esperando o si ya tenemos que leer
 259     djnz    delay, 255$
 260
 261     ; comenzamos realmente a leer la próxima columna
 262     mov     delay, _leds_delay
 263
 264     ; guardamos en el stack el estado actual de los registros que vamos a usar
 265     push    acc
 266     push    psw
 267     push    ar0
 268     push    dpl
 269     push    dph
 270
 271     ; vemos si hay que empezar a leer por la 1ra columna de nuevo
 272     mov     a, curr_col
 273     cjne    a, _leds_matrix_len, 1$
 274
 275     ; hay que empezar de nuevo
 276     mov     curr_col, #0
 277     mov     a, curr_col ; dejamos en a la columna actual
 278
 279 1$:
 280     ; multiplicamos por 2 porque hay 2 bytes por columna
 281     clr     c
 282     rlc     a
 283
 284     ; uso r0 como puntero al comienzo de la matriz
 285     mov     r0, #_leds_matrix
 286     add     a, r0 ; le sumo al puntero el offset actual segun la columna
 287     mov     r0, a
 288
 289     ; imprimo en LEDS_HIGH
 290     mov     a, @r0 ; leo el contenido de la matriz
 291     mov     dptr, #LEDS_HIGH
 292     cpl     a ; complemento para ver encendidos los "1"
 293     movx    @dptr, a
 294
 295     ; imprimo en LEDS_LOW
 296     inc     r0     ; busco proximo byte de la columna
 297     mov     a, @r0 ; leo el contenido de la matriz
 298     mov     dptr, #LEDS_LOW
 299     cpl     a ; complemento para ver encendidos los "1"
 300     movx    @dptr, a
 301
 302     ; avanzamos a la proxima columna
 303     mov     a, curr_col
 304     inc     a
 305     mov     curr_col, a
 306
 307     ; sacamos nuestra basura del stack
 308     pop     dph
 309     pop     dpl
 310     pop     ar0
 311     pop     psw
 312     pop     acc
 313
 314 255$:
 315     reti ; listo! seguimos viaje...
 316
 317
 318 ; Provoca un retardo corto.
 319 ; Usamos dpl y dph porque son "C-safe".
 320 sleep:
 321     mov     a, #0xff
 322 2$:
 323     mov     dph, #0xff
 324 1$:
 325     mov     dpl, #0xff
 326     djnz    dpl, .
 327     djnz    dph, 1$
 328     djnz    acc, 2$
 329     ret
 330
 331
 332 ; Matriz por default
 333 DEFAULT_MATRIX_LEN:
 334     .db     16
 335     ;.db     32
 336
 337 DEFAULT_MATRIX:
 338 ;    .dw     0b0000111111110000    ; columna 0
 339 ;    .dw     0b0011111111111100    ; columna 1
 340 ;    .dw     0b0111000000001110    ; columna 2
 341 ;    .dw     0b0110000000000110    ; columna 3
 342 ;    .dw     0b1100001100000011    ; columna 4
 343 ;    .dw     0b1100011000110011    ; columna 5
 344 ;    .dw     0b1100110000110011    ; columna 6
 345 ;    .dw     0b1100110000000011    ; columna 7
 346 ;    .dw     0b1100110000000011    ; columna 8
 347 ;    .dw     0b1100110000110011    ; columna 9
 348 ;    .dw     0b1100011000110011    ; columna 10
 349 ;    .dw     0b1100001100000011    ; columna 11
 350 ;    .dw     0b0110000000000110    ; columna 12
 351 ;    .dw     0b0111000000001110    ; columna 13
 352 ;    .dw     0b0011111111111100    ; columna 14
 353 ;    .dw     0b0000111111110000    ; columna 15
 354
 355     .dw     0b0000011111100000
 356     .dw     0b0001111111111000
 357     .dw     0b0011100000011100
 358     .dw     0b0111110000000110
 359     .dw     0b0110111000000110
 360     .dw     0b1100011100000011
 361     .dw     0b1100001110000011
 362     .dw     0b1111111111111111
 363     .dw     0b1111111111111111
 364     .dw     0b1100001110000011
 365     .dw     0b1100011100000011
 366     .dw     0b0110111000000110
 367     .dw     0b0111110000000110
 368     .dw     0b0011100000011100
 369     .dw     0b0001111111111000
 370     .dw     0b0000011111100000
 371
 372 ;    .dw     0b1111000000001111    ; columna 0
 373 ;    .dw     0b1100000000000011    ; columna 1
 374 ;    .dw     0b1000111111110001    ; columna 2
 375 ;    .dw     0b1001111111111001    ; columna 3
 376 ;    .dw     0b0011001111111100    ; columna 4
 377 ;    .dw     0b0011100111001100    ; columna 5
 378 ;    .dw     0b0011110011001100    ; columna 6
 379 ;    .dw     0b0011110011111100    ; columna 7
 380 ;    .dw     0b0011110011111100    ; columna 8
 381 ;    .dw     0b0011110011001100    ; columna 9
 382 ;    .dw     0b0011100111001100    ; columna 01
 383 ;    .dw     0b0011001111111100    ; columna 00
 384 ;    .dw     0b1001111111111001    ; columna 01
 385 ;    .dw     0b1000111111110001    ; columna 03
 386 ;    .dw     0b1100000000000011    ; columna 04
 387 ;    .dw     0b1111000000001111    ; columna 05
 388
 389 ;    .dw     0b0000001111100000    ; columna 0
 390 ;    .dw     0b0000111110000000    ; columna 1
 391 ;    .dw     0b0111111000000000    ; columna 2
 392 ;    .dw     0b1111000000000000    ; columna 3
 393 ;    .dw     0b0111100000000000    ; columna 4
 394 ;    .dw     0b0011110000000000    ; columna 5
 395 ;    .dw     0b0001111000000000    ; columna 6
 396 ;    .dw     0b0000111100000000    ; columna 7
 397 ;    .dw     0b0000011110000000    ; columna 8
 398 ;    .dw     0b0000001111000000    ; columna 9
 399 ;    .dw     0b0000000111100000    ; columna 10
 400 ;    .dw     0b0000000011110000    ; columna 11
 401 ;    .dw     0b0000000001111000    ; columna 12
 402 ;    .dw     0b0000000000111100    ; columna 13
 403 ;    .dw     0b0000000000011110    ; columna 14
 404 ;    .dw     0b0000000000001111    ; columna 15
 405
 406 ;end