A better coding style in Verilog

[syntax=verilog]
`timescale 1ns / 1ns

module motor_if

         #(parameter INITIAL_POSITION  =       0,      // inital position is at floor 0
                     MOTOR_STEP        =      50,      // [m] (a single motor step is 50m = 0,05mm)
                     CONTROL_STEP      =      10,      // [mm] (a control step is 10mm = 1cm)
                     DISTANCE_BITS     =      14,      // max distance 12m = 12.000 mm
                     CONTROL_STEP_BITS =      11,      // 12m <> 1.200 control steps
                     MOTOR_STEP_BITS   =      18,      // max distance 12m = 240.000 * 50m
                     MOTOR_STEP_BITS2  =      18,      // max distance 12m = 240.000 * 50m
                     MAX_POSITION_R    =    1200,      // [control steps] (1.200 control steps = 240.000 motor steps = 12 m)
                     MAX_POSITION_L    =       0,      // [control steps] (0 control steps = 0 motor steps = 0 m)
                     DELAY_COUNT_BITS  =      17,      // 17 bits required to count up to C_0 = 100.000
                     C_0               =  100000,      // initial counter value <> 100 Hz @ 10 MHz clock
                     C_MIN             =     250)      // minimum counter value <> 40 kHz @ 10 MHz clock

         (input  wire                      CLK,
          input  wire                      RESET,

          input  wire [DISTANCE_BITS-1 :0] DISTANCE,        // levels [mm] / door_width [mm]
          input  wire                      ROTATE_LEFT,     // open or down
          input  wire                      ROTATE_RIGHT,    // close or up
                                            
          output reg                       CTRL_STEP_DONE,  // 10mm distance is a step
          output reg                       DONE,            // motor request executed
          output wire                      A,               // motor coil a output
          output wire                      B,               // motor coil a output
          output wire                      C,               // motor coil a output
          output wire                      D);              // motor coil a output

/* =============================INSERT CODE HERE======================================*/ 

	//Test related regs and wires
	reg [DELAY_COUNT_BITS -1:0]	actual_delay_rounded;

	//The number of motor steps which make one control step
	parameter steps_per_ctrl = CONTROL_STEP * 1000 / MOTOR_STEP;
	//Register to save motor steps needed for the current command
	reg [DISTANCE_BITS + 9:0]				motor_steps_command;
	//Register to save motor steps needed for the acceleration and deceleration
	reg [DISTANCE_BITS + 8:0]				motor_steps_accel, motor_steps_decel;
	/*
	* Register for storing the current number of clocks to wait before making a motor step.
	* The value is stored in a DELAY_COUNT_BITS.16 fixed point format
	*/
	reg [(DELAY_COUNT_BITS + 16) - 1:0]	actual_delay; 
	/*
	* Register for storing the calculation result of the next delay. The calculation result
	* is 2 * (DELAY_COUNT_BITS + 16) bit wide, that's why the result can't be directly
	* assigned to actual_delay
	*/
	reg [(DELAY_COUNT_BITS + 16) + (16 + 16) - 1:0] actual_delay_tmp;
	/*
	* Register for storing the number of clock waited since the last calculation of 
	* actual_delay
	*/
	reg [DELAY_COUNT_BITS - 1:0] 	delay_count;	
	/*
	* Registers storing the direction (LEFT, RIGHT) of a command, the emergency halt signal.
	* The remaining registers are helpers for converting wires to registers
	*/
	reg 									direction, halt, next_root, previous_root, a_tmp, b_tmp, c_tmp, d_tmp;
	//Wires for controlling the sqrt module (instantiated below)
	wire									next_root_tmp, previous_root_tmp;
	//Wire for the done signal of the sqrt module
	wire									root_finished;
	//Wire for the result of the sqrt module
	wire [31:0]							root_res;
	/*
	* Register for storing the current root before calculating the next root, since both roots
	* are needed for the calculation of the next delay
	*/
	reg [31:0]							interval_root;
	/*
	* Registers for storing the motor steps done in one command and the total
	* motor steps done since the reset (the total motor steps consider the direction of a
	* command). The total motor steps are used to actually steer the motor (using outputs
	* A, B, C and D)
	*/
	reg [MOTOR_STEP_BITS - 1:0]	total_motor_steps, current_motor_steps;
	/*
	* Register for storing the position of the elevator or the door (is used to check whether
	* a command exceeds the maximum or minimum position of the elevator or door)
	*/
	reg [CONTROL_STEP_BITS - 1:0]	position;
	//Register for storing the intern state of the module 
	reg [1:0]							state;
	
	//Conversion between wires and regs
	assign next_root_tmp = next_root;
	assign previous_root_tmp = previous_root;
	assign A = a_tmp;
	assign B = b_tmp;
	assign C = c_tmp;
	assign D = d_tmp;
	
	//Instantiation of the sqrt module used to calculates the square roots
	sqrt root(CLK, RESET, next_root_tmp, previous_root_tmp, root_finished, root_res);
		
	//State and combinational logic
	always @ (posedge CLK) begin
		if(CTRL_STEP_DONE) CTRL_STEP_DONE = 0;
		if(next_root) next_root = 0;
		if(previous_root) previous_root = 0;
		//Reset the whole module
		if(RESET) begin
			CTRL_STEP_DONE = 0;
			DONE = 1;
			
			motor_steps_command = 0;
			motor_steps_accel = 0;
			motor_steps_decel = 0;
			
			delay_count = 0;
			actual_delay = {C_0, 16'b0};
			
			direction = 0;
			halt = 0;
			next_root = 0;
			previous_root = 0;
			
			interval_root = root_res;
			
			total_motor_steps = INITIAL_POSITION * steps_per_ctrl;
			current_motor_steps = 0;
			
			position = INITIAL_POSITION;
			
			state = 0;
		end
		//Emergency halt the motor
		else if(ROTATE_LEFT & ROTATE_RIGHT) begin
		halt = 1;
		end
		else begin
			//Check whether the module is currently within a command (!DONE) or not (DONE)
			if(DONE) begin
				//If new commando is given, take the given values and start
				if(ROTATE_LEFT | ROTATE_RIGHT) begin
					if(ROTATE_LEFT ? position - DISTANCE / CONTROL_STEP >= MAX_POSITION_L : position + DISTANCE / CONTROL_STEP <= MAX_POSITION_R) begin
						delay_count = 0;
						actual_delay = {C_0, 16'b0};
						
						direction = ROTATE_LEFT ? 0 : 1;
						
						current_motor_steps = 0;
						
						motor_steps_command = (DISTANCE * 1000) / MOTOR_STEP;
						if(motor_steps_command[0]) begin
							motor_steps_accel = (motor_steps_command - 1) / 2;
						end
						else begin
							motor_steps_accel = motor_steps_command / 2;
						end
						
						state = 0;
						
						DONE = 0;
					end
				end
				//If no new commando is given, do nothing
			end
			else begin
				/*
				* Check if distance has to be updated (can only be updated along the current 
				* direction). It's not a problem that this block is not only run through during
				* updates, since the distance cannot change is a single clock? Maybe Issue
				*/
				if((ROTATE_LEFT & !direction) | (ROTATE_RIGHT & direction)) begin
					motor_steps_command = (DISTANCE * 1000) / MOTOR_STEP;
					if(motor_steps_command[0]) begin
						motor_steps_accel = (motor_steps_command - 1) / 2;
					end
					else begin
						motor_steps_accel = motor_steps_command / 2;
					end
				end
				//Do calculations (only if motor is not halted)
				if(!halt) begin
					
					//Check in which state the module is currently
					case (state)
						/*
						* State 0: Check if target distance if greater than 0, if yes, change to
						* 			  state 1 and pre-calculate next root
						*/
						0: begin 
								if(motor_steps_accel > 0) begin
									state = 1;
									/*interval_root = root_res;
									next_root = 1;*/
								end
								else begin
									state = 3;
								end
							end
						/*
						* State 1: Accelerate motor -> check if enough clocks have been waited,
						*			  if yes, calculate new interval, store current root, calculate
						* 			  next root, do a motor step and update the total motor steps, if
						*			  not, the increase delay count
						*			  If the half of target distance is travelled, change to state 3
						*			  and calculate the previous root
						*			  If the actual delay is smaller the C_MIN change to state 2 and
						*			  calculate the previous root
						*/
						1: begin 
								if(delay_count == actual_delay[DELAY_COUNT_BITS + 15:16]) begin
									delay_count = 1;
									//Do motor step (current and total)
									current_motor_steps = current_motor_steps + 1;
									total_motor_steps = direction ? total_motor_steps + 1 : total_motor_steps - 1;
									if(actual_delay <= C_MIN) begin
										motor_steps_decel = current_motor_steps;
										state = 2;
									end
									else if(current_motor_steps == motor_steps_accel) begin
										if(!motor_steps_command[0]) begin
											interval_root = root_res;
											previous_root = 1;
											state = 3;
										end
									end
									else if(current_motor_steps == motor_steps_accel + 1) begin
										interval_root = root_res;
										previous_root = 1;
										state = 3;	
									end
									else begin
										interval_root = root_res;
										next_root = 1;
									end
								end
								else begin
									delay_count = delay_count + 1;
								end
								
							end
						/*
						* State 2: Travel with full speed -> check if enough clocks have been
						*			  waited, if yes, do a motor step and update the total motor
						*			  steps
						*			  If the acceleration distance is left of target distance,
						*			  calculate the new delay and the previous root
						*/
						2: begin						
								if(delay_count == C_MIN) begin
									delay_count = 1;
									//Do motor step (current and total)
									current_motor_steps = current_motor_steps + 1;
									total_motor_steps = direction ? total_motor_steps + 1 : total_motor_steps - 1;
								end
															
								if(motor_steps_command - current_motor_steps == motor_steps_decel) begin
									interval_root = root_res;
									previous_root = 1;
									state = 3;
								end
							end
						/*
						* State 3: Decelerate motor -> like if state 1, but calculating the
						*			  previous root instead of the next root
						*			  If the total distance was travelled, change to state 0 and set
						*			  DONE to 1
						*/
						3: begin 								
								if(delay_count == actual_delay[DELAY_COUNT_BITS + 15:16]) begin
									delay_count = 1;
									interval_root = root_res;
									//Do motor step (current and total)
									current_motor_steps = current_motor_steps + 1;
									total_motor_steps = direction ? total_motor_steps + 1 : total_motor_steps - 1;
									if(current_motor_steps == motor_steps_command) begin
										$stop;
										state = 0;
										if(root_res == 0) begin
											next_root = 1;
										end
										DONE = 1;
									end
									else begin
										previous_root = 1;
									end
								end
								else begin
									delay_count = delay_count + 1;
								end								
							end
					endcase
				end
			end
		end
	end
	
	//Increase current_distance and position (total_distance) according to motor_steps
	always @ (current_motor_steps) begin
		if(state != 0 & current_motor_steps > 0 & current_motor_steps % steps_per_ctrl == 0) begin
			position = direction ? position + 1 : position - 1;
			CTRL_STEP_DONE = 1;
		end	
	end
	
	/*
	* Take the relevant bits (DELAY_COUNT_BITS integer bits, 16 fractional bits) from the
	* calculation of the next delay stored in actual_delay_tmp
	*/
	always @ (*) begin
		actual_delay = actual_delay_tmp[(DELAY_COUNT_BITS + 15) + 16:16];
	end
	
	/*
	* Calculate actual_delay
	*/
	always @ (*) begin
		if(current_motor_steps > 0 & root_finished) begin
			if(state == 1) begin
				actual_delay_tmp = {C_0[DELAY_COUNT_BITS - 1:0], 16'b0} * (root_res - interval_root);
			end
			else if(state == 3) begin
				actual_delay_tmp = {C_0[DELAY_COUNT_BITS - 1:0], 16'b0} * (interval_root - root_res);
			end
		end
	end
	
	//Test related mappings
	always @ (*) begin
		actual_delay_rounded = actual_delay[(DELAY_COUNT_BITS +15):16];
	end
		
	//Mapping between motor_steps and the motor signals
	always @ (*) begin
		case (total_motor_steps % 4)
			0: {a_tmp, b_tmp, c_tmp, d_tmp} <= 4'b1001; 
			1:	{a_tmp, b_tmp, c_tmp, d_tmp} <= 4'b1100;
			2: {a_tmp, b_tmp, c_tmp, d_tmp} <= 4'b0110;
			3: {a_tmp, b_tmp, c_tmp, d_tmp} <= 4'b0011;
		endcase
	end
	
/* ====================================================================================*/
   
endmodule 
[/syntax]

[syntax=verilog]

reg a;

always @ (posedge CLK) begin
    a = input;
    if(input) output = 1;
end
[/syntax]

[syntax=verilog]

reg a;

always @ (posedge CLK) begin
    a <= input;
    if(input) output <= 1;
end
[/syntax]

[syntax=verilog]
/*
* Here does the actual calculation take place, consequently this is only done if
* DONE is set to 0
*/
if(!DONE) begin
	/*
	* Check if the maximum precision of the 16.16 format is reached - if this is the
	* stop the calculation and set DONE to 1
	*/			
	if (delta > 0) begin
		//Adjust the estimation of the current square root
		SQRT = (high + low) >> 1;
		//Check if the estimation is the new high or low boundary
		sqr = SQRT * SQRT;
		if(sqr[48:16] > {1'b0, n[15:0], 16'b0000000000000000})
			high = SQRT;
		else
			low = SQRT;
		//Adjust the precision of the estimation
		delta = delta >> 1;
	end
	else begin
		DONE = 1;
	end
end	
[/syntax]

           a = b *c; 
           d= a*e;