---
# System prepended metadata

title: Progetto Reti Logiche A.A. 2019/2020 (Prof. Salice Fabio)

---

# Progetto Reti Logiche A.A. 2019/2020 (Prof. Salice Fabio)
#### Luigi Fusco (Codice Persona 10601210 - Matricola 886493)
#### Alessandro Ferrara (Codice Persona 10602973 - Matricola 887198)

## Introduzione
Il progetto consiste nella progettazione di un componente in linguaggio VHDL che implementi una conversione one-hot di indirizzi appartenenti a specifiche "Working Zone" (WZ). Una WZ è definita da un intervallo di 4 indirizzi contigui a partire da un indirizzo base a `8 bit`, reso noto. Il componente deve, dati gli indirizzi base delle WZ e l'indirizzo da tradurre, produrre un indirizzo di uscita che sia tradotto o meno in base all'appartenenza dell'indirizzo originario a una delle WZ definite.

Tutte le operazioni di lettura e scrittura dell'elemento circuitale avvengono con la RAM.
Gli indirizzi base delle otto WZ sono contenuti rispettivamente agli indirizzi `0-7`.
L'indirizzo da tradurre è un numero a 8 bit nel range 0-127, contenuto all'indirizzo `8`. Il risultato della computazione deve essere scritto all'indirizzo `9` della RAM.

| Indirizzo | Contenuto              |
|:---------:|:----------------------:|
| 0         | Indirizzo Base **WZ0** |
| 1         | Indirizzo Base **WZ1** |
| 2         | Indirizzo Base **WZ2** |
| 3         | Indirizzo Base **WZ3** |
| 4         | Indirizzo Base **WZ4** |
| 5         | Indirizzo Base **WZ5** |
| 6         | Indirizzo Base **WZ6** |
| 7         | Indirizzo Base **WZ7** |
| 8         | **ADDR** da codificare |
| 9         | **OUTPUT**             |

Se l'indirizzo da tradurre non appartiene a nessuna delle workzone esso va trascritto senza modifiche. In caso contrario in output verrà scritto un vettore ad `8 bit` così formato:

| `7` | `6-4`                          | `3-0`                                |
|-----|--------------------------------|--------------------------------------|
| `1` | Numero WZ (codificato a 3 bit) | Offset WZ (**codificato one-hot**) |


## Concept
L'idea è programmare una macchina a stati. Lo stato di reset della machcina è `INIT`. L'esecuzione vera e propria inizia al ricevimento del segnale `start`. Successivamente la macchina esegue 8 cicli nello stato `WZREAD` nel quale legge in sequenza gli indirizzi base delle WZ e l'indirizzo da tradurre dalla RAM e li scrive nella sua memoria. Successivamente nello stato `CALCWRITE` l'indirizzo da tradurre viene comparato con tutti gli indirizzi delle WZ per poi essere eventualmente tradotto e successivamente scritto im RAM. Negli stati di `CLEANUP` e `FINAL` viene notificata, secondo specifica, la terminazione della computazione portandosi se necessario di nuovo allo stato `INIT`.


Segue lo schema ad alto livello della macchina descritta:
![FSM](https://luigifusco.github.io/FSM_progetto_reti_logiche.png =200x)


Uno schema più dettagliato e a basso livello del funzionamento della macchina è il seguente:

![](https://i.imgur.com/0klaTxR.png)

Il progetto viene diviso in unità funzionali. Il controller ha il compito di comunicare alla RAM l'indirizzo di lettura e scrittura, oltre a orchestrare l'esecuzione degli altri componenti. Una cache è predisposta a contenere gli indirizzi base delle WZ e l'indirizzo da tradurre, oltre che l'output finale prima che esso venga scritto in RAM. Un'unità funzionale esegue a cascata le seguenti operazioni:
- espansione delle WZ a tutti e 32 gli indirizzi
- comparazione dell'indirizzo originale con le WZ
- eventuale traduzione dell'indirizzo

L'indirizzo, tradotto o originale, viene poi trascritto dalla cache alla RAM. 

### Librerie utilizzate
Vengono utilizzate le librerie `ieee.std_logic_1164.all` per gestire la logica di base e `ieee.numeric_std.all` per effettuare operazioni aritmetiche.


### Variabili
Il programma fa uso delle seguenti variabili:
| Nome      | Tipo                  | Ruolo                                           |
| --------- | --------------------- | ----------------------------------------------- |
| state     | enum                  | contiene lo stato corrente della macchina       |
| counter   | integer               | contiene la WZ corrente                         |
| workzones | array of logic vector | contiene gli otto indirizzi base delle workzone |

### Process
Il programma fa uso di un singolo process, che ascolta i segnali `i_clk` e `i_rst`. Il segnale di reset è gestito in maniera asincrona, portando a `0` tutte le variabili numeriche e ad `INIT_STATE` la variabile state. Il resto del codice all'interno del process si occupa della normale attività sincrona della macchina. Il sincronismo viene effettuato sul `falling-edge`. Segue una descrizione dettagliata delle operazioni svolte nei singoli stati:

#### INIT_STATE
```vhdl
if i_start = '1' then
    o_address <= std_logic_vector(to_unsigned(counter, o_address'length));
    o_en <= '1';
    state <= WZREAD_STATE;
end if;
```
La macchina rimane nello stato `INIT_STATE` fin quando essa non riceve il segnale di start. Quando ciò avviene viene richiesta alla RAM il dato contenuto all'indirizzo `counter` e si passa al prossimo stato. In caso di operazione successiva al reset, `counter` contiene il numero 0, e quindi viene richiesto alla RAM il primo indirizzo base delle WZ. Se l'operazione non è la prima nel ciclo di attività della macchina allora counter conterrà il numero 8 e il dato richiesto alla macchina sarà dunque l'indirizzo da tradurre.

#### WZREAD_STATE
```vhdl
if counter = 8 then
    o_data <= '0' & i_data(6 downto 0);
    state <= CALCWRITE_STATE;
else
    workzones(counter) <= i_data;
    counter <= counter + 1;
    o_address <= std_logic_vector(to_unsigned(counter + 1, o_address'length));
end if;
```
Nel `WZREAD_STATE` la macchina legge sequenzialmente gli indirizzi base delle WZ e li scrive nella variabile `workzones`. Ad ogni ciclo `counter` viene incrementato e viene richiesto alla RAM l'indirizzo successivo. In questo modo, se `counter` è uguale a n allora allo stesso momento sto ricevendo dalla RAM il dato contenuto all'indirizzo n. Se `counter` è pari a 8 allora sto ricevendo dalla RAM l'indirizzo da tradurre. In questo caso "salvo" preventivamente dentro `o_data` l'indirizzo ricevuto, che andrò eventualmente a modificare all'interno di `CALCWRITE_STATE`.

#### CALCWRITE_STATE
```vhdl
o_we <= '1';
o_address <= std_logic_vector(to_unsigned(9, o_address'length));
for I in 0 to 7 loop
    if UNSIGNED(i_data) = UNSIGNED(workzones(I)) then
        o_data <= '1' & std_logic_vector(to_unsigned(I, 3)) & "0001";
    end if;
    if UNSIGNED(i_data) = UNSIGNED(workzones(I)) + 1 then
        o_data <= '1' & std_logic_vector(to_unsigned(I, 3)) & "0010";
    end if;
    if UNSIGNED(i_data) = UNSIGNED(workzones(I)) + 2 then
        o_data <= '1' & std_logic_vector(to_unsigned(I, 3)) & "0100";
    end if;
    if UNSIGNED(i_data) = UNSIGNED(workzones(I)) + 3 then
        o_data <= '1' & std_logic_vector(to_unsigned(I, 3)) & "1000";
    end if;
end loop;
state <= CLEANUP_STATE;
```
`CALCWRITE_STATE` prepara la RAM per la scrittura ponendo a 1 `o_we` e indicando come indirizzo di scrittura l'indirizzo 9. Il resto dello stato è costituito da un loop in cui l'indirizzo da tradurre viene comparato in parallelo con tutti gli indirizzi appartenenti alle WZ, per un totale di 64 confronti paralleli. Se si verifica un'uguaglianza allora `o_data` (precedentemente scritto con l'indirizzo originale) viene sovrascritto con l'indirizzo tradotto secondo le regole già descritte in precedenza. Da specifica le WZ non si sovrapongono, quindi in condizioni normali non si verificano conflitti di scrittura.

#### CLEANUP_STATE
```vhdl
o_en <= '0';
o_we <= '0';
o_done <= '1';
state <= FINAL_STATE;
```
Una volta raggiunto `CLEANUP_STATE` la RAM è stata scritta. Vengono posti a 0 `o_en` e `o_we` per disattivare la RAM e viene posto a 1 `o_done`, indicando così che la computazione è volta al termine.

#### FINAL_STATE
```vhdl
if i_start = '0' then
    o_done <= '0';
    state <= INIT_STATE;
end if;
```
`FINAL_STATE` aspetta fino a quando `i_start` non viene posto a 0 dall'utilizzatore. A questo punto la macchina porta `o_done` a `0` e si porta in `INIT_STATE` per aspettare un nuovo comando. Si noti che `counter` non viene azzerato.

### Ottimizzazioni
* Si è scelto di sincronizzare il componente sul `falling-edge` del clock in quanto la RAM è sincronizzata sul `rising-edge`. Questo ci permette di accedere alla RAM sullo stessto ciclo di clock, evitando di aspettare il ciclo successivo per l'accesso
* Nel ritorno a `INIT_STATE` non viene resettato il `counter`. In questo modo al raggiungimento di `WZ_READ_STATE` leggo direttamente l'indirizzo da tradurre e al clock successivo passo a `CALCWRITE_STATE`. Questo comportamento è valido perchè per specifica le WZ possono cambiare soltanto a seguito di un segnale di `reset`

### Scelte progettuali
* Salvare gli indirizzi base permette di saltare la fase di lettura della RAM in caso di molteplici start tra un reset e l'altro (supposta come condizione di normale utilizzo). Questo approccio risulta in un notevole aumento della velocità di esecuzione, a scapito di un maggior utilizzo di flip-flop (FF) per la memorizzazione degli indirizzi e di look-up table (LUT) per il confronto parallelo
* Una soluzione alternativa consiste nel leggere inizialmente l'indirizzo da tradurre, e confrontarlo con gli indirizzi base delle WZ letti in maniera sequenziale dalla RAM. Questo approccio comporta un notevole risparmio di FF (solo l'indirizzo da tradurre viene salvato) e di LUT (viene riciclata la logica di confronto). Lo svantaggio di questo approccio consiste nel dover leggere dalla RAM gli indirizzi base delle WZ ad ogni computazione, anche nel caso in cui essi non cambino, con un notevole impatto sulla velocità di esecuzione.

## Sintesi
La sintesi è stata effettuata per il dispositivo xc7k70tfbv676-1.

| Risorsa | Utilizzo | Percentuale |
| ------- | -------- | ----------- |
| LUT     | 289      | 0.70        |
| FF      | 86       | 0.10        |
| IO      | 38       | 12.67       |
| BUFG    | 1        | 3.13        |

![netlist](https://luigifusco.github.io/netlist.png)
La maggior parte del design è occupato dai registri che contengono gli indirizzi base delle working zones e dalla logica di confronto. 

## Test
Verificato che il circuito si sintetizzasse con successo abbiamo provveduto ad eseguire dei casi di test ritenuti più significativi per verificare che il comportamento dell'implementazione coincidesse con quello della specifica, analizzando i seguenti casi limite:

* WZ posizionata al limite inferiore (`00000000`)
* WZ posizionata al limite superiore (`11111111`)
* WZ posizionate in modo contiguo
* WZ posizionate randomicamente
* WZ posizionata parzialmente al di fuori del limite superiore. (WZ all'indirizzo base `11111110` e traduzione dell'indirizzo `11111111`)
* Reset durante la computazione
* Start di una nuova traduzione senza reset della macchina


Tutti i test hanno dato esito positivo.

## Conclusioni
Il componente risulta funzionante sia in pre-sintesi che in post-sintesi. Ha inoltre superato tutti i test a cui è stato sottoposto. Si ritiene quindi di aver sviluppato un componente che, seguendo la specifica, risolve il problema posto.