Cbira: Cbira a redenumit pagina CID Aplicatii 11 în CID Aplicatii 12 fără a lăsa o redirecționare în loc

2021-05-06T06:15:55Z

Cbira a redenumit pagina CID Aplicatii 11 în CID Aplicatii 12 fără a lăsa o redirecționare în loc

Gvpopescu: Pagină nouă: == Automate finite. Introducere == Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand st...

2021-05-04T08:36:43Z

Pagină nouă: == Automate finite. Introducere == Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand st...

Pagină nouă

== Automate finite. Introducere ==
Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand starile nu sunt tranzitate intr-un mod simplu, evident sau repetitiv.

Automatul finit, numit și FSM (Finite State Machine), este un model matematic de computație, definit de următoarele elemente:
* O mulțime finită de simboluri de intrare, numită alfabet de intrare;
* O mulțime finită și nevidă de simboluri de ieșire, numită alfabet de ieșire;
* O mulțime finită și nevidă de stări, din care doar una, numită starea curentă, este activă la un moment dat;
* O stare inițială, care face parte din mulțimea stărilor;
* O funcție de tranziție a stărilor, care calculează starea următoare a automatului în funcție de starea curentă și de simbolul de intrare;
* O funcție de calcul a ieșirii, care determină simbolul de ieșire în funcție de starea curentă (în cazul automatelor de tip Moore) sau în funcție de starea curentă și de simbolul de intrare (în cazul automatelor de tip Mealy).

[[[[Fișier:Fsm.png]]]]

La fiecare front al ceasului, valoarea stării următoare, calculată de către CLC, va fi încărcată în registru. Dacă registrul are n biți, numărul maxim de stări care pot fi reprezentate este 2<sup>n</sup>. Acest număr poate fi mai mic, în funcție de schema de codare a stărilor. De exemplu, pentru n = 4, folosind codarea binară se pot reprezenta cel mult 16 stări (0000, 0001, 0010, ..., 1111), în timp ce pentru codarea one-hot, în care doar un singur bit poate lua valoarea 1, se pot reprezenta 4 stări (1000, 0100, 0010, 0001).

Pentru a reprezenta comportamentul unui automat finit, putem folosi grafuri sau organigrame, conventiile de notare depinzand de tipul automatului (Moore sau Mealy).

==1. Automat ce detecteaza secvente de tipul 11....100....0==
In acest exemplu va fi implementat un automat care detecteaza secventele de tipul 11....100....0. Pentru aceasta, automatul va avea o intrare pe un bit (''in'', pe care va veni secventa de biti) si doua iesiri: ''detectOk'', care semnalizeaza prin 1 ca nu a fost inca detectata o secventa ilegala si ''detectFail'', care semnalizeaza prin 1 ca a fost detectata o secventa ilegala (un 1 dupa 0).

Automatul va avea 3 stari:
* Q0 - STATE_READ1: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 1 (inca nu a aparut niciun 0).
* Q1 - STATE_READ0: automatul intra in aceasta stare atunci cand apare pe intrare primul 0 si va ramane in aceasta atata timp cat pe intrare este 0.
* Q2 - STATE_ERROR: automatul intra in aceasta stare atunci cand apare un 1 dupa 0 si va ramane blocat aici pana la reset.

Pentru a coda cele 3 stari avem nevoie de minim 2 biti: STATE_READ1 = 2'b00, STATE_READ0 = 2'b01, STATE_ERROR = 2'b10.

Graful automatului este:

[[Fișier:Organigrama FSM 111000.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM1(
input clock,
input in,
input reset,
output detectOk,
output detectFail
);

//Se asociaza sirurilor de biti folositi pentru codarea starilor nume ce pot fi folosite mai usor in cod.
//La compilare, numele vor fi inlocuite in cod cu numerele asociate la inceput.
localparam STATE_READ1 = 2'b00;
localparam STATE_READ0 = 2'b01;
localparam STATE_ERROR = 2'b10;

reg [1:0] state, state_next;

//registrul de stare
always@(posedge clock) begin
if(reset == 0)
state <= STATE_READ1;
else
state <= state_next;
end

//circuit combinational pentru calculul starii urmatoare
always@(*) begin
state_next = state;
case(state)
STATE_READ1: begin
if(in == 0) state_next = STATE_READ0;
end
STATE_READ0: begin
if(in == 1) state_next = STATE_ERROR;
end
STATE_ERROR: state_next = STATE_ERROR;
default: state_next = STATE_READ1;

endcase
end

//circuit combinational pentru calculul iesirilor
assign detectOk = (state == STATE_READ0) || (state == STATE_READ1);
assign detectFail = (state == STATE_ERROR);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM1'''
<syntaxhighlight lang="Verilog">
module FSM1_TB();

reg clock_t;
reg reset_t;
reg in_t;
wire detectOk_t;
wire detectFail_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 1;
reset_t = 0;
#2 reset_t = 1;
#10 in_t = 0;
#10 in_t = 1;
#10 $stop();
end

FSM1 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.detectOk(detectOk_t),
.detectFail(detectFail_t)
);

endmodule
</syntaxhighlight>

==2. Automat ce detecteaza fronturile crescatoare ale unui semnal==
Automatul ce detecteaza fronturile crescatoare are un singur semnal de intrare ''in'', care reprezinta semnalul analizat si o singura iesire, ''out'', generand pe aceasta un puls lung cat o perioada de ceas la fiecare aparitie a unui front crescator pe ''in''.

Vom avea nevoie de 3 stari:
* Q0: automatul intra in aceasta stare la reset si va ramane in aceasta atata timp cat intrarea este 0 (inca nu a aparut niciun front crescator).
* Q1: automatul intra in aceasta stare atunci cand apare pe intrare un front crescator. Dupa aparitia frontului crescator sunt doua posibilitati: linia ramane in 1, ceea ce duce la trecerea in starea Q2 care va duce iesirea in 0 dupa o perioada de ceas, sau linia trece in 0 dupa un ciclu de ceas, ceea ce duce la revenirea in starea Q0.
* Q2: automatul intra in aceasta stare atunci cand linia de intrare ramane in 1 mai mult de o perioada de ceas. Automatul va ramane in aceasta stare atata timp cat ''in'' ramane in 1 si va reveni in starea Q0 imediat ce ''in'' revine in 0.

Graful automatului este:

[[Fișier:Organigrama FSM rising edge.png]]

'''Implementarea automatului'''
<syntaxhighlight lang="Verilog">
module FSM2(
input clock,
input in,
input reset,
output out
);

localparam Q0 = 2'b00;
localparam Q1 = 2'b01;
localparam Q2 = 2'b10;

reg [1:0] state, state_next;

always@(posedge clock) begin
if(reset == 0)
state <= Q0;
else
state <= state_next;
end

always@(*) begin
state_next = state;
case(state)
Q0: begin
if(in == 1) state_next = Q1;
end
Q1: begin
if(in == 0) state_next = Q0;
if(in == 1) state_next = Q2;
end
Q2: begin
if(in == 0) state_next = Q0;
end
default: state_next = Q0;
endcase
end

assign out = (state == Q1);

endmodule
</syntaxhighlight>

'''Implementarea unui modul de test pentru FSM2'''
<syntaxhighlight lang="Verilog">
module FSM2_TB();

reg clock_t;
reg reset_t;
reg in_t;
wire out_t;

initial begin
clock_t = 0;
forever #1 clock_t = ~clock_t;
end

initial begin
in_t = 0;
reset_t = 0;
#2 reset_t = 1;
#10 in_t = 1;
#5 in_t = 0;
#10 in_t = 1;
#5 in_t = 0;
#10 $stop();
end

FSM2 DUT(
.clock(clock_t),
.reset(reset_t),
.in(in_t),
.out(out_t)
);

endmodule

</syntaxhighlight>

← Versiunea anterioară	Versiunea de la data 6 mai 2021 06:15
(Nicio diferență)

CID Aplicatii 12 - Revizia istoricului

Cbira: Cbira a redenumit pagina CID Aplicatii 11 în CID Aplicatii 12 fără a lăsa o redirecționare în loc

Gvpopescu: Pagină nouă: == Automate finite. Introducere == Automatul finit este folosit pentru a descrie sisteme ce tranziteaza un numar finit de stari. Acest tip de sistem este foarte util atunci cand st...