Lezione 6 di 43

Lezione 05

🎓 PIC16 — From Zero to Hero · Lezione 05

Operazioni logiche 🔀

ANDLW ANDWF IORLW IORWF XORLW XORWF
Mascherare bit, accendere pin, fare toggle — tre pattern che usi ogni giorno.

🎯 Cosa impari in questa lezione

Come funzionano AND, OR, XOR bit per bit su 8 bit
ANDLW/ANDWF — mascherare (isolare) bit specifici
IORLW/IORWF — settare bit specifici a 1 senza toccare gli altri
XORLW/XORWF — invertire (toggle) bit specifici
I tre pattern fondamentali: mask · set · toggle
Perché queste istruzioni modificano solo il flag Z (mai C né DC)

📋 Scheda lezione

Modulo	1 — Assembly Base
Lezione	05 di 42
Livello	⭐⭐ Principiante+
Tempo	~25 minuti
Istruzioni	6 nuove
Flag STATUS	Z soltanto

🧠 Tre operazioni, tre scopi precisi

Le operazioni logiche lavorano bit per bit: ogni bit del primo operando viene combinato con il bit corrispondente del secondo, indipendentemente dagli altri. Il risultato ha sempre 8 bit. Niente carry, niente overflow — solo Z se il risultato è 0x00.

Figura 1 — Tavole di verità: AND azzera, OR setta, XOR inverte

① AND — isolare bit (mascheratura)

Sintassi

ANDLW k

Operazione

W AND k → W

Sintassi

ANDWF f,d

Operazione

W AND f → dest

Flag

Z soltanto

AND è la maschera: i bit a 0 nella maschera “spengono” i bit corrispondenti nel risultato, i bit a 1 li “lasciano passare” invariati. Usatissimo per estrarre il nibble basso, ignorare bit di stato, testare singoli bit.

; Estrarre nibble basso (bit 3..0)
MOVF PORTB, W ; W = stato PORTB
ANDLW 0x0F ; W = W AND 0x0F → bit 7..4 azzerati

; Estrarre nibble alto (bit 7..4)
MOVF PORTB, W
ANDLW 0xF0 ; W = W AND 0xF0 → bit 3..0 azzerati

; Testare se i bit 1 e 0 di una variabile sono entrambi 0
FLAGS EQU 0x0C
MOVF FLAGS, W
ANDLW b’00000011′ ; isola bit 1 e bit 0
; Z=1 se entrambi erano 0

💡 Regola pratica AND: metti 1 nella maschera dove vuoi vedere il bit originale, metti 0 dove vuoi azzerarlo. Se dopo l’AND il risultato è 0 (Z=1), tutti i bit di interesse erano a 0.

② OR — settare bit a 1

Sintassi

IORLW k

Operazione

W OR k → W

Sintassi

IORWF f,d

Operazione

W OR f → dest

Flag

Z soltanto

OR è il setter: i bit a 1 nella maschera forzano a 1 i bit corrispondenti nel risultato, i bit a 0 lasciano invariato ciò che c’era. Usato per accendere LED, abilitare periferiche, settare flag di stato.

; Accendere RB7, RB6 e RB0 senza toccare gli altri bit
MOVF PORTB, W
IORLW b’11000001′ ; OR forza a 1 i bit 7, 6 e 0
MOVWF PORTB

; Settare il bit GIE (bit 7 di INTCON) per abilitare interrupt
MOVF INTCON, W
IORLW b’10000000′ ; setta GIE, lascia tutto il resto invariato
MOVWF INTCON

; Alternativa più compatta con IORWF direttamente su RAM
MOVLW 0x80
IORWF INTCON, F ; INTCON |= 0x80 (stesso risultato, 2 istruzioni)

💡 Regola pratica OR: metti 1 nella maschera dove vuoi forzare a 1, metti 0 dove vuoi lasciare invariato. OR non può mai mettere un bit a 0 — usa AND per quello.

③ XOR — invertire bit (toggle)

Sintassi

XORLW k

Operazione

W XOR k → W

Sintassi

XORWF f,d

Operazione

W XOR f → dest

Flag

Z soltanto

XOR è il toggle: i bit a 1 nella maschera invertono il bit corrispondente (0→1 o 1→0), i bit a 0 lasciano invariato. Perfetto per il lampeggio LED: basta fare XOR con la stessa maschera ogni volta.

XOR ha anche una proprietà speciale: A XOR A = 0. Se fai XOR di un registro con sé stesso ottieni zero. Questa è la forma più veloce per azzerare W (anche se CLRW è più leggibile).

; Toggle di RB0 — lampeggio LED ogni volta che esegui questo codice
MOVLW 0x01 ; maschera: solo RB0
XORWF PORTB, F ; RB0 cambia stato ad ogni esecuzione

; Toggle di tutti i pin PORTB (tutti cambiano insieme)
MOVLW 0xFF
XORWF PORTB, F ; alternativa ON/OFF totale

; Confronto: A == B? (XOR → Z=1 se uguali)
MOVF VALORE_A, W
XORWF VALORE_B, W ; Z=1 se A==B (tutti i bit coincidono)

; Azzerare W con XOR (trucco accademico)
XORLW 0xFF ; W = complemento di W
XORLW 0xFF ; W = W originale (doppio XOR = identità)

🔍 XOR come confronto: A XOR B = 0 (Z=1) se e solo se A e B sono identici bit per bit. È un modo rapido per confrontare due byte senza usare la sottrazione — e senza toccare C né DC.

📊 I tre pattern — riepilogo visivo

Figura 2 — I tre pattern logici: mask (AND), set (OR), toggle (XOR)

Istruzione	Operazione	dest	C	DC	Z	Uso tipico
`ANDLW k`	W AND k	W	—	—	✅	maschera costante
`ANDWF f,d`	W AND f	W o f	—	—	✅	maschera su registro
`IORLW k`	W OR k	W	—	—	✅	setta bit con costante
`IORWF f,d`	W OR f	W o f	—	—	✅	setta bit su registro
`XORLW k`	W XOR k	W	—	—	✅	toggle, confronto
`XORWF f,d`	W XOR f	W o f	—	—	✅	toggle su registro

— = flag non modificato dall’istruzione. Nessuna delle sei istruzioni modifica C o DC.

💻 Programma — i tre pattern in azione

; ; ; ; REG ; ; ; ; FINE ============================================
Lezione 05 — AND, OR, XOR
Prof. D.Bertolino · WebPicSimulator
============================================
LIST p=16F84A
#include <p16f84a.inc>
EQU 0x0C
ORG 0x00

— Pattern AND (MASK) —
MOVLW 0xB6 ; W = 1011 0110
ANDLW 0x0F ; [1] W=? Z=? (nibble basso)

MOVLW 0xB6
ANDLW 0xF0 ; [2] W=? Z=? (nibble alto)

MOVLW 0x00
ANDLW 0xFF ; [3] W=? Z=? (AND con tutti 1)

— Pattern OR (SET) —
MOVLW 0x2C ; W = 0010 1100
IORLW 0xC1 ; [4] W=? Z=? (set RB7, RB6, RB0)

MOVLW 0xB6
MOVWF REG
MOVLW 0x40
IORWF REG, F ; [5] REG=? (setta bit 6, W=0x40 invariato)

— Pattern XOR (TOGGLE) —
MOVLW 0xAA ; W = 1010 1010
XORLW 0xFF ; [6] W=? Z=? (complemento)

MOVLW 0x3C ; W = 0011 1100
XORLW 0x3C ; [7] W=? Z=? (XOR con sé stesso)

Confronto A==B con XOR
MOVLW 0x42
MOVWF REG
MOVF REG, W
XORLW 0x42 ; [8] Z=? (REG == 0x42?)

GOTO FINE
END

Mostra soluzione

#	Istruzione	W	REG	Z	Note
1	`ANDLW 0x0F`	0x06	—	0	0xB6 AND 0x0F = 0x06 (nibble basso)
2	`ANDLW 0xF0`	0xB0	—	0	0xB6 AND 0xF0 = 0xB0 (nibble alto)
3	`ANDLW 0xFF`	0x00	—	1	0x00 AND 0xFF = 0x00 — Z=1!
4	`IORLW 0xC1`	0xED	—	0	0x2C OR 0xC1 = 0xED
5	`IORWF REG,F`	0x40	0xF6	0	0xB6 OR 0x40 = 0xF6 (bit 6 settato)
6	`XORLW 0xFF`	0x55	—	0	0xAA XOR 0xFF = 0x55 (complemento)
7	`XORLW 0x3C`	0x00	—	1	0x3C XOR 0x3C = 0x00 — Z=1!
8	`XORLW 0x42`	0x00	0x42	1	0x42 XOR 0x42 = 0 → Z=1 (sono uguali)

🏋️ Prova tu!

Hai una variabile STATO che vale 0xA7. Scrivi una sequenza che azzera i bit 7 e 5 senza toccare gli altri. Qual è la maschera AND da usare? Quanto vale STATO dopo?
Partendo da PORTB = 0x00, accendi solo i LED sui pin pari (RB6, RB4, RB2, RB0) usando una singola operazione OR. Quale valore usi come maschera?
Sfida: scrivi un mini-programma che usa XOR per fare lampeggiare solo i bit dispari di PORTB (RB7, RB5, RB3, RB1). Il ciclo deve usare GOTO per ripetersi — prova a mettere un NOP tra i toggle per simulare un ritardo visivo nello step.

💡 Esercizio 1: una maschera AND che azzera bit 7 e bit 5 deve avere quei due bit a 0 e tutti gli altri a 1. Scrivi il byte in binario — è più facile trovare il valore.

❓ Quiz rapido

1. Voglio settare il bit 3 di PORTB a 1 senza toccare gli altri. Quale istruzione uso e con quale maschera?

Mostra risposta

MOVLW b'00001000' (0x08) poi IORWF PORTB, F. OR con 0x08: solo il bit 3 viene forzato a 1, tutti gli altri rimangono invariati.

2. Dopo MOVLW 0x55 / ANDLW 0xAA quanto vale W e quanto vale Z?

Mostra risposta

0x55 = 0101 0101, 0xAA = 1010 1010. AND di due byte con bit complementari = 0000 0000 = 0x00. W = 0x00, Z = 1. Non hanno nessun bit in comune!

3. Le istruzioni logiche modificano C o DC?

Mostra risposta

No — AND, OR e XOR modificano solo Z. Non c’è concetto di carry o digit carry nelle operazioni logiche (non c’è “9 + 1 = 10” bit per bit). C e DC rimangono al valore che avevano prima.

4. Come faccio a azzerare il bit 4 di un registro RAM senza toccare gli altri bit?

Mostra risposta

AND con una maschera che ha il bit 4 a 0 e tutti gli altri a 1: b'11101111' = 0xEF. Sequenza: MOVLW 0xEF / ANDWF REGISTRO, F. (In alternativa, nella prossima lezione vedrai BCF REGISTRO, 4 che fa esattamente questo in una sola istruzione.)

Prossima lezione →

Lezione 06 — Rotazioni e SWAPF
RLF, RRF, COMF, SWAPF — spostare bit,
invertire byte, scambiare nibble attraverso il Carry.