bms_eras_dsc_half.tdf

CodeVisionAVR C Library Functions Reference CodeVisionAVR C 库函数介绍 译自CodeVisionAVR C Compiler Help

onereg.clk = sysclk;
onenode[1] = onereg;
onenode[m..2] = 0;

FOR k IN 1 TO check GENERATE
  bd[k][] = (addvec[k][] & !clearbd);
END GENERATE;

bd[][].clk = sysclk;
bd[][].clrn = !reset;

FOR k IN 1 TO nummult GENERATE
  bd[k][].ena = (!omsel[k] & loadbdleft) # clearbd;
END GENERATE;
FOR k IN 1 TO (check-nummult) GENERATE
  bd[k+nummult][].ena = (!omsel[k+nummult] & loadbdright) # clearbd;
END GENERATE;


omsel[].clk = sysclk;
omsel[].clrn = !reset;
omsel[].ena = incomega;

omsel[1] = VCC;
FOR k IN 2 TO check GENERATE
	omsel[K] = omsel[K-1];
end generate;


bdprev[1][] = ((bdtemp[1][] & !shiftbdprev_ml & !shiftbdprev_lm & !loadsyn) #
              (eras_pos[1][] & !shiftbdprev_ml & !shiftbdprev_lm & loadsyn) #
              (onenode[] & !shiftbdprev_ml & shiftbdprev_lm) #
              (bdprev[2][] & shiftbdprev_ml & !shiftbdprev_lm));
FOR k IN 2 TO check-1 GENERATE
  bdprev[k][] = ((bdtemp[K][] & !shiftbdprev_ml & !shiftbdprev_lm & !loadsyn) #
              (eras_pos[K][] & !shiftbdprev_ml & !shiftbdprev_lm & loadsyn) #
              (bdprev[K-1][] & !shiftbdprev_ml & shiftbdprev_lm) #
              (bdprev[K+1][] & shiftbdprev_ml & !shiftbdprev_lm));

END GENERATE;
bdprev[check][] = ((bdtemp[check][] & !shiftbdprev_ml & !shiftbdprev_lm & !loadsyn) #
              (eras_pos[check][] & !shiftbdprev_ml & !shiftbdprev_lm & loadsyn) #
              (bdprev[check-1][] & !shiftbdprev_ml & shiftbdprev_lm) #
              (bdprev[1][] & shiftbdprev_ml & !shiftbdprev_lm));

bdprev[][].clk = sysclk;
bdprev[][].clrn = !reset;
bdprev[][].ena = loadbdprev # shiftbdprev_lm # shiftbdprev_ml # loadsyn;

sh_sel[1] = VCC;
FOR k IN 2 TO check GENERATE
	sh_sel[K] = sh_sel[K-1];
END GENERATE;


sh_sel[].clk = sysclk;
sh_sel[].ena = shift_sh_sel;
sh_sel[].clrn = !reset;

bdtemp[][] = (bd[][] & !loadsyn) # (eras_pos[][] & loadsyn);
bdtemp[][].clk = sysclk;
bdtemp[][].ena = loadbdtemp # loadsyn;
bdtemp[][].clrn = !reset;  

--********************
--*** CORE SECTION ***
--********************

--*** calculate new delta ***

bdleft[][] = bdprev[][];

erasright[1][] = 1;
FOR K IN 2 TO check GENERATE
  erasright[K][] = bd[K-1][];
END GENERATE;

FOR k IN 1 to check GENERATE

  erasleft[K][] = (bdprev[1][] & sh_sel[k]) # (bdtemp[k][] & !sh_sel[K]);

  deltaleft[k][] = synreg[check+1-k][];
  deltaright[k][] = bd[k][]; 

-- calculate new bd vector
  bdright[k][] = deltamult[];

-- calculate omega
  omegaleft[k][] = synreg[k][];
  omegaright[k][] = (bdprev[1][] & !initomega) # (one[] & initomega);

END GENERATE;


FOR k IN 1 TO nummult-odd GENERATE
  addvec[k][] = bd[k][] $ mulout[k][];   -- GFadd
	addvec[k+nummult][] = bd[k+nummult][] $ mulout[k][];   -- GFadd
END GENERATE;
IF (odd == 1) GENERATE
  addvec[nummult][] = bd[nummult][] $ mulout[nummult][];  -- GFadd
END GENERATE;


-- Multiplexing before multiplying
FOR k IN 1 TO nummult-odd GENERATE

  mulleft[k][] = ( !multmux & 
                 ((erasleft[k][] & deltacalc & calcomega) #
                 (deltaleft[k][] & deltacalc & !calcomega) # 
                 (bdleft[k][] & !deltacalc & !calcomega) #
                 (omegaleft[k][] & !deltacalc & calcomega))) #
				         ( multmux &
				         ((erasleft[k+nummult][] & deltacalc & calcomega) #
				         (deltaleft[k+nummult][] & deltacalc & !calcomega) # 
                 (bdleft[k+nummult][] & !deltacalc & !calcomega) #
                 (omegaleft[k+nummult][] & !deltacalc & calcomega)));

  mulright[k][] = ( !multmux &
	               ((erasright[k][] & deltacalc & calcomega) #
                 (deltaright[k][] & deltacalc & !calcomega) # 
                 (bdright[k][] & !deltacalc & !calcomega) #
                 (omegaright[k][] & !deltacalc & calcomega))) #
				         ( multmux &
				         ((erasright[k+nummult][] & deltacalc & calcomega) #
				         (deltaright[k+nummult][] & deltacalc & !calcomega) # 
                 (bdright[k+nummult][] & !deltacalc & !calcomega) #
                 (omegaright[k+nummult][] & !deltacalc & calcomega)));

  END GENERATE;

If odd==1 generate

  mulleft[nummult][] = ( !multmux & 
                 ((erasleft[nummult][] & deltacalc & calcomega) #
                 (deltaleft[nummult][] & deltacalc & !calcomega) # 
                 (bdleft[nummult][] & !deltacalc & !calcomega) #
                 (omegaleft[nummult][] & !deltacalc & calcomega)));

  mulright[nummult][] = ( !multmux &
	               ((erasright[nummult][] & deltacalc & calcomega) #
                 (deltaright[nummult][] & deltacalc & !calcomega) # 
                 (bdright[nummult][] & !deltacalc & !calcomega) #
                 (omegaright[nummult][] & !deltacalc & calcomega)));

END GENERATE;
mulleft[][].clk = sysclk;
mulright[][].clk = sysclk;

FOR k IN 1 TO nummult GENERATE
  mulout[k][] = gfmul (mulleft[k][], mulright[k][])
               	WITH (m = m, irrpol = irrpol);
END GENERATE;

-- calculate new delta
mulsum[1][] = mulout[1][];
IF (nummult>1) GENERATE
  FOR k IN 2 TO nummult GENERATE
    mulsum[k][m..1] = mulout[k][m..1] $ mulsum[k-1][m..1];  -- GFadd
  END GENERATE;
END GENERATE;

predelta[] = mulsum[nummult][] $ synreg[1][];
predelta[].clk = sysclk;

delta[] = mulsum[nummult][] $ predelta[];
delta[].clk = sysclk;
delta[].ena = newdelta;
delta[].clrn = !reset;

deltaprev[] = delta[];
deltaprev[].clk = sysclk;
deltaprev[].ena = olddelta;
deltaprev[m..2].clrn = !reset;
deltaprev[1].prn = !reset;

deltamult[] = gfdiv (delta[], deltaprev[])
               WITH (m=m, irrpol=irrpol, inv_file = inv_file);
deltamult[].clk = sysclk;

deltazero[1] = delta[1];
FOR k IN 2 TO m GENERATE
  deltazero[k] = delta[k] # deltazero[k-1];
END GENERATE;

--****************
--*** COUNTERS ***
--****************

mloop[] = mcount.q[];
mcount.clock = sysclk;
mcount.cnt_en = incm;
mcount.aclr = reset;

mchk[1] = mloop[1] $ mcmp[1];
eras_zero[1] = num_eras_q[1];
init_syn[1] = mloop[1] $ num_eras_q[1];
omegachk[1] = omegaloop[1] $ omegacmp[1];
FOR k IN 2 TO wide GENERATE
  mchk[k] = mchk[k-1] # (mloop[k] $ mcmp[k]);
	eras_zero[k] = num_eras_q[k] # eras_zero[k-1];
  init_syn[k] = init_syn[k-1] # (mloop[k] $ num_eras_q[k]);
  omegachk[k] = omegachk[k-1] # (omegaloop[k] $ omegacmp[k]);
END GENERATE;

--onewide[] = 1;
-- L = M+1-L

--(llnuma[],,) = lpm_add_sub ( VCC, mloop[], llnum[],,,)
--				  WITH (LPM_WIDTH = wide, LPM_DIRECTION = "SUB");

add_sub1.cin = VCC;
add_sub1.dataa[] = mloop[];
add_sub1.datab[] = llnum[];
llnuma[] = add_sub1.result[];

--(llnumb[],,) = lpm_add_sub ( GND, num_eras_q[], onewide[],,,)
--				  WITH (LPM_WIDTH = wide, LPM_DIRECTION = "ADD");

add_sub2.cin = GND;
add_sub2.dataa[] = num_eras_q[];
add_sub2.datab[] = 1;
llnumb[] = add_sub2.result[];

--(llnumnode[],,) = lpm_add_sub ( GND, llnuma[], llnumb[],,,)
--				  WITH (LPM_WIDTH = wide, LPM_DIRECTION = "ADD");

add_sub3.cin = GND;
add_sub3.dataa[] = llnuma[];
add_sub3.datab[] = llnumb[];
llnumnode[] = add_sub3.result[];

llnum[] = (llnumnode[] & !loadsyn) # (num_eras[] & loadsyn);
llnum[].clk = sysclk;
llnum[].ena = load_llnum # loadsyn;

num_eras_q[].clk = sysclk;
num_eras_q[] = num_eras[];

-- 2L <= m + num_eras_q?

--(mloop_plus_eras_num[],,) = lpm_add_sub ( GND, (0,mloop[]), (0,num_eras_q[]),,,)
--				  WITH (LPM_WIDTH = wide+1, LPM_DIRECTION = "ADD");

add_sub4.cin = GND;
add_sub4.dataa[] = (0,mloop[]);
add_sub4.datab[] = (0,num_eras_q[]);
mloop_plus_eras_num[] = add_sub4.result[];

--(,,,,,tlm) = lpm_compare ( (llnum[],0), mloop_plus_eras_num[],,)
--				  WITH (LPM_WIDTH = (wide+1));

compare1.dataa[] = (llnum[],0);
compare1.datab[] = mloop_plus_eras_num[];
tlm = compare1.aleb;


omegaloop[] = omegacount.q[];
omegacount.clock = sysclk;
omegacount.cnt_en = incomega;
omegacount.aclr = reset;


--***************
--*** OUTPUTS ***
--***************

bdout[][] = bdprev[][];
omegaout[][] = bd[][];
numerr[] = llnum[];
done = massdone;

END;