reg [8:0]xn_re;
always @ (posedge CLK_A)
xn_re <= signal;

FFT FFT_A (
  .clk(CLK_A),         // input clk
  .start(1),           // input start
  .unload(1),          // input unload
  .xn_re(xn_re[8:0]),  // input [8 : 0] xn_re min+max
  .xn_im(0),           // input [8 : 0] xn_im
  .fwd_inv(1),         // input fwd_inv
  .fwd_inv_we(1),      // input fwd_inv_we
  .rfd(rfd),           // output rfd
  .busy(busy),         // output busy
  .dv(dv),             // output dv
  .xk_re(xk_re),       // output [8 : 0] xk_re
  .xk_im(xk_im)        // output [8 : 0] xk_im
);

wire [8:0]out_math;
math math (// математика
          .clk(CLK_A),
             .dv(dv),
          .real_(xk_re),
          .imaginary(xk_im),
          .out_(out_math)
         );

module math (
input clk,
input dv,
input [7:0]real_,
input [7:0]imaginary,
output reg[9:0]out_
);
wire [15:0] real_re;
wire [15:0] imaginary_;
//модуль комплексного числа.    
multiplexor m_re (
  .clk(clk), // input clk
  .a(real_), // input [7 : 0] a
  .b(real_), // input [7 : 0] b
  .ce(dv),  
  .p(real_re) // output [15 : 0] p
);
multiplexor m_im (
  .clk(clk),     // input clk
  .a(imaginary), // input [7 : 0] a
  .b(imaginary), // input [7 : 0] b
  .ce(dv),  
  .p(imaginary_) // output [15 : 0] p
);
reg [16:0] summe;
always @ (posedge clk)
begin
summe <= real_re[15:0] + imaginary_[15:0];
end
wire [8:0]out_m;
sqrt sqrt (
  .clk(clk), // input clk
  .ce(dv),
  .x_in(summe), // input [15 : 0] x_in
  .x_out(out_m) // output [8 : 0] x_out
);
//------------------------ ищем max ----------------------------------
wire [8:0] max = (dv == 1'b1) ? 1'b1: (( max < out_m ) ?  out_m : 1'b1);    
//----------------------- нормировка по max
wire [8:0] max_2;  
divider d_max (
    .clk(clk),         // input clk
    .ce(dv),           // input ce
    .dividend(max),    // input [8 : 0] dividend
    .divisor(2),       // input [8 : 0] divisor
    .fractional(max_2) // output[8 : 0] fractional
    );
wire [8:0] res;      
divider d_res (
    .clk(clk),       // input clk
    .ce(dv),         // input ce
    .dividend(out_m),// input [8 : 0] dividend
    .divisor(max_2), // input [8 : 0] divisor
    .fractional(res) // output[8 : 0] fractional
    );

always @ (posedge clk)
begin
      out_ <= res[7:0] - 118;//двигаем по высоте. меньше - выше
end

endmodule