Libreria Python didattica per costruire e testare circuiti digitali a livello di porte logiche: dalle porte elementari (AND, OR, NAND, NOR, NOT, XOR, XNOR) fino a latch, flip-flop, registri, contatori, memorie RAM e — come esempio conclusivo — una piccola CPU funzionante.
Ogni componente e' un oggetto "vivo": collegando le uscite di una porta agli ingressi di un'altra si costruisce un circuito che si ricalcola da solo ogni volta che uno dei suoi ingressi cambia, esattamente come farebbe l'hardware reale (propagazione a eventi, non una semplice funzione da richiamare a mano).
pip install -e .oppure, per lavorare senza installare il pacchetto, basta eseguire da
questa cartella impostando PYTHONPATH:
PYTHONPATH=. python examples/01_gates_basic.pyPer eseguire i test:
pip install -e ".[dev]"
pytestUn Signal e' un filo logico a un bit. Quando il suo valore cambia,
notifica automaticamente tutto cio' che vi e' collegato:
from logica.signal import Signal
a = Signal(value=True)
a.value = False # propaga il cambiamento a tutti i componenti collegatiUn Bus e' un gruppo ordinato di Signal che rappresenta un valore a N
bit (comodo per dati, indirizzi, contatori):
from logica.signal import Bus
d = Bus(4, value=0)
d.set_int(0b1010)
print(d.to_int()) # 10from logica.signal import Signal
from logica.gates import And, Or, Not, Nand, Nor, Xor, Xnor
a, b = Signal(), Signal()
g = And(a, b) # variabile: And(a, b, c, ...) accetta 2+ ingressi
b.value = True
print(g.output.value)Sono disponibili anche le versioni "pure" su booleani grezzi (AND, OR,
NAND, NOR, NOT, XOR, XNOR), utili per definire funzioni di
riferimento da confrontare con un circuito.
from logica.truth_table import generate_truth_table
table = generate_truth_table([a, b], [g.output], output_names=["A AND B"])
print(table)generate_truth_table prova automaticamente tutte le 2**N combinazioni
degli ingressi e ripristina i valori originali alla fine. Per circuiti
puramente Python (senza Signal) c'e' truth_table_from_function.
from logica.scope import print_state, Scope
print_state({"A": a, "B": b, "OUT": g.output}) # istantanea
scope = Scope({"CLK": clk_signal, "Q": ff.q}) # storia nel tempo
scope.attach_clock(clock) # un campione per fronte
print(scope.waveform()) # diagramma ASCIIfrom logica.clock import Clock
clock = Clock(frequency=2) # 2 impulsi al secondo
clock.on_rising_edge(lambda: ...) # sottoscrizione ai fronti
clock.start() # modalita' automatica (thread in background)
clock.set_frequency(10) # regolabile mentre gira
clock.stop()
clock.step() # un singolo impulso manuale (debug)
clock.run_interactive(key=" ") # blocca il terminale: SPAZIO = un impulso, 'q' = esci| Modulo | Contenuto |
|---|---|
logica.signal |
Signal, Bus |
logica.gates |
And, Or, Nand, Nor, Not, Xor, Xnor (+ versioni pure) |
logica.clock |
Clock (automatico e manuale/debugger) |
logica.latches |
SRLatch, SRLatchNand, GatedSRLatch, DLatch |
logica.flipflops |
DFlipFlop, JKFlipFlopMasterSlave, JKFlipFlop, TFlipFlop |
logica.registers |
Register (parallelo, con load enable opzionale) |
logica.counters |
RippleCounter (asincrono), SyncCounter (sincrono, con enable) |
logica.memory |
RAM (decoder d'indirizzo + mux di lettura) |
logica.truth_table |
generate_truth_table, truth_table_from_function |
logica.scope |
print_state, Scope (waveform ASCII) |
Tutti i latch e i flip-flop sono costruiti realmente a livello di porte
NAND/NOR con retroazione incrociata (nessuna scorciatoia comportamentale):
puoi ispezionare ogni singola porta interna (es. latch.nor_q,
ff.master, ff.slave) per capire davvero come funziona il circuito.
Nota sul flip-flop JK: sono disponibili sia la variante storica
master-slave (JKFlipFlopMasterSlave, soggetta al classico problema
del "ones catching") sia una variante realmente edge-triggered
(JKFlipFlop, priva di quel problema, ottenuta convertendo la logica J/K
in un ingresso D equivalente).
Nella cartella examples/ trovi:
01_gates_basic.py— le sette porte logiche e le loro tabelle di verita'02_latches.py— latch SR e D03_clock_demo.py— clock automatico e modalita' debugger a tastiera04_flipflops.py— tutti i flip-flop con diagramma temporale05_registers_counters.py— registro con enable, contatore ripple e sincrono06_ram.py— memoria RAM07_mini_cpu.py— CPU didattica completa (ispirata al SAP-1 di Malvino)
Una accumulator machine a 8 bit dati / 4 bit indirizzi (16 parole di
memoria), con istruzioni LDA, ADD, SUB, OUT, HLT. Il datapath
(program counter, registro istruzioni, accumulatore, ALU a somma/sottrazione
con adder a propagazione di riporto, memoria) e' interamente simulato a
livello di porte logiche; la sequenza dei micro-passi (fetch/decode/execute)
e' orchestrata in Python, la stessa separazione che nei processori reali
esiste tra datapath e microcodice del control unit.
PYTHONPATH=. python examples/07_mini_cpu.pycalcola 5 + 3 - 2 interamente via hardware simulato e stampa 6.
Per costruire circuiti nuovi bastano gli stessi mattoni: crea dei Signal
o Bus per gli ingressi/uscite che ti servono (tanti quanti vuoi), collega
porte e componenti passando le uscite degli uni come ingressi degli altri.
Ogni classe (SRLatch, DFlipFlop, Register, ...) e' scritta per essere
letta e usata come riferimento per costruirne di tue (es. un registro a
scorrimento, un flip-flop con preset/clear asincroni, un secondo banco di
RAM, un decoder di istruzioni piu' ricco con i salti condizionati).