Verilog Code for specific kind of counter (Problems) - memory

Question

Good afternoon people, i'm trying to code in Verilog a structure than can store up to 64 different 8bit numbers (64X8), which is only allowed to store numbers greater than 125 and bellow or equal to 250. When it is writing (or not), it can show the maximum current stored value (VAL_MAX) as well as it's position (POS_MAX). When not writing (EN_WR ==0) i simply put in POS_RD the position that i want, in order to see what number is stored there, and when the memory is full (NR_ST = 64) it replaces the oldest stored numbers with the new ones, one by one. I currently have the code but there are some issues:
1st - When the memory is full and for eg. i have 250 in the 2nd position, the output will be
VAL_MAX= 250 ; POS_MAX=1. When a bunch of new numbers come, that maximum should be replaced with the 2nd highest stored value and must show it's position, but the memory isn't showing a new Max Value.
2nd - When i want to see the number stored in the 1st position (POS_RD = 0) the output VAL_RD (used to read the stored numbers) is "X" and not the stored number, i don't know if it is saving or not.
The code is:
module Bloco(VAL_SENSOR, EN_WR, POS_RD, NR_ST, VAL_MAX, POS_MAX, VAL_RD, segundo, clk);
parameter MEM_SIZE = 64;
parameter MEM_WIDTH = 8;
parameter ADDR_SIZE = 5;
input[MEM_WIDTH - 1:0] VAL_SENSOR;
input[5:0] POS_RD;
input EN_WR,segundo,clk;
output[6:0] NR_ST;
output[MEM_WIDTH - 1:0] VAL_MAX;
output[ADDR_SIZE :0]POS_MAX;
output[MEM_WIDTH - 1:0]VAL_RD;
reg[MEM_WIDTH - 1:0] ram[MEM_SIZE - 1:0]; // C , L
reg[MEM_WIDTH - 1:0] VAL_RD;
reg[MEM_WIDTH - 1:0] val_max = 0; //necessita de variavel so por causa do valor inicial
reg[ADDR_SIZE :0] POS_MAX = 0;
reg[ADDR_SIZE :0] POS_MAX2 = 0;
reg[ADDR_SIZE + 1:0] NR_ST_COUNTER = 0; //addr_size + 1 because it needs to count from zero to the number of values
reg[ADDR_SIZE :0] POS_POINTER = 0;
assign VAL_MAX = val_max;
assign NR_ST = NR_ST_COUNTER;
always # (posedge clk)
begin
if(EN_WR) //Caso esteja habilitado o sistema de armazenamento
begin
if(segundo)
begin
if(VAL_SENSOR > 125 && VAL_SENSOR <= 250) //Se for um numero abaixo de 250 unid. luminosas e acima de 125
begin //Escrita
if(POS_POINTER == POS_MAX)
POS_MAX <= POS_MAX2;
else
ram[POS_POINTER] <= VAL_SENSOR;
if(NR_ST_COUNTER < 64) //atualizar Contador de Valores guardados
NR_ST_COUNTER = NR_ST_COUNTER + 1;
if(VAL_SENSOR > val_max) //atualizar MAX
begin
POS_MAX <= POS_POINTER;
val_max <= VAL_SENSOR;
end
else //ver se encaixa no segundo maior POS_MAX2
begin
if(VAL_SENSOR > ram[POS_MAX2]) //nao precisa guardar o valor
POS_MAX2 <= POS_POINTER;
end
POS_POINTER <= POS_POINTER + 1;
end
end
end
else
VAL_RD <= ram[POS_RD];
end
endmodule
.
NOTE = The input "segundo" is like EN_WR, but it's only used after 10 clock cycles (it will be linked to a Counter).
Thank you.

Answer 1

To answer your questions:
1) The reason you are likely not seeing the second highest value in your memory appear on VAL_MAX when the current max is overridden is because you never change val_max register to contain the value of ram[POS_MAX2], ie the second highest value. However, as you do not have an ordered data structure and do not store any more than the second highest value (and do not search the memory for the second highest value), you cannot reliably keep finding the next highest value when the current highest is removed/overridden. You might need to rethink alot of how you are doing this if you need to always have the current highest value in the memory being output on VAL_MAX.
2) Position 0 is not being written to the first time you write to the memory; thus you are getting the default value of the memory, ie 'x. Here way:
if(POS_POINTER == POS_MAX)
POS_MAX <= POS_MAX2;
else
ram[POS_POINTER] <= VAL_SENSOR;
In the above lines, you only put values in the memory if the current position is not equal to the position of the current highest value. The first time you write (ie, to position 0), POS_POINTER and POS_MAX are at their initial values of 0, thus equal. So, ram[0] never gets updated as it is only executed if POS_POINTER and POS_MAX are not equal (which in this case, they are equal). If you were to write to position 0 a second time, you might be able to write to it as the value of POS_MAX might have changed. Note also, that you sometimes update the write pointer POS_POINTER even if you dont write there, as in the example above (even through ram[0] wasnt written to, you will still update POS_PONTER to be 1).
As mentioned in #1, depending on your requirements, you might not have the right structures here to meet them. If you always need to have the highest value in the memory output on VAL_MAX and always have the old value ejected, you might need to make old of those operations do a search, or store and update all the needed meta data.