Me gustaría preguntar cómo usar Verilog para escribir un divisor de 16 bits por un divisor de 8 bits en xilinx ISE e implementarlo en la placa spartan3.
módulo?divisor(cociente,resto,listo,error,palabra1,palabra2,inicio,reloj,reinicio);?
parámetro?L_divn=8,?
L_divr=4,?
S_idle=0,S_adivr=1,S_adivn=2,S_div=3,S_err=4,?
L_state=3,L_cnt=4, Max_cnt=L_divn-L_divr;?
salida[L_divn-1:0]?cociente,resto;?
salida?listo,error;?
entrada ?[L_divn-1:0]?word1;//dividendo?
input?[L_divr-1:0]?word2;//divisor?
inputstart,clock,reset ;//0,start,1,reset?
reg?[L_state-1:0]state,next_state;?
regLoad_words,Restar,Shift_dividend,Shift_divisor;?
reg?[L_divn-1:0]?cociente;?
reg?[L_divn:0]?dividendo;?
reg?[L_divr-1: 0]?divisor;
reg?[L_cnt-1:0]num_Shift_dividend,num_Shift_divisor;?
reg?[L_divr:0]?comparación;?
wireMSB_divr=divisor[L_divr-1];?
wireready=((state==S_idle)&&reset);?
wireerror=(state==S_err);?
wireMax=(num_Shift_dividend==Max_cnt+num_Shift_divisor);?
wiresign_bit=comparación[L_divr];?
assignremainder=(dividendo[L_divn-1:L_divn- L_divr])>num_Shift_divisor;/////////?
siempre?@(estado?o?dividendo?o?divisor?o?MSB_divr)?caso(estado)?
S_adivr:?if(MSB_divr==0)?
comparación=dividendo[L_divn:L_divn-L_divr]+{1'b1,~(divisor<<1)}+1'b1 ;? ¿más?
comparación=dividendo[L_divn:L_divn-L_divr]+{1'b1,~divisor[L_divr-1:0]}+1'b1;?
predeterminado:?comparación=dividendo[L_divn:L_divn-L_divr]+{1'b1,~divisor[L_divr-1:0]}+1'b1;? endcase?
¿siempre?@
(posedge?clock?o?negedge?reset)?
if(!reset)?state<=S_idle;?else?state<=next_state;?
siempre?@( ¿estado?o?palabra1?o?palabra2?o?inicio?o?comparación?o?sign_bit?o?Max)?
¿comenzar?
Load_words=0;Subtract=0 ;Shift_dividend=0;Shift_divisor=0;?
caso(estado)? S_idle:caso(!start)?
0:next_state=S_idle;?
1:if(palabra2==0)?next_state=S_err;?
else?if(palabra1)?begin?next_state=S_adivr;Load_words=1;?end?
else?next_state=S_idle;?
endcase? S_adivr:?case(MSB_divr)?
0:if(sign_bit==0)?begin?next_state=S_adivr;Shift_divisor=1 ;?end?
else?if(sign_bit==1)?next_state=S_adivn;?
1:next_state=S_div;?
endcase? :?case({Max,sign_bit})?
2'b00:next_state=S_div;?
2'b01:begin?next_state=S_adivn;Shift_dividend=1;?end ?
2'b10:begin?next_state=S_idle;Subtract=1;?end?
2'b11:next_state=S_idle;?
endcase? S_div:?case({Max,sign_bit})?
2'b00:begin?next_state=S_div;Subtract=1;?end?
2'b01:next_state=S_adivn ;?
2'b10:begin?next_state=S_div;Subtract=1;?end?
2'b11:begin?next_state=S_div;Shift_dividend=1;?end?
endcase? default:?next_state=S_err;? endcase? end?
¿siempre?@(posedge?clock?or?negedge?reset)?
¿empezar?
if(!reset)? comenzar divisor<=0;? dividendo<=0;? cociente<=0;? num_Shift_dividend<=0;? p>
else?if(Load_words==1)? comenzar? dividendo<=palabra1;? divisor<=palabra2;?
num_Shift_divisor<=0;? final?
¿else?if(Shift_divisor)? ¿empezar? divisor<=divisor<<1;? ¿else?if(Shift_dividend)? ¿empezar? dividendo<=dividendo<<1;? cociente<=cociente<<1;? ? comenzar? dividendo[L_divn:L_divn-L_divr]<=comparación;? cociente[0]<=1;? final?
final?
endmodule?
Simulación de forma de onda aquí