SDGI

Repaso para el parcial

Mapa de memoria, CSBR/CSOR, pila y lectura de código en el MCF5272

calculando…
Por qué este tema

El mapa de memoria aparece en todos los parciales

En Nov-2015, Ene-2016, Nov-2017 y el parcial de SDG1 2017-18, la primera pregunta es siempre la misma: a partir de un listado en ensamblador y un enunciado, reconstruir el mapa de direcciones y configurar los registros CSBRn / CSORn. Esta página practica justo eso.

Comprobación rápida de una BAM

Como tienes calculadora de bases, no necesitas hacer las conversiones a mano — pero sí conviene saber reconocer un error. Una BAM siempre es "N unos seguidos de ceros", así que cada cifra hexadecimal solo puede ser 0, 8, C, E o F. Si te sale cualquier otra cifra (1,2,3,4,5,6,7,9,A,B,D), te has equivocado en algún paso.

válidas: $FFFFC $FFFC0 $FFFE0 $FFFFF $FF800 inválida: $FFFFD ← la D es imposible en una BAM

Registro base de selección de chip — CSBR0–CSBR7

BAbits 31-12 · dirección base ÷ $1000
EBI11-10
BW9-8
SUPER7
—6-1
EN0
EBI00 SRAM/ROM 16-32 bits con byte-enable01 SDRAM (solo CS7)10 reservado11 SRAM/ROM 8 bits sin byte-enable
BW00 long (32b)01 byte (8b)10 word (16b)11 línea de caché (32b)

SUPER=1 → CSn# solo se activa en modo supervisor · ENABLE=1 → se habilita la salida CSn#.

CSBRn = (BA << 12) | (EBI << 10) | (BW << 8) | (SUPER << 7) | ENABLE

Registro de opciones — CSOR0–CSOR7

BAMbits 31-12 · máscara de comparación
—11-6
WS6-2 · estados de espera
RW1
MRW0

La BAM marca con 1 los bits que SÍ se comparan. El decodificador solo exige que coincidan con BA los bits donde BAM=1; donde BAM=0 el bit de la dirección puede ser cualquier cosa — ahí es donde "crece" el rango. Como BA/BAM solo cubren A31-A12, el bloque mínimo posible ya es de 4 KB (2¹²).

Receta: tamaño = 2ⁿ → k = n-12 bits a 0 (los menos significativos de los 20) → escribe (20-k) unos seguidos de k ceros → agrupa en 5 nibbles de 4 bits → pasa a hex.

16 KB = 2^14 → k=2 → 18 unos + 2 ceros 1111 1111 1111 1111 1100 F F F F C → BAM = $FFFFC 256 KB = 2^18 → k=6 → 14 unos + 6 ceros 1111 1111 1111 1100 0000 F F F C 0 → BAM = $FFFC0 4 KB = 2^12 → k=0 → 20 unos → BAM = $FFFFF (bloque mínimo) CSORn = (BAM << 12) | (WS << 2) | (RW << 1) | MRW

MRW=0 → lectura/escritura (RW no importa) · MRW=1 → solo lectura (RW=0) o solo escritura (RW=1).

Memoria interna y SIM — MBAR / RAMBAR

MBAR — mapea el módulo SIM (registros internos) en una ventana fija de 64 KB.

MBAR = (BA16 << 16) | SC<<4 | SD<<3 | UC<<2 | UD<<1 | V ej: MBAR=$00010001 → SIM en $00010000-$0001FFFF, V=1

RAMBAR — habilita la RAM interna, de tamaño fijo 4 KB.

RAMBAR = (BA20 << 12) | WP<<8 | CI<<5 | SC<<4 | SD<<3 | UC<<2 | UD<<1 | V ej: RAMBAR=$00004035 → RAM en $00004000-$00004FFF (WP=0, así que no afecta a este valor) Ojo: en las máscaras SC/SD/UC/UD el 1 PROHÍBE el acceso, el 0 lo PERMITE.

Dato que cae mucho en el test: hay 8 salidas CS0#-CS7#; CS0# es la única habilitada tras el reset y da acceso a la ROM de arranque.

Caso 1 · guiado

Construir un mapa de memoria desde cero (apuntes U3)

El sistema tiene: ROM externa con el programa (16 KB, CS0#), RAM interna para variables y pila (4 KB, vía RAMBAR), el módulo SIM (64 KB, vía MBAR), otros dispositivos de E/S externos (64 KB, CS2#) y RAM externa de datos (256 KB, CS1#). El bus de datos es de 32 bits en todos los casos; la RAM externa necesita 1 estado de espera; se inhabilita el acceso a la RAM interna para accesos de código.

Rango (hex)DispositivoVía
$00000000 – $00003FFFROM externa (programa) · 16 KBCS0#
$00004000 – $00004FFFRAM interna (variables y pila) · 4 KBRAMBAR
$00010000 – $0001FFFFMódulo SIM (registros internos) · 64 KBMBAR
$00020000 – $0002FFFFOtros dispositivos de E/S externos · 64 KBCS2#
$00040000 – $0007FFFFRAM externa (datos) · 256 KBCS1#
Ver configuración completa de registros
  • CSBR0 = $00000001 → BA=$00000, EBI=00, BW=00 (ROM 32b), SUPER=0, ENABLE=1
  • CSOR0 = $FFFFC001 → BAM=$FFFFC (16 KB), WS=0, RW=0, MRW=1 (solo lectura)
  • RAMBAR = $00004035 → BA=$00004, WP=0, C/I=1, SC=UC=1 (sin acceso a código), SD=UD=0, V=1
  • MBAR = $00010001 → BA=$0001, sin máscaras, V=1
  • CSBR1 = $00040001 / CSOR1 = $FFFC0004 → RAM externa 256 KB, 1 estado de espera, lectura/escritura
  • CSBR2 = $00020001 / CSOR2 = $FFFF0000 → E/S externa 64 KB
Caso 2 · examen real

Noviembre 2015 — Pulsómetro portable (MCF5272 a 66 MHz)

Módulo emisor/receptor de IR conectado directamente al bus externo (puerto de 8 bits, P_AD, P_MUESTRA, P_DEDO); módulo de visualización en un puerto de 8 bits (P_DISPLAY).

MBAR_MEM EQU $00200000 CSBR0 EQU MBAR_MEM+$40 CSOR0 EQU MBAR_MEM+$44 (ROM 16 bits, 512 KB) ORG $100000 FREC_CARD DS.B 1 ERROR DS.B 1 BUFFER_PULSO DS.B N_MUESTRAS ; N_MUESTRAS = 2000 PILA DS.B TAMPILA P_DEDO ORG $700000 ; módulo IR, puerto de 8 bits P_AD DS.B 1 P_MUESTRA DS.B 1 P_DISPLAY ORG $600000 ; módulo de visualización, puerto de 8 bits DS.B 1

Pista: la RAM usada son los 4 KB de RAM interna (vía RAMBAR) — no hay chip de RAM externa en el enunciado.

1.1 — Completa el mapa de memoria

0/5
Ver explicación — por qué es ese rango
  • ROM ($00000000–$0007FFFF): el enunciado dice "ROM 16 bits, 512 KB" y nada fija su base, así que se le asigna la dirección más baja posible, $00000000. 512 KB = $80000 bytes → último byte en $0007FFFF.
  • RAM interna ($00100000–$00100FFF): FREC_CARD, ERROR, BUFFER_PULSO (N_MUESTRAS=2000 bytes) y PILA se declaran tras ORG $100000, dentro de la RAM interna del MCF5272. Esa RAM es siempre de 4 KB fijos (vía RAMBAR), así que el bloque ocupa $00100000-$00100FFF aunque las variables sumen menos.
  • Módulo SIM ($00200000–$0020FFFF): MBAR_MEM EQU $00200000 fija la base; la ventana de registros internos es siempre de 64 KB.
  • Módulo IR ($00700000–$00700002): P_DEDO ORG $700000, luego P_AD DS.B 1 y P_MUESTRA DS.B 1 ocupan, en orden, $700000, $700001 y $700002.
  • Display ($00600000–$00600000): P_DISPLAY ORG $600000 con un único DS.B 1 → ocupa solo esa dirección.

1.3 — Configura CSBR1 / CSOR1 (módulo IR, sin estados de espera)

0/11
Ver justificación completa
  • RAMBAR=$00100035 — RAM interna en $00100000, sin máscara para datos (solo se inhabilita código).
  • CSBR1=$00700D01 — BA=$00700; EBI=11 (SRAM de 8 bits); BW=01 (puerto de 8 bits); SUPER=0; ENABLE=1.
  • CSOR1=$FFFFF000 — BAM=$FFFFF (bloque mínimo de 4 KB, el módulo solo ocupa 3 bytes); WS=0 (sin estados de espera); RW=0, MRW=0 (lectura y escritura).
  • Mapa: ROM $00000000-$0007FFFF · RAM $00100000-$00100FFF · SIM $00200000-$0020FFFF · Módulo IR $00700000-$00700002 · Display $00600000-$00600000.
Caso 3 · examen real

SDG1 — Parcial 13/11/2017 — Adquisición de datos y estadísticos

MCF5272 a 66 MHz. Pantalla de solo escritura (32 bits, 64 KB). Conversor A/D de 8 bits + pulsador comparten zona de direcciones. Usa la RAM interna del microcontrolador.

MBAR_MEM EQU $20000000 CSBR0 EQU MBAR_MEM+$40 (EPROM 16 bits, 128 KB) CSBR1 EQU MBAR_MEM+$48 (no usado en esta parte) ORG $MMMMMMMM ; RAM interna CONT DS.L 1 STD1..STD4 DS.L 1 (×4) ESTADO DS.B 1 BUFFER DS.B N_MUESTRAS ; N_MUESTRAS = 1000 PILA DS.B TAMPILA ORG $30000000 ; ADC + pulsador ADC DS.B 1 PULSADOR DS.B 1 ORG $10000000 ; pantalla, CS2# PANTALLA DS.L $TTTTTTTT INICIO MOVE.L #$00000201,D0 MOVE.L D0,CSBR0 ; CSBR0 ya viene fijado

1.1 — Completa el mapa de memoria

0/5
Ver explicación — por qué es ese rango
  • EPROM ($00000000–$0001FFFF): el diagrama indica "EPROM 16 bits, 128 KB" sin fijar su base, así que se asigna la dirección más baja posible, $00000000. 128 KB = $20000 bytes → último byte en $0001FFFF.
  • RAM interna ($00020000–$00020FFF): CONT, STD1-STD4, ESTADO, BUFFER (N_MUESTRAS=1000) y PILA se declaran en la RAM interna (tras ORG $MMMMMMMM), que es siempre de 4 KB fijos. Como la EPROM ya ocupa hasta $0001FFFF, la siguiente dirección libre más baja para ese bloque de 4 KB es $00020000.
  • ADC + pulsador ($30000000–$30000001): el listado fija ORG $30000000; ADC DS.B 1 y PULSADOR DS.B 1 ocupan, en orden, $30000000 y $30000001.
  • Módulo SIM ($20000000–$2000FFFF): MBAR_MEM EQU $20000000 fija la base; la ventana de registros internos es siempre de 64 KB.
  • Pantalla ($10000000–$1000FFFF): el listado fija ORG $10000000 y el enunciado dice que la pantalla se comporta como una memoria de 64 KB (de solo escritura) → $10000000-$1000FFFF.

1.2 — A partir de CSBR0=$00000201, calcula CSOR0 (30 estados de espera)

0/5
Ver justificación completa
  • CSBR0=$00000201 (dado) → BA=$00000, EBI=00 (16/32 bits), BW=10 (puerto de 16 bits), SUPER=0, ENABLE=1.
  • CSOR0=$FFFE0079 → BAM=$FFFE0 (128 KB = 2^17, se comparan los 15 bits superiores); WS=%11110=30; RW=0; MRW=1 (solo lectura).
  • Mapa: EPROM $00000000-$0001FFFF · RAM interna $00020000-$00020FFF · ADC/pulsador $30000000-$30000001 · SIM $20000000-$2000FFFF · Pantalla $10000000-$1000FFFF.
Práctica ilimitada

Configura CSBRn / CSORn para un dispositivo nuevo

Generando enunciado…

0/11 Aciertos totales: 0
Ver solución y justificación
    Práctica ilimitada

    Configura RAMBAR para la RAM interna

    Ojo con la trampa clásica: en SC/SD/UC/UD, el 1 prohíbe el acceso y el 0 lo permite — al revés de lo que parece a primera vista.

    Generando enunciado…

    0/9
    Ver solución y justificación
      Referencia

      Modos de direccionamiento

      Esto no está en la hoja de referencia del examen, así que conviene tenerlo claro. f,d = fuente/destino · dspB = desplazamiento de B bits, rango [-2^(B-1), 2^(B-1)-1].

      ModoSintaxisDirección efectivaEjemplo
      Directo a registroDn / AnEA = ese registroMOVE.W D2,D4
      Inmediato#nel operando va en la instrucción (no hay EA)MOVEQ.L #-16,D5
      AbsolutoEAla dirección va explícita en la instrucciónMOVE.B D1,$1C8
      Indirecto(An)EA = (An)MOVE.B (A1),$2CE
      Indirecto con postincremento(An)+EA = (An); An += tamaño. Para extraer de la pilaMOVE.W (A3)+,D4
      Indirecto con predecremento-(An)An -= tamaño; EA = (An) ya decrementado. Para meter en la pilaMOVE.L D0,-(A7)
      Con desplazamientoN(An)EA = (An) + N  ·  N = dsp16MOVE.L 8(A0),D0
      Indexado con escalaN(An,Rm*s)EA = (An) + (Rm)×s + N  ·  N = dsp8, s∈{1,2,4}MOVE.W 8(A0,D1.L*4),D0
      Relativo a PCN(PC)EA = (PC) + N  ·  solo como fuenteLEA 6(PC),A0
      Práctica ilimitada

      Calcula la dirección efectiva

      Generando enunciado…

      —
      Ver desarrollo

      Convenciones de pila (PEA, MOVEM, LINK/UNLK)

      Tampoco está en la hoja de referencia — es lo que necesitas para rastrear el contenido de la pila en cualquier ejercicio de software.

      • MOVE.L valor,-(A7) → apila el valor (4 bytes); MOVE.L (A7)+,Dn lo desapila.
      • PEA etiqueta → apila la dirección de la etiqueta (4 bytes), no su contenido.
      • JSR / BSR → apilan el PC de retorno antes de saltar (JSR admite cualquier modo; BSR es siempre relativo a PC). RTS lo desapila al volver.
      • ADDA.L #-N,A7 al entrar en una subrutina → reserva N bytes de variables locales; ADDA.L #N,A7 los libera antes del RTS.
      • MOVEM.L regs,(A7) guarda varios registros siempre en el mismo orden D0…D7, A0…A7, sin importar el orden en que los escribas en la instrucción.
      • LINK An,#-m ≈ apila An (4 bytes), copia A7 en An, reserva m bytes más; UNLK An lo deshace.
      • Interrupción → el procesador apila 8 bytes: PC (4), SR (2) y formato/vector VF (2), en ese orden; VF queda en la dirección más baja. RTE los desapila.
      • N(A7) dentro de una subrutina: cuenta los bytes desde el A7 actual. Recién entrado, 0(A7) es el PC de retorno y 4(A7) el último parámetro apilado; cada byte que apiles después desplaza esas distancias.
      Examen real · Nov-2015 (Pulsómetro)

      Contenido de la pila durante una llamada a subrutina

      PROGRAMA PRINCIPAL PROCESA_FCARD ADDA.L #-16,A7 PEA FREC_CARD MOVEM.L D0-D2/A0,(A7) BSR PROCESA_FCARD ──llama──▶ LEA BUFFER_PULSO,A0 ; punto M, justo aquí ADDA.L #4,A7 ...

      El programa principal apila primero la dirección de FREC_CARD (parámetro) con PEA, y luego BSR apila el PC de retorno. Dentro de la subrutina, ADDA.L #-16,A7 reserva 16 bytes y MOVEM.L D0-D2/A0,(A7) guarda 4 registros (D0,D1,D2,A0 = 16 bytes) en ese hueco.

      —
      Ver pila completa, de arriba (A7 actual) a abajo (A7 inicial)
      1. D0 (4 bytes) — guardado por MOVEM
      2. D1 (4 bytes) — guardado por MOVEM
      3. D2 (4 bytes) — guardado por MOVEM
      4. A0 (4 bytes) — guardado por MOVEM
      5. PC de retorno (4 bytes) — apilado por el BSR
      6. Dirección de FREC_CARD (4 bytes) — apilada por el PEA del programa principal

      Total: 24 bytes entre el A7 actual (en el punto M) y el A7 inicial del programa principal.

      Práctica ilimitada

      Ocupación de la pila en una llamada a subrutina

      Generando enunciado…

      —
      Ver desglose
        Práctica ilimitada

        Dimensionar la pila: A7 inicial y TAMPILA

        Dos trampas típicas: el A7 inicial es la última dirección de la RAM + 1 (no el último byte, y las variables no se restan aquí); TAMPILA sale de restar al tamaño total de la RAM los bytes que ya ocupan las variables.

        Generando enunciado…

        0/2
        Ver desarrollo
          Práctica ilimitada · como Nov-2017 3.1 y ejercicio 1-casa 1.3

          Dibuja el contenido de la pila en el punto M

          Cada fila es una palabra (2 bytes); las direcciones más bajas van arriba. Un dato de 4 bytes ocupa dos filas con la misma etiqueta. Marca (libre) las filas que quedan por encima de A7.

          —
          Ver pila resuelta
          De dónde sale esto

          Leer y entender código

          Ejercicios generados con la misma forma que las cuestiones de las Unidades 2 y 3 y los problemas 2.1 y 2.2: directivas, tamaños de MOVE, operaciones lógicas y desplazamientos, CCR, saltos con y sin signo, direccionamiento indirecto, C con enteros y punteros, y líneas del bus de datos. Usa la calculadora para pasar de base; lo que cuenta es entender qué hace cada instrucción.

          Práctica ilimitada

          Trazar un bucle en ensamblador

          (A0)+ es el contenido de esa dirección (no la dirección); la inicialización del registro va fuera del bucle.

          0/2
          Ver desarrollo

          Práctica ilimitada

          Análisis de C: valor vs. referencia

          Un parámetro sin & es una copia local — cambiarlo dentro de la función no afecta a la variable del main. Un puntero (int *p, llamado con &x) sí permite modificar la variable original a través de *p.

          0/2
          Ver traza paso a paso
            Examen de octubre 2026 · reconstruido

            Caja registradora con báscula

            Todos los apartados de los PDF ExamenSDG1 Oct-26 y Notas y solucionario. Se corrigen solos salvo las partes abiertas, donde comparas con la solución y te autoevalúas. Tus respuestas se guardan en este navegador.

            Es una reconstrucción a partir de un resumen manuscrito: direcciones, tabla de productos y datos de la primera iteración son inventados por su autor, y los pesos son orientativos. La hoja de información del MCF5272 no se repite aquí; usa la tuya o la pestaña Resumen.

            Nota: 0,00 / 10 Corregidos: 0 / 10
            MBAR/RAMBARCSBR/CSORPilaProblemas U2Conceptos clave
            Pregunta 1 / 14 Aciertos: 0