Sistemi E Reti

Il Count Register

Stampa WhatsApp Email

Il registro contatore CX e l'uso dell'istruzione LOOP per implementare cicli iterativi in Assembly 8086, essenziale per l'esecuzione ripetuta di blocchi di codice.

Durata

PT50M

Software

emu8086

1 Il Registro CX: Il Contatore in Assembly

Tra i registri a scopo generale dell'architettura 8086, il registro CX (Counter Register, Registro Contatore) ha un ruolo specializzato e fondamentale: è dedicato alla gestione dei cicli iterativi.

  • Dimensioni: Come gli altri registri generali, è a 16 bit, diviso nelle parti CH (High - 8 bit) e CL (Low - 8 bit).
  • Ruolo Principale: Quando la CPU deve eseguire ripetutamente un blocco di codice per un numero preciso di volte (l'equivalente di un ciclo for nei linguaggi di alto livello), si aspetta che il numero di ripetizioni sia contenuto in CX.
  • Inizializzazione: Prima di avviare il ciclo, è necessario caricare in CX il numero totale di iterazioni desiderate (es. MOV CX, 10 per dieci ripetizioni).

2 L'Istruzione LOOP: Il Ciclo Automatico

Nei linguaggi di alto livello, la gestione del ciclo e del contatore (incremento, decremento, test della condizione) è automatica. In Assembly, è gestita esplicitamente, ma l'istruzione LOOP semplifica notevolmente questo processo.

L'istruzione LOOP unisce tre operazioni fondamentali in un'unica riga:

  1. Decremento Automatico: Il valore contenuto in CX viene automaticamente decrementato di 1 (CX = CX - 1).
  2. Test della Condizione: Viene verificato se il nuovo valore di CX è diverso da zero.
  3. Salto: Se CX è diverso da zero, il flusso di esecuzione salta all'etichetta (label) specificata nell'istruzione LOOP.

La sintassi è: LOOP Etichetta. L'esecuzione del ciclo termina quando CX raggiunge il valore zero.

3 Struttura di un Ciclo LOOP

Un ciclo ben strutturato in Assembly richiede tre elementi:

  1. Inizializzazione del Contatore: Impostare CX al numero di ripetizioni desiderato. 
    
MOV CX, N_ITERAZIONI
  2. Etichetta d'inizio Ciclo: Un'etichetta (es. INIZIO_CICLO:) che definisce il punto dove l'istruzione LOOP farà il salto.
  3. Istruzione LOOP: Posizionata alla fine del blocco di codice da ripetere.

Attenzione: È essenziale che l'etichetta del ciclo sia definita prima del blocco di codice che deve essere ripetuto. 


ORG 100h

MOV CX, 5        ; Ripeti il ciclo 5 volte
MOV AX, 0        ; Inizializza l'accumulatore (risultato)

INIZIO_CICLO:
    ADD AX, 10   ; Corpo del ciclo: Aggiunge 10 ad AX
    LOOP INIZIO_CICLO ; CX--. Se CX != 0, salta a INIZIO_CICLO

RET
LABORATORIO

Esercizio Guidato: Implementare una Moltiplicazione tramite Somme Ripetute

Poiché il microprocessore 8086 esegue le moltiplicazioni (MUL) in modo complesso, simuleremo la moltiplicazione $5 \times 4$ eseguendo la somma del numero 5 per 4 volte, utilizzando il registro CX per il conteggio.

1 Inizializzazione e Setup del Codice

Prepariamo l'ambiente caricando i valori iniziali nei registri AX e CX.

  1. Aprire emu8086 e creare un nuovo programma .COM.
  2. Definire l'obiettivo ($5 \times 4$): il numero da sommare è 5 (memorizzato in BX) e il numero di ripetizioni è 4 (memorizzato in CX). AX è il nostro accumulatore, inizializzato a zero.
    3. 
ORG 100h

; -- Dati di Input --
MOV BX, 5        ; Moltiplicando: il valore da sommare (5)
MOV CX, 4        ; Moltiplicatore: numero di ripetizioni (4)

; -- Inizializzazione --
MOV AX, 0        ; Accumulatore del risultato (AX = 0)

CICLO_MOLT:      ; Etichetta di inizio ciclo
    ; Qui andremo a sommare BX ad AX
    
    ; Qui inseriremo l'istruzione LOOP
    
RET
  3. Compilare e iniziare l'esecuzione in modalità "Single Step" per verificare le inizializzazioni (AX=0, BX=5, CX=4).

2 Implementazione e Tracciamento del Ciclo LOOP

Aggiungiamo le istruzioni ADD e LOOP e tracciamo l'esecuzione.

  1. Inserire le istruzioni all'interno dell'etichetta CICLO_MOLT:
    2. 
ORG 100h

MOV BX, 5       
MOV CX, 4        
MOV AX, 0        

CICLO_MOLT:      
    ADD AX, BX   ; Operazione: AX = AX + BX (Somma 5 ad AX)
    
    LOOP CICLO_MOLT ; Decrementa CX, Salta se CX != 0
    
RET
  2. Ricompilare e avviare l'Emulatore.
  3. Utilizzare "Single Step" e osservare i registri:
    • Iterazione 1: ADD AX, BX (AX diventa 5). LOOP (CX diventa 3). Salta.
    • Iterazione 2: ADD AX, BX (AX diventa 10). LOOP (CX diventa 2). Salta.
    • Iterazione 3: ADD AX, BX (AX diventa 15). LOOP (CX diventa 1). Salta.
    • Iterazione 4: ADD AX, BX (AX diventa 20). LOOP (CX diventa 0). Non Salta! Il programma prosegue con RET.
  4. Verifica: Il risultato finale (20 Decimale) è contenuto in AX.

3 Esercizio: Creazione di Ritardi

I cicli sono spesso usati nei sistemi embedded per creare ritardi temporizzati. Un ritardo si ottiene eseguendo un ciclo che non fa nulla di significativo al suo interno.

Scrivere un programma che esegue un "Ciclo Vuoto" 5000 volte.

  1. Impostare CX al valore 5000.
  2. Creare un'etichetta (es. DELAY:).
  3. L'unica istruzione all'interno del ciclo deve essere LOOP DELAY.
    4. 
ORG 100h

MOV CX, 5000

DELAY:
    ; Nessuna istruzione qui (ciclo vuoto)
    LOOP DELAY
    
RET
  4. Eseguire e osservare quanto velocemente (o lentamente) il CX si decrementa, specialmente in modalità "Single Step" o "Run" normale.



Assembly, 8086, CX Register, LOOP, Cicli, Programmazione Basso Livello, emu8086,