Logica booleana

Tutti (o quasi) abbiamo in casa un computer. Ma quanti di noi sanno effettivamente cosa succede dentro “la scatola”? Cosa avviene effettivamente quando schiacciamo il pulsante di accensione, e diamo corrente a quell’ammasso di ferraglia? Lo scopo di questo articolo, è proprio lo spiegare, in termini ragionevolmente semplici, come funziona un processore, ed in che modo i programmi che scriviamo e compiliamo, sono in grado di interagire con il sistema.

Per capire come funziona un computer, dobbiamo partire dalla sua base. Che cos’è un bit. Si senta tanto parlare di bit, megabit, gigabit… e molti di noi ancora si chiedono, cos’è, questo fantomatico bit? Bene, è presto detto: il bit è un impulso. Un minuscolo impulso elettrico che viaggia sui circuiti integrati della nostra “scatola magica”. Puo assumere due diversi valori, 1 o 0, o true o false, vero o falso, o una qualsiasi altra coppia di valori a mutua esclusione (ad esempio nero o bianco…). Il significato del bit, però, è solo una semplificazione che l’uomo fa per capire di cosa sta parlando. La macchina, in se, riconosce solo gli impulsi, i segnali. Contatto aperto, o contatto chiuso. 1 o 0. Punto. Stop. Fine. Dobbiamo abituarci, se vogliamo imparare come funziona intimamente un computer, a pensare come lui. A saper interpretare al volo il significato di 1 e 0.

Ora questo non è un corso avanzato di architettura dei compilatori. Non staremo qui a spiegare dettagliatamente il funzionamento fisico della macchina, perchè ci vogliono basi molto solide, soprattutto in elettronica, che non tutti potremmo avere. Non staremo quindi a spiegare come effettivamente un componente di un circuito integrato riesce a realizzare la propria funzione. Inizieremo invece a spiegare da un livello superiore, da un’astrazione un gradino piu su. I componenti, appunto.

In linea di massima, in un circuito integrato, troveremo un numero piuttosto limitato di componenti base. In particolare sono molto frequenti i componenti AND, i NOT, gli OR e XOR. Non fatevi spaventare dalle sigle usate, ora spiegheremo cosa sono e a cosa servono. Iniziamo col dire che questi “componenti”, si chiamano porte logiche, e sono alla base di qualsiasi altro componente. Le combinazioni di questi elementi, creano altri componenti, via via piu complessi, fino a dare apparente vita autonoma alla nostra “scatola”. Un esempio? Se mettiamo insieme un NOT e un OR, avremo un NOR, un NOT e un AND, avremo un NAND. Vi state ancora chiedendo cosa sono, vero? Ok, passiamo a spiegare.
Le porte logiche sono le implementazioni fisiche della logica booleana. Non per niente, i loro nomi sono quelli delle parole che caratterizzano la logica booleana. Facciamo un breve ripasso (chi si trovasse spaesato, puo fare una brevissima ricerca online, e troverà moltissimo materiale esplicativo su questa logica, detta anche binaria).
AND:

Un AND è una porta logica con due entrate ed un’uscita. In particolare restituisce in uscita un 1, nel caso in cui entrambi i segnali in entrata siano settati a 1.

1 AND 0 = 0
0 AND 0 = 0
1 AND 1 = 1
0 AND 1 = 0

OR:

Un OR è una porta logica con due entrate ed un’uscita. In particolare restituisce in uscita un 1, nel caso uno dei due ingressi sia settato ad 1.

1 OR 0 = 1
0 OR 0 = 0
1 OR 1 = 1
0 OR 1 = 1

NOT:

Un NOT è una porta logica con una sola entrata ed una sola uscita. In particolare restituisce in uscita un 1, nel caso l’ingresso sia settato ad 1, e viceversa.

NOT 1 = 0
NOT 0 = 1

XOR:

Uno XOR è una porta logica con due entrate ed un’uscita. In particolare restituisce in uscita un 1, nel caso uno dei due ingressi non siano uguali.

1 XOR 0 = 1
0 XOR 0 = 0
1 XOR 1 = 0
0 XOR 1 = 1

Ora proviamo a combinare le porte logiche che abbiamo visto fino ad ora, ed otterremo:
NAND:

NOT (1 AND 0) = 1
NOT (0 AND 0) = 1
NOT (1 AND 1) = 0
NOT (0 AND 1) = 1

NOR:

NOT (1 OR 0) = 0
NOT (0 OR 0) = 1
NOT (1 OR 1) = 0
NOT (0 OR 1) = 0

XNOR:

NOT (0 XOR 0) = 1
NOT (0 XOR 1) = 0
NOT (1 XOR 0) = 0
NOT (1 XOR 1) = 1

Come vedere il contetto non è difficile. Ora proviamo a complicare un po le cose. Colleghiamo insieme alcuni di questi componenti. Ad esempio, colleghiamo alle due entrate di uno XOR, due AND. Chiameremo le 4 entrate degli AND rispettivamente 1A,2A e 1B,2B. Chiameremo quindi le entrate dello XOR (che sono poi le uscite dei due AND) 1C e 2C. Il nostro primo appuntamento si conclude con un esercizio. Risolvete per la prossima volta lo schemino sottostante, riportando il valore d’uscita del circuito (cioè quello dello XOR, che chiamaremo EX) a seconda dei valori in entrata dei due AND.

+----+----+----+----+----+----+----+
| 1A | 2A | 1B | 2B | 1C | 2C | EX |
+----+----+----+----+----+----+----+
|  0 |  0 |  0 |  0 |    |    |    |
|  0 |  0 |  0 |  1 |    |    |    |
|  0 |  0 |  1 |  1 |    |    |    |
|  0 |  1 |  0 |  0 |    |    |    |
|  0 |  1 |  0 |  1 |    |    |    |
|  0 |  1 |  1 |  1 |    |    |    |
|  1 |  0 |  0 |  0 |    |    |    |
|  1 |  0 |  0 |  1 |    |    |    |
|  1 |  0 |  1 |  1 |    |    |    |
|  1 |  1 |  0 |  0 |    |    |    |
|  1 |  1 |  0 |  1 |    |    |    |
|  1 |  1 |  1 |  0 |    |    |    |
|  1 |  1 |  1 |  1 |    |    |    |
+----+----+----+----+----+----+----+

Sembra difficile? Non fatevi assalire dal panico, e provateci. Tra due settimane, la risposta 🙂

Un pensiero su “Logica booleana

Rispondi

Effettua il login con uno di questi metodi per inviare il tuo commento:

Logo di WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione /  Modifica )

Google photo

Stai commentando usando il tuo account Google. Chiudi sessione /  Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione /  Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione /  Modifica )

Connessione a %s...

Questo sito utilizza Akismet per ridurre lo spam. Scopri come vengono elaborati i dati derivati dai commenti.