Lezione 5 di 43

Lezione 04

🎓 PIC16 — From Zero to Hero · Lezione 04

Aritmetica a 8 bit ➕➖

ADDLW ADDWF SUBLW SUBWF
Somme, sottrazioni e i tre flag C, DC, Z.

🎯 Cosa impari in questa lezione

ADDLW k — somma una costante a W
ADDWF f,d — somma W con un registro RAM
SUBLW k — sottrae W da una costante (k - W)
SUBWF f,d — sottrae W da un registro RAM (f - W)
Come funziona il flag C in addizione e sottrazione
Cos’è il flag DC (Digit Carry) e quando serve
L’overflow a 8 bit e come gestirlo

📋 Scheda lezione

Modulo	1 — Assembly Base
Lezione	04 di 42
Livello	⭐⭐ Principiante+
Tempo	~30 minuti
Istruzioni	4 nuove
Flag STATUS	C, DC, Z

🔢 Aritmetica a 8 bit — il confine è 255

Il registro W e tutti i registri RAM del PIC16 sono a 8 bit: possono contenere valori da 0x00 (0) a 0xFF (255). Cosa succede se il risultato di una somma supera 255? Il risultato si tronca a 8 bit e il carry viene registrato nel flag C.

1 DC = 0 Z = 0 il nono bit è andato nel flag C Digit Carry 0x08 + 0x09 = 0x11 (17) C = 0 DC = 1 Z = 0 riporto dal nibble basso (bit 3→4)

Figura 1 — I tre casi: normale, overflow carry, digit carry

🔴 Flag C — Carry

In addizione: vale 1 se il risultato supera 255 (il bit 8 “trabocca”).
In sottrazione: vale 1 se non c’è borrow (risultato ≥ 0), 0 se c’è borrow (risultato negativo). Attenzione — è il contrario dell’intuizione!

🟠 Flag DC — Digit Carry

Riporto dal nibble basso (bit 3) al nibble alto (bit 4). Usato nell’aritmetica BCD (Binary Coded Decimal) per correggere il risultato. Nel codice normale lo ignorerai quasi sempre — ma il simulatore lo mostra comunque.

🟣 Flag Z — Zero

Vale 1 se il risultato (dopo la troncatura a 8 bit) è esattamente 0. Utile per rilevare quando due valori sono uguali: A - B = 0 significa A = B. È la base dei confronti.

① ADDLW k — somma costante a W

Sintassi

ADDLW k

Operazione

W + k → W

Flag

C · DC · Z

Cicli

Somma la costante k (0–255) al registro W e mette il risultato in W. I tre flag C, DC e Z vengono aggiornati in base al risultato.

MOVLW 0x30 ; W = 0x30
ADDLW 0x20 ; W = 0x50, C=0, DC=0, Z=0

MOVLW 0xF0 ; W = 0xF0
ADDLW 0x20 ; W = 0x10, C=1 (overflow!)

MOVLW 0xFE ; W = 0xFE = 254
ADDLW 0x02 ; W = 0x00, C=1, Z=1 (254+2=256, troncato a 0)

💡 L’ultimo esempio è interessante: 0xFE + 0x02 = 256, che a 8 bit diventa 0x00. Il risultato è zero (Z=1) e c’è stato carry (C=1) contemporaneamente. Nel simulatore puoi vedere entrambi i flag settati.

② ADDWF f,d — somma W con un registro RAM

Sintassi

ADDWF f,d

Operazione

W + f → dest

Flag

C · DC · Z

Cicli

Somma W con il registro f. La destinazione d decide dove va il risultato: W (d=0) oppure F (d=1, rimane in f). È la versione “registro con registro” dell’addizione.

CONTA EQU 0x0C
TOTALE EQU 0x0D

; ADDWF con d=W: risultato in W, f invariato
MOVLW 0x0A ; W = 10
MOVWF CONTA ; CONTA = 10
MOVLW 0x05 ; W = 5
ADDWF CONTA, W ; W = 5+10 = 15, CONTA = 10 (invariato)

; ADDWF con d=F: risultato in f, W invariato
MOVLW 0x05 ; W = 5
ADDWF CONTA, F ; CONTA = 10+5 = 15, W = 5 (invariato)

; Incremento diretto di una variabile (CONTA += 1)
MOVLW 0x01
ADDWF CONTA, F ; CONTA = CONTA + 1

③ SUBLW k — sottrai W da una costante

Sintassi

SUBLW k

Operazione

k − W → W

Flag

C · DC · Z

Cicli

Attenzione alla direzione: è k meno W, non W meno k. Il risultato va in W. È usata meno frequentemente di SUBWF, ma utile quando si vuole calcolare il “complemento” rispetto a una costante.

⚠️ Il flag C in sottrazione — logica invertita

Nel PIC16 (come nella maggior parte delle CPU a 8 bit), il flag C in sottrazione è il complemento del borrow:

C = 1 se il risultato è ≥ 0 (nessun borrow, sottrazione “va bene”)
C = 0 se il risultato è < 0 (c’è borrow, il sottraendo era più grande)

Sembra controintuitivo, ma ha senso implementativo: la sottrazione viene eseguita come addizione del complemento a 2, e il carry di quell’addizione diventa il flag C.

; k=10, W=3 → risultato = 10-3 = 7 ≥ 0 → C=1
MOVLW 0x03 ; W = 3
SUBLW 0x0A ; W = 10-3 = 7, C=1, Z=0

; k=5, W=5 → risultato = 0 → C=1, Z=1
MOVLW 0x05 ; W = 5
SUBLW 0x05 ; W = 5-5 = 0, C=1, Z=1

; k=3, W=10 → risultato = 3-10 = -7 (borrow!) → C=0
MOVLW 0x0A ; W = 10
SUBLW 0x03 ; W = 3-10 → 0xF9 (249), C=0 (borrow!)

④ SUBWF f,d — sottrai W da un registro RAM

Sintassi

SUBWF f,d

Operazione

f − W → dest

Flag

C · DC · Z

Cicli

La più usata tra le sottrazioni: f meno W. Stessa logica del flag C: vale 1 se il risultato è ≥ 0. Il pattern tipico è caricare il sottraendo in W con MOVLW, poi usare SUBWF.

VALORE EQU 0x0C
DIFF EQU 0x0D

; VALORE = 20, calcolo VALORE – 7
MOVLW 0x14 ; W = 20
MOVWF VALORE ; VALORE = 20
MOVLW 0x07 ; W = 7 (il sottraendo va in W)
SUBWF VALORE, W ; W = 20-7 = 13, C=1, VALORE invariato
MOVWF DIFF ; DIFF = 13

; Decremento diretto (VALORE -= 1)
MOVLW 0x01
SUBWF VALORE, F ; VALORE = VALORE – 1

; Confronto: VALORE == 10?
MOVLW 0x0A ; W = 10
SUBWF VALORE, W ; W = VALORE – 10
; Z=1 se VALORE==10, Z=0 altrimenti

💡 Pattern confronto: MOVLW valore / SUBWF variabile, W è il modo standard per confrontare una variabile con una costante. Se Z=1 i valori sono uguali. Nelle prossime lezioni lo combineremo con BTFSC/BTFSS per fare branch condizionali.

📊 Riepilogo — le 4 istruzioni a confronto

Istruzione	Operazione	Destinazione	C	DC	Z
`ADDLW k`	W + k	W	✅	✅	✅
`ADDWF f,W`	W + f	W	✅	✅	✅
`ADDWF f,F`	W + f	f	✅	✅	✅
`SUBLW k`	k − W	W	✅ (inv.)	✅	✅
`SUBWF f,W`	f − W	W	✅ (inv.)	✅	✅
`SUBWF f,F`	f − W	f	✅ (inv.)	✅	✅

✅ (inv.) = C è invertito rispetto all’intuizione: vale 1 se il risultato è ≥ 0, vale 0 se c’è borrow.

🔍 Visualizzare i flag nel simulatore

Il registro STATUS è all’indirizzo 0x03. Nel pannello registri del simulatore lo vedi aggiornato in tempo reale dopo ogni istruzione. I bit che ci interessano ora sono i tre bassi:

Figura 2 — Registro STATUS dopo MOVLW 0x05 / ADDLW 0x05: risultato 0x0A, DC=1 (riporto nibble), C=0, Z=0

💻 Programma — esplora tutti i casi

Carica questo programma e usa Step per eseguirlo istruzione per istruzione. Per ogni operazione annota i valori di W, C, DC e Z — poi confronta con la tabella soluzione.

; ; ; ; A B ; ; FINE ============================================
Lezione 04 — Aritmetica e flag
Prof. D.Bertolino · WebPicSimulator
============================================
LIST p=16F84A
#include <p16f84a.inc>
EQU 0x0C
EQU 0x0D
ORG 0x00

— Addizioni —
MOVLW 0x30 ; W=0x30
ADDLW 0x20 ; [1] W=? C=? Z=?

MOVLW 0xF0 ; W=0xF0
ADDLW 0x20 ; [2] W=? C=? Z=? (overflow!)

MOVLW 0xFE ; W=0xFE
ADDLW 0x02 ; [3] W=? C=? Z=? (overflow+zero!)

MOVLW 0x14 ; W=20
MOVWF A ; A=20
MOVLW 0x06 ; W=6
ADDWF A, F ; [4] A=? W=? C=?

— Sottrazioni —
MOVLW 0x0A ; W=10
SUBLW 0x1E ; [5] W=? C=? (30-10)

MOVLW 0x1E ; W=30
SUBLW 0x0A ; [6] W=? C=? (10-30, borrow!)

MOVLW 0x14 ; W=20
MOVWF B ; B=20
MOVLW 0x14 ; W=20
SUBWF B, W ; [7] W=? C=? Z=? (B-W, 20-20)

GOTO FINE
END

Mostra soluzione — risultati attesi

#	Istruzione	W	C	DC	Z	Note
1	`ADDLW 0x20`	0x50	0	0	0	0x30+0x20=0x50, nessun overflow
2	`ADDLW 0x20`	0x10	1	0	0	0xF0+0x20=0x110, troncato a 0x10
3	`ADDLW 0x02`	0x00	1	0	1	0xFE+0x02=0x100 → 0, C=1 e Z=1 insieme
4	`ADDWF A,F`	6	0	0	0	A=20+6=26=0x1A, W invariato a 6
5	`SUBLW 0x1E`	0x14	1	1	0	30-10=20=0x14, C=1 (no borrow)
6	`SUBLW 0x0A`	0xEC	0	0	0	10-30=-20 → 0xEC (complemento a 2), C=0 (borrow!)
7	`SUBWF B,W`	0x00	1	1	1	B-W=20-20=0, C=1 (no borrow), Z=1

🏋️ Prova tu!

Scrivi una sequenza che calcola 100 - 37 e salva il risultato in una variabile RIS. Verifica nel simulatore che RIS = 63 = 0x3F e C=1.
Aggiungi al programma precedente una seconda operazione: RIS + 200. Il risultato supera 255? Cosa vale C?
Sfida: come fai a calcolare A - B (entrambe variabili in RAM) e mettere il risultato in una terza variabile DIFF? Scrivi la sequenza completa.

💡 Per l’esercizio 3: ricorda che SUBWF calcola f - W. Prima devi caricare B in W, poi eseguire SUBWF A, W — oppure trovare un altro percorso.

❓ Quiz rapido

1. MOVLW 0xFF / ADDLW 0x01: quanto vale W? E il flag C?

Mostra risposta

W = 0x00 (255+1=256, troncato a 0). C = 1 (overflow). Z = 1 (risultato zero). Tre flag settati in una sola addizione.

2. Dopo MOVLW 0x05 / SUBLW 0x03 (cioè 3−5), quanto vale C?

Mostra risposta

C = 0. Il risultato è 3−5 = −2 (borrow): nel PIC16 C=0 indica che c’è stato borrow, cioè che il risultato è negativo. W conterrà 0xFE (complemento a 2 di −2).

3. Qual è la differenza tra ADDLW k e ADDWF f,W?

Mostra risposta

ADDLW k somma W con una costante scritta nel codice. ADDWF f,W somma W con il contenuto attuale del registro f in RAM — un valore che può cambiare durante l’esecuzione.

4. Voglio verificare se la variabile CONTA è uguale a 50. Come scrivo il test senza modificare CONTA?

Mostra risposta

MOVLW 0x32 (50 in esadecimale) poi SUBWF CONTA, W. Il risultato va in W (CONTA rimane intatta). Se Z=1, CONTA era uguale a 50.

Prossima lezione →

Lezione 05 — Operazioni logiche
ANDLW, ANDWF, IORLW, IORWF, XORLW, XORWF
Mascherare bit, settare flag, confrontare nibble.