public void driver_update_state(ref DriverState driver)
{
lock (procSyncObject)
{
PinProc.PRDriverUpdateState(ProcHandle, ref driver);
}
}
public DriverState driver_state_patter(DriverState state, ushort milliseconds_on, ushort milliseconds_off, ushort original_on_time)
{
lock (procSyncObject)
{
PinProc.PRDriverStatePatter(ref state, milliseconds_on, milliseconds_off, original_on_time);
}
return(state);
}
public DriverState driver_state_schedule(DriverState state, uint schedule, byte seconds, bool now)
{
lock (procSyncObject)
{
PinProc.PRDriverStateSchedule(ref state, schedule, seconds, now);
}
return(state);
}
public DriverState driver_state_disable(DriverState state)
{
lock (procSyncObject)
{
PinProc.PRDriverStateDisable(ref state);
}
return(state);
}
public DriverState driver_state_pulse(DriverState state, byte milliseconds)
{
lock (procSyncObject)
{
PinProc.PRDriverStatePulse(ref state, milliseconds);
}
return(state);
}
public DriverState driver_state_pulsed_patter(DriverState state, ushort milliseconds_on, ushort milliseconds_off, ushort milliseconds_overall_patter_time)
{
lock (procSyncObject)
{
PinProc.PRDriverStatePulsedPatter(ref state, milliseconds_on, milliseconds_off, milliseconds_overall_patter_time);
}
return(state);
}
public DriverState driver_get_state(ushort number)
{
DriverState ds = new DriverState();
lock (procSyncObject)
{
PinProc.PRDriverGetState(ProcHandle, (byte)number, ref ds);
}
return(ds);
}
public void driver_schedule(ushort number, uint schedule, ushort cycle_seconds, bool now)
{
DriverState state = this.driver_get_state(number);
lock (procSyncObject)
{
PinProc.PRDriverStateSchedule(ref state, schedule, (byte)cycle_seconds, now);
PinProc.PRDriverUpdateState(ProcHandle, ref state);
PinProc.PRFlushWriteData(ProcHandle);
}
}
public void driver_pulsed_patter(ushort number, ushort milliseconds_on, ushort milliseconds_off, ushort milliseconds_overall_patter_time)
{
DriverState state = this.driver_get_state(number);
lock (procSyncObject)
{
PinProc.PRDriverStatePulsedPatter(ref state, milliseconds_on, milliseconds_off, milliseconds_overall_patter_time);
PinProc.PRDriverUpdateState(ProcHandle, ref state);
PinProc.PRFlushWriteData(ProcHandle);
}
}
public void driver_disable(ushort number)
{
DriverState state = this.driver_get_state(number);
lock (procSyncObject)
{
PinProc.PRDriverStateDisable(ref state);
PinProc.PRDriverUpdateState(ProcHandle, ref state);
PinProc.PRFlushWriteData(ProcHandle);
}
}
///////////////////////////////////////////////////////////////////////////////
/// DRIVER FUNCTIONS
///////////////////////////////////////////////////////////////////////////////
public Result driver_pulse(ushort number, byte milliseconds)
{
DriverState state = this.driver_get_state(number);
Result res;
lock (procSyncObject)
{
PinProc.PRDriverStatePulse(ref state, milliseconds);
res = PinProc.PRDriverUpdateState(ProcHandle, ref state);
}
if (res == Result.Success)
{
lock (procSyncObject)
{
res = PinProc.PRDriverWatchdogTickle(ProcHandle);
res = PinProc.PRFlushWriteData(ProcHandle);
}
}
return(res);
}
public static extern Result PRDriverGetState(IntPtr handle, byte driverNum, ref DriverState driverState);
public void switch_update_rule(ushort number, EventType event_type, SwitchRule rule, DriverState[] linked_drivers, bool drive_outputs_now)
{
int numDrivers = 0;
if (linked_drivers != null)
numDrivers = linked_drivers.Length;
bool use_column_8 = g_machineType == MachineType.WPC;
if (firstTime)
{
firstTime = false;
SwitchConfig switchConfig = new SwitchConfig();
switchConfig.Clear = false;
switchConfig.UseColumn8 = use_column_8;
switchConfig.UseColumn9 = false; // No WPC machines actually use this
switchConfig.HostEventsEnable = true;
switchConfig.DirectMatrixScanLoopTime = 2; // Milliseconds
switchConfig.PulsesBeforeCheckingRX = 10;
switchConfig.InactivePulsesAfterBurst = 12;
switchConfig.PulsesPerBurst = 6;
switchConfig.PulseHalfPeriodTime = 13; // Milliseconds
lock (procSyncObject)
{
PinProc.PRSwitchUpdateConfig(ProcHandle, ref switchConfig);
}
}
Result r;
lock (procSyncObject)
{
r = PinProc.PRSwitchUpdateRule(ProcHandle, (byte)number, event_type, ref rule, linked_drivers, numDrivers, drive_outputs_now);
}
if (r == Result.Success)
{
// Possibly we should flush the write data here
}
else
{
Logger.Log(String.Format("SwitchUpdateRule FAILED for #{0} event_type={1} numDrivers={2} drive_outputs_now={3}",
number, event_type.ToString(), numDrivers, drive_outputs_now));
}
}
public static extern Result PRDriverUpdateState(IntPtr handle, ref DriverState driverState);
public static extern void PRDriverStatePulsedPatter(ref DriverState state, UInt16 millisecondsOn, UInt16 millisecondsOff, UInt16 patterTime);
public static extern void PRDriverStatePatter(ref DriverState state, UInt16 millisecondsOn, UInt16 millisecondsOff, UInt16 originalOnTime);
public static extern Result PRDriverGetState(IntPtr handle, byte driverNum, ref DriverState driverState);
public static extern void PRDriverStatePatter(ref DriverState state, UInt16 millisecondsOn, UInt16 millisecondsOff, UInt16 originalOnTime);
public static extern void PRDriverStatePulse(ref DriverState state, byte milliseconds);
public static extern Result PRDriverUpdateState(IntPtr handle, ref DriverState driverState);
public static extern void PRDriverStateDisable(ref DriverState state);
public DriverState driver_get_state(ushort number)
{
DriverState ds = new DriverState();
lock (procSyncObject)
{
PinProc.PRDriverGetState(ProcHandle, (byte)number, ref ds);
}
return ds;
}
public static extern void PRDriverStateSchedule(ref DriverState state, UInt32 schedule, byte cycleSeconds, bool now);
public DriverState driver_state_disable(DriverState state)
{
lock (procSyncObject)
{
PinProc.PRDriverStateDisable(ref state);
}
return state;
}
public static extern void PRDriverStatePulsedPatter(ref DriverState state, UInt16 millisecondsOn, UInt16 millisecondsOff, UInt16 patterTime);
public DriverState driver_state_patter(DriverState state, ushort milliseconds_on, ushort milliseconds_off, ushort original_on_time)
{
lock (procSyncObject)
{
PinProc.PRDriverStatePatter(ref state, milliseconds_on, milliseconds_off, original_on_time);
}
return state;
}
public static extern void PRDriverStateDisable(ref DriverState state);
public DriverState driver_state_pulse(DriverState state, byte milliseconds)
{
lock (procSyncObject)
{
PinProc.PRDriverStatePulse(ref state, milliseconds);
}
return state;
}
public static extern void PRDriverStatePulse(ref DriverState state, byte milliseconds);
public DriverState driver_state_pulsed_patter(DriverState state, ushort milliseconds_on, ushort milliseconds_off, ushort milliseconds_overall_patter_time)
{
lock (procSyncObject)
{
PinProc.PRDriverStatePulsedPatter(ref state, milliseconds_on, milliseconds_off, milliseconds_overall_patter_time);
}
return state;
}
public static extern void PRDriverStateSchedule(ref DriverState state, UInt32 schedule, byte cycleSeconds, bool now);
public DriverState driver_state_schedule(DriverState state, uint schedule, byte seconds, bool now)
{
lock (procSyncObject)
{
PinProc.PRDriverStateSchedule(ref state, schedule, seconds, now);
}
return state;
}
public static extern Result PRSwitchUpdateRule(IntPtr handle, byte switchNum, EventType eventType, ref SwitchRule rule, DriverState[] linkedDrivers, int numDrivers, bool drive_outputs_now);
public void driver_update_state(ref DriverState driver)
{
lock (procSyncObject)
{
PinProc.PRDriverUpdateState(ProcHandle, ref driver);
}
}
