module StepNext(Current,Next);

input [3:0] Current;
output[3:0] Next;
reg [3:0] Next;

always @(Current)
case (Current)
 4'b1001: Next=4'b1000;
 4'b1000: Next=4'b1100;
 4'b1100: Next=4'b0100;
 4'b0100: Next=4'b0110;
 4'b0110: Next=4'b0010;
 4'b0010: Next=4'b0011;
 4'b0011: Next=4'b0001;
 default: Next=4'b1001;
endcase

endmodule

module StepPrev(Current,Prev);

input [3:0] Current;
output[3:0] Prev;
reg [3:0] Prev;

always @(Current)
case (Current)
 4'b1100: Prev=4'b1000;
 4'b0100: Prev=4'b1100;
 4'b0110: Prev=4'b0100;
 4'b0010: Prev=4'b0110;
 4'b0011: Prev=4'b0010;
 4'b0001: Prev=4'b0011;
 4'b1001: Prev=4'b0001;
 default: Prev=4'b1001;
endcase

endmodule

module machine(Select,Mode,DataIn,DataOut,CLK,
 PatternX,PatternY,PatternZ,StepperEnable,
 Coolant,Spindle,
 LimitsX,LimitsY,LimitsZ,Stop,Guard) ;

//Inputs from computer
input [2:0] Select;
input Mode;
input DataIn;
input CLK;

//Output to computer

output DataOut;
reg DataOut;

//Inputs from Limit switches etc.

input [1:0] LimitsX;
input [1:0] LimitsY;
input [1:0] LimitsZ;
input Stop;
input Guard;

//Outputs for Steppers and other stuff...

output [3:0] PatternX;
reg [3:0] PatX; //I'm sure one of these needn't be a reg!
reg [3:0] PatternX;
output [3:0] PatternY;
reg [3:0] PatY; 
reg [3:0] PatternY;
output [3:0] PatternZ;
reg [3:0] PatZ; 
reg [3:0] PatternZ;
output StepperEnable;
reg StepperEnable;
output Coolant;
reg Coolant;
output Spindle;
reg Spindle;

`define StepperX      3'b000
`define StepperY      3'b001
`define StepperZ      3'b010
`define WindingEnable 3'b100
`define SpindleMotor  3'b101
`define CoolantPump   3'b110

`define StartX 3'b000
`define EndX   3'b001
`define StartY 3'b010
`define EndY   3'b011
`define StartZ 3'b100
`define EndZ   3'b101
`define StopSwitch  3'b110
`define GuardSwitch 3'b111

`define S 0
`define E 1

wire [3:0] PatternXNext;
wire [3:0] PatternXPrev;
wire [3:0] PatternYNext;
wire [3:0] PatternYPrev;
wire [3:0] PatternZNext;
wire [3:0] PatternZPrev;

StepNext NextX(PatternX,PatternXNext);
StepPrev PrevX(PatternX,PatternXPrev);
StepNext NextY(PatternY,PatternYNext);
StepPrev PrevY(PatternY,PatternYPrev);
StepNext NextZ(PatternZ,PatternZNext);
StepPrev PrevZ(PatternZ,PatternZPrev);

always @(Mode or Select or LimitsX or LimitsY or LimitsZ or Stop or Guard)
if (Mode)
 DataOut=
 ~LimitsX[`S] | ~LimitsX[`E] |
 ~LimitsY[`S] | ~LimitsY[`E] |
 ~LimitsZ[`S] | ~LimitsZ[`E] |
 ~Stop | ~Guard;
else begin
 case (Select)
  `StartX: DataOut=~LimitsX[`S];
  `EndX:   DataOut=~LimitsX[`E];
  `StartY: DataOut=~LimitsY[`S];
  `EndY:   DataOut=~LimitsY[`E];
  `StartZ: DataOut=~LimitsZ[`S];
  `EndZ:   DataOut=~LimitsZ[`E];
  `StopSwitch:  DataOut=~Stop;
  `GuardSwitch: DataOut=~Guard;
 endcase
end

always @ (PatX or StepperEnable)
if (StepperEnable) PatternX=PatX;
else PatternX=4'b0000;

always @ (PatY or StepperEnable)
if (StepperEnable) PatternY=PatY;
else PatternY=4'b0000;

always @ (PatZ or StepperEnable)
if (StepperEnable) PatternZ=PatZ;
else PatternZ=4'b0000;

always @ (posedge CLK) begin
if (Mode)
 begin
  case (Select)
   `SpindleMotor:  Spindle<=DataIn;
   `CoolantPump:   Coolant<=DataIn;
   `WindingEnable: StepperEnable<=DataIn;
   `StepperX: if (DataIn) PatX<=PatternXNext;
             else PatX<=PatternXPrev;
   `StepperY: if (DataIn) PatY<=PatternYNext;
             else PatY<=PatternYPrev;
   `StepperZ: if (DataIn) PatZ<=PatternZNext;
             else PatZ<=PatternZPrev;
  endcase
 end
end
endmodule