Constant declaraion with calculation in VHDL

My suggestion is to put these within the main architecture as signals, completely determined by constants:

RAG_max <= x"7FE"-PWM_DC_min-PWM_Crossover;
RAG_min <= x"802"+PWM_DC_min+PWM_Crossover;

I must confess that I didn't yet come across the apparently existing problems with derived constants. They are working for me in a number of applications, may be there's something special with the involved types.

Which libraries are you using? I assume that you use one or more of the SYNOPSYS libraries. In this case I suggest to use the numeric_std library instead and try the following code:

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
ENTITY constant_math IS
END ENTITY constant_math;
ARCHITECTURE rtl OF constant_math IS
    CONSTANT PWM_DC_min    : std_logic_vector(11 DOWNTO 0) := std_logic_vector(to_unsigned(120, 12));
    CONSTANT PWM_Crossover : std_logic_vector(11 DOWNTO 0) := std_logic_vector(to_unsigned(6, 12));
    CONSTANT RAG_max       : std_logic_vector(11 DOWNTO 0) := std_logic_vector(2046 - unsigned(PWM_DC_min) - unsigned(PWM_Crossover));
    CONSTANT RAG_min       : std_logic_vector(11 DOWNTO 0) := std_logic_vector(2050 + unsigned(PWM_DC_min) + unsigned(PWM_Crossover));
    
BEGIN  -- ARCHITECTURE rtl
END ARCHITECTURE rtl;

Actually, I think the issue may be not explicitly declaring the 2047 inside the third type as unsigned. For example:

library IEEE;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;  
use ieee.math_real.all;
entity calibrate is
    generic (regSize : integer := 16);
     port(
         MCLK     : in  std_logic;
         HRST     : in  std_logic;
         ENABLE   : in  std_logic;
         START    : in  std_logic;
         Xin      : in  std_logic_vector(regSize-1 downto 0);
         Xout     : out std_logic_vector(regSize-1 downto 0);
         DONE     : out std_logic
         );
end calibrate;
architecture rtl of calibrate is 
constant Nsamples  :  integer := 4;
constant Z         :  integer := integer(ROUND(LOG2(1.0*real(Nsamples))));
constant N         :  integer := integer(Z) + regSize;
type accumType is record
    val : signed(N-1 downto 0);
end record;
signal accum : accumType;
type counterType is record
    start : std_logic;
    done  : std_logic;
    val   : integer range 0 to Nsamples-1;
end record;
signal counter : counterType;
signal load    : std_logic;     
signal doneDly : std_logic;
begin
/*--------------------------------------
   Accumulate offset
--------------------------------------*/
FX: process(all) begin
    if HRST then
        accum.val <= (others => '0');
    elsif rising_edge(MCLK) then
        if load then
            accum.val <= (others => '0');
        elsif START and not(counter.done) then
            accum.val <= accum.val + resize(signed(Xin),N);
        end if;
    end if;
end process FX;    
process(all) begin
    if HRST then
        Xout <= (others => '0');
    elsif rising_edge(MCLK) then
        if counter.done then
            Xout <= std_logic_vector(accum.val(N-1 downto Z)) ;
        end if;
    end if;
end process;
Uedge1 : entity work.POS_EDGE(rtl)
    port map(
        CLK     => MCLK,
        HRST     => HRST,
        X         => counter.done,
        Y         => doneDly
    );
    
Udff1 : entity work.D_FF(rtl)
    port map(
        CLK     => MCLK,
        HRST     => HRST,
        X         => doneDly,
        Y         => DONE
    );    
/*--------------------------------------
   Edge detect enable mode
--------------------------------------*/
Uedge : entity work.POS_EDGE(RTL)
    port map(
        CLK     => MCLK,
        HRST     => HRST,
        X         => ENABLE,
        Y         => load
    );
/*-------------------------------------------
           Count the number of samples
---------------------------------------------*/
counter.start <= START;
process(all) begin
    if HRST then
        counter.val  <= 0;
        counter.done <= '0';
    elsif rising_edge(MCLK) then
        if load then
            counter.val <= Nsamples-1;
            counter.done <= '0';
        elsif counter.start then
            if counter.val > 0  then
                 counter.val <= counter.val - 1;
                counter.done <= '0';
            else
                counter.done <= '1';
            end if;
        end if;
    end if;
end process;
end rtl;

Hi all,

Instead of posting just a code snippet, could you post the file where the problem occurs? Are you sure its not a problem of localised constants?

To avoid wrong conclusions of mine, can you post a code example using the said constants that shows the wrong behaviour.

FvM; Yes, I would agree it is caused by the ambiguities of the ieee std_logic_signed library versus using numeric_std. In my earlier post I alluded to this; and in a derived calculation each data type must be explicitly declared, i.e. :

Hi,