-- NewPadsDriver.sak
-- last edited by Suzuki: 20-Jan-82 16:53:33

DIRECTORY
  SakuraRT,
  NewPads,
  SimIO;
  
NewPadsDriver: MONITOR IMPORTS SakuraRT, NewPads, SimIO = {

  PadsDriver: DEVICE = {
    IN  Clock: BOOLEAN, AIn, BIn: CARDINAL, EnableIn, EqualIn: CARDINAL
    OUT AOut, BOut: CARDINAL, EnableOut, EqualOut: CARDINAL
    GUARDIAN {}
    CONTROL {
      Power: PROC [left, exponent: CARDINAL] RETURNS [ret: CARDINAL] = {
        ret _ 1;
	THROUGH [0..exponent) DO
	  ret _ ret*left
	  ENDLOOP};
      Print: PROC [en, eq: CARDINAL, a, b: CARDINAL] = {
        SimIO.WF4["Enable = %d*nEqual = %d*nA = %d,  %d*n", en, eq, a, a];
	SimIO.WF2["B = %d,  %d*n", b, b]
	};
      Step: PROC [aOrB, out, enable: CARDINAL] = {
        WHEN Clock CHANGE: Print[EnableIn, EqualIn, AIn, BIn];
	IF aOrB = 1 THEN AOut _ out ELSE BOut _ out;
	EnableOut _ enable;
	};
      UpAndDown: PROC [out, enable: CARDINAL] = {
        Step[enable, out, 0];
        Step[enable, out, enable];
        Step[enable, out, 0];
	};
      Enable: PROC [enable: CARDINAL] = {
        FOR i: NAT IN [0..8) DO
          UpAndDown[0, enable];
	  UpAndDown[Power[2, i], enable];
	  Step[enable, 0, 0];
	  Step[enable, 0, enable];
	  ENDLOOP
	};
	
      WHEN Clock CHANGE: {EnableOut _ 0; 
                          EqualOut _ 0; 
			  AOut _ 0; 
			  BOut _ 0; 
			  SakuraRT.Delay[10]};
      Enable[1];
      Enable[2];
      }
    };

  ClockDriver: DEVICE = {
    IN
    OUT Clock: BOOLEAN
    GUARDIAN {}
    CONTROL {
      DO
        Clock _ TRUE;
	SakuraRT.Delay[20];
	ENDLOOP }
    };
	
  SimIO.Start[];
  CIRCUIT {
    COMPONENTS cl: ClockDriver, pd: PadsDriver, pi: NewPads.PadsFunc
    NODES a, b, c, en, eq: NODE
    REPRESENTATION
    CONNECTIONS
      cl[Clock: c],
      pd[Clock: c, AIn: a, BIn: b, EnableIn: en, EqualIn: eq, AOut: a, BOut: b, 
        EnableOut: en, EqualOut: eq],
      pi[Clock: c, A: a, B: b, Enable: en, Equal: eq]};
  SimIO.Stop[];
      
}.