SPI TO AVALON

Il mosi dell'spi manda 8 bit di opcode, 32 bit di indirizzo e 32 bit di dato. Nel file .elf è stato 
impostato che i bit di opcode vengono inviati correttamente se scriviamo la lettera "W" o "w" per la scrittura,
e "R" o "r" per la lettura. qualunque altro carattere farà apparire a schermo una sintesi su come utilizzare il programma.
i 32 bit di indirizzo e i 32 bit di dato verranno scritti con caratteri esadecimali. Un esempio di scrittura e lettura sono i seguenti:

Wrrrrrrrrdddddddd dove rrrrrrrr rappresentano i caratteri esadecimali dell'indirizzo e dddddddd quelli del dato;
Rrrrrrrrr dove rrrrrrrr rappresentano i caratteri esadecimali dell'indirizzo

---------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------

PATTERN GENERATOR

Il generatore di pattern dispone di alcuni registri che devono essere settati prima di avviare la generazione del pattern. Ognuno di questi 
registri ha un indirizzo specifico. Gli indirizzi dei registri sono i seguenti:

  "0000" => idle;                               0
  "0001" => clock_divider_reg;                  1
  "0010" => clock_selection;                    2
  "0011" => addr_reg;                           3
  "0100" => data_reg;                           4
  "0101" => trigger_mask_reg;                   5
  "0110" => trigger_condition_reg;              6
  "0111" => start_reg;                          7
  "1000" => working_mode_reg;                   8
  "1001" => mask_OE_reg;                        9
  "1010" => max_loop_reg;                       a
  "1011" => rd_data_memory;                     b


Questi bit sono gli ultimi 4 bit sui 32 bit di indirizzo. Questo vuol dire che basta inserire il giusto carattere nell'ultima posizione relativa 
agli indirizzi. Si noti che all'indirizzo "1011" cui è associata la memoria in cui salvare i pattern, è possibile effettuare solo la lettura. 
La scrittura in memoria avviene in automatico ogni volta che si scrive un nuovo dato nel registro "data_reg" all'indirizzo "0100". 
Nell modalita sequenziale, dopo aver impostato correttamente i vari registri, per effettuare una serie di scritture consecutive in momeria 
è sufficiente dare il comando di scrittura nel data_reg in numero di volte impostato nel registro "max_loop_reg". Per la la lettura il discorso è analogo,
tranne per il fatto che l'indirizzo da leggere sara "1011", cioe rd_data_memory. Infine per la generazione dei pattern in sequenza, è sufficiente 
scrivere piu volte il registro di start.                      

Prima di effettuare una generazione è necessario settare alcuni registri:
  clock_divider_reg     => impostare un valore diverso da 00000000 altrimenti durante la generazione si va in uno stato di errore; 
  clock_selection       => lasciare 00000000 se si vuole utilizzare il clock interno, impostare 00000001 se si vuole utilizzare un clock esterno;                   
  working_mode_reg      => impostando 00000000 se si vuole lavorare in modalita one shot, oppure 00000001 se si vuole lavorare in modalita sequenziale;
  mask_OE_reg           => impostare una maschera coerente con i segnali che si vogliono vedere in uscita;
  max_loop_reg          => impostare un valore diverso da "00000000". Se si vuole lavorare in modalita sequenziale selezionare almeno "00000002" per 
                           effettuare due scritture, due letture o due generazioni successive;                 
  addr_reg              => se si vuole utilizzare un indirizzo diverso da 00000000; L'indirizzo massimo che è possibile inserire è "000000FF" in quanto la 
                           memoria implementata è una memoria 256x32bit.	
  trigger_mask_reg      => impostare una maschera coerente con le proprie esigenze
  trigger_condition_reg => impostare una valore atteso coerente con la logica dei pattern da generare;
  data_reg              => scrivere il pattern che si vuole generare. se non si rispetta il trigger, il dato verra salvato comunque in memoria, ma durante
                           la generazione, si andra nello stato di errore;
  start_reg             => scrivere "00000001" per genarare il pattern in uscita. si autoresetta in automatico. In caso di loop, basta scrivere 
                           nuovamente "00000001" per avviare la seconda generazione e cosi via. La prima generazione corrisponderà al pattern scritto in 
                           memoria nell'indirizzo presente in addr_reg, la seconda in addr_reg + 1 e cosi via.
  rd_data_memory        => si noti come anche la lettura della memoria funzionerà con lo stesso meccanismo dello start. leggera prima il pattern scritto in 
                           memoria nell'indirizzo presente in addr_reg, successivamente in addr_reg + 1 e cosi via (in caso di working_mode = 00000001).

Esempio comandi usati dal terminale per testare il generatore:

CLOCK_DIVIDER_REGISTER      ==> w0000000100000001
ADDR_REGISTER               ==> w0000000300000000
TRIGGER_MASK_REGISTER       ==> w0000000500000001
TRIGGER_CONDITION_REGISTER  ==> w0000000600000001
MASK_OUTPUT_ENABLE_REGISTER ==> w00000009ffffffff
WORKING_MODE_REGISTER       ==> w0000000800000001
MAX_SEQUENCE_REGISTER       ==> w0000000a00000003
DATA_REGISTER               ==> w0000000400000001
DATA_REGISTER               ==> w0000000400000011
DATA_REGISTER               ==> w0000000400000111
RD_DATA_MEMORY              ==> r0000000b
RD_DATA_MEMORY              ==> r0000000b
RD_DATA_MEMORY              ==> r0000000b
START_REGISTER              ==> w0000000700000001
START_REGISTER              ==> w0000000700000001
START_REGISTER              ==> w0000000700000001
    
------------------------------------------------------------------------------------------------------------------------------------------------------------ 
------------------------------------------------------------------------------------------------------------------------------------------------------------ 

LOGIC ANALYZER

Anche l'analizzatore di stati logici dispone di alcuni registri che devono essere settati prima dell'acquisizione dei dati. Ognuno di questi 
registri ha un indirizzo specifico. Gli indirizzi dei registri sono i seguenti:

  "0000" => idle;                                                                          0
  "0001" => clock_divider_reg;                                                             1
  "0010" => clock_selection;                                                               2
  "0011" => addr_reg;                                                                      3
  "0101" => trigger_mask_reg;                                                              5
  "0110" => trigger_condition_reg;                                                         6
  "1000" => working_mode_reg;                                                              8
  "1010" => max_loop_reg;                                                                  a
  "1011" => acquisizione del pattern(w)\lettura dei campioni salvati in memoria(r)         b
  "1100" => lettura dei glitch catturati durante l'acquisizione                            c
								
Questi bit sono gli ultimi 4 bit sui 32 bit di indirizzo. Questo vuol dire che basta inserire il giusto carattere nell'ultima posizione relativa 
agli indirizzi. Si noti che all'indirizzo "1011" è stata associata l'acquisizione del pattern in ingresso tramite spi (in caso di scrittura), 
sia la lettura dei campioni salvati in memoria durante una acquisizione(in caso di lettura).  
La scrittura in memoria dei campioni e dei glitch avviene in automatico ogni volta che si scrive un nuovo dato all'indirizzo "1011". 
Nell modalita sequenziale, dopo aver impostato correttamente i vari registri, per effettuare una serie di scritture consecutive in memoria 
(e quindi un numero consecutivo di acquisizioni) è sufficiente dare il comando di scrittura all'indirizzo "1011" in numero di volte pari a 
quello impostato nel registro "max_loop_reg". Per la la lettura dei campioni il discorso è analogo, in quanto si utilizza lo stesso registro. 
Se si volessero leggere i glitch rilevati, si utilizza il registro "1100".

Prima di effettuare una acquisizione è necessario settare alcuni registri:
  clock_divider_reg     => impostare un valore diverso da 00000000 altrimenti durante la generazione si va in uno stato di errore; ; 
  clock_selection       => lasciare 00000000 se si vuole utilizzare il clock interno, impostare 00000001 se si vuole utilizzare un clock esterno;                   
  working_mode_reg      => impostando 00000000 se si vuole lavorare in modalita one shot, oppure 00000001 se si vuole lavorare in modalita sequenziale;
  max_loop_reg          => impostare un valore diverso da "00000000". Se si vuole lavorare in modalita sequenziale selezionare almeno "00000002" per 
                           effettuare due scritture, due letture o due generazioni successive;                 
  addr_reg              => se si vuole utilizzare un indirizzo diverso da 00000000; L'indirizzo massimo che è possibile inserire è "000000FF" in quanto le 
                            due memorie implementate per i campioni e per i glitch hanno dimensione 256x32bit.	
  trigger_mask_reg      => impostare una maschera coerente con le proprie esigenze
  trigger_condition_reg => impostare una valore atteso coerente con la logica dei pattern da generare;
  acquisizione pattern  => se si vuole acquisire il pattern e scrivere i campioni in memoria, è sufficiente scrivere  il comando di scrittura, l'indirizzo 
  \lettura samples         0000000b e successivamente il pattern che deve essere acquisito dall'analizzatore di stati logici. I campioni verranno salvati 
                           in memoria all'indirizzo presente all'interno ddi addr_reg. Se siamo in modalitò sequenziale, allora basta scrivere nuovamente 
                           il comando di scrittura,  l'indirizzo 0000000b e il pattern, ed in automatico i campioni verranno scritti all'indirizzo successivo.
                           Per la lettura dei campioni in memoria il discorso è lo stesso. basta inserire il comando di lettura (r) e l'indirizzo 0000000b 
                           ed in automatico si andra a leggere la RAM dei campioni all'indirizzo presente nell'addr_reg. In modalita sequenziale invece 
                           leggera anche nelle allocazioni successive.
  lettura glitch         => stesso funzionamento della lettura dei samples.
 
Esempio comandi usati dal terminale per testare il generatore:  

CLOCK_DIVIDER_REGISTER      ==> w0000000100000001
ADDR_REGISTER               ==> w0000000300000000
TRIGGER_MASK_REGISTER       ==> w0000000500000001
TRIGGER_CONDITION_REGISTER  ==> w0000000600000001
WORKING_MODE_REGISTER       ==> w0000000800000001
MAX_SEQUENCE_REGISTER       ==> w0000000a00000003
DATA_REGISTER               ==> w0000000b00000001
DATA_REGISTER               ==> w0000000b00000011
DATA_REGISTER               ==> w0000000b00000111
RD_DATA_MEMORY              ==> r0000000b
RD_DATA_MEMORY              ==> r0000000b
RD_DATA_MEMORY              ==> r0000000b
     





                                            