shift register problem in VHDL
As the array types signed and std_logic_vector have the same element type you can convert between both types the following way:

signal x : std_logic_vector(7 downto 0); -- 8 bit for example
signal y : signed(7 downto 0);

y &lt;= signed(x);


and back

signal y : signed(7 downto 0);
signal z : std_logic_vector(7 downto 0); -- 8 bit for example

z &lt;= std_logic_vector(y);


Of course, you can also use variables instead of signals (using the := assignment).

So for your shift register you will need:

temp_shift_register(31 downto 24) &lt;= std_logic_vector(temp_byte);




Further remarks

This line is not required:

  else null;


You are missing to shift in new values at the position temp_shift_register(7 downto 0).

Instead of the for ... end loop; you can just assign all bits at once:

temp_shift_register(55 downto 8) &lt;= temp_shift_register(47 downto 0);




How to proceed

Taking your other question into account, the basic idea is to have a second 56-bit wide result register which stores the current maximum and the values (bytes) beside it:

signal result_register : std_logic_vector(55 downto 0) := (others =&gt; '0');


Then you will have to:


Shift the new values from memory into the shift register at the lower bits.
Compare the middle byte of the shift register with the middle byte of the result register. If the former is greater, then copy the shift register into the result register.


The code would look like this:

process (clk) is
begin
  if rising_edge(clk) then
    -- shift register
    temp_shift_register(55 downto 8) &lt;= temp_shift_register(47 downto 0);
    temp_shift_register(7 downto 0)  &lt;= new_byte_from_memory;

    -- check for new maximum
    if signed(temp_shift_register(31 downto 24)) &gt; signed(result_register(31 downto 24))  then
      result_register &lt;= temp_shift_register;
    end if;
  end if;
end process;


You will have to extend the code at least 1) to reset both registers, and 
2) shift the register only when new data from memory is available.