async Task Initialize()
{
// Start a timer, and stop it immediately
TimerId tid = StartTimer(payload, 10, true);
await this.StopTimer(tid, flush : false);
}
void Initialize()
{
tcs = (this.ReceivedEvent as Configure).TCS;
tid = this.StartTimer(this.payload, 100, true);
m = CreateMachine(typeof(T3), new TransferTimerAndTCS(tid, tcs));
this.Raise(new Halt());
}
void InitOnEntry()
{
count = 0;
// Start a one-off timer
tid = StartTimer(payload, 10, false);
}
public static void Init()
{
if (instance == default(TimerId))
{
instance = new TimerId(0xB5);
}
}
public InitTimer(MachineId client, TimerId tid, bool IsPeriodic, int period)
{
this.client = client;
this.IsPeriodic = IsPeriodic;
this.Period = period;
this.tid = tid;
}
void InitOnEntry()
{
count = 0;
// Start a periodic timer
tid = StartTimer(payload, 10, true);
}
async Task Initialize()
{
// Incorrect period, will throw assertion violation
TimerId tid = this.StartTimer(payload, -1, true);
await this.StopTimer(tid, flush : true);
}
private static void TimerProcedure(WindowHandle window, MessageType message, TimerId timerId, uint time)
{
Windows.MessageBeep();
s_fFlipFlop = !s_fFlipFlop;
using DeviceContext dc = window.GetDeviceContext();
using BrushHandle brush = Gdi.CreateSolidBrush(s_fFlipFlop ? Color.Red : Color.Blue);
dc.FillRectangle(window.GetClientRectangle(), brush);
}
private void InitializeTimer()
{
var e = (this.ReceivedEvent as InitTimerEvent);
this.client = e.client;
this.IsPeriodic = e.IsPeriodic;
this.tid = e.tid;
this.Send(this.Id, new RepeatTimeoutEvent());
}
private void DoPing()
{
// reset the count
count = 1;
// Start a periodic timer with timeout interval of 1sec.
// The timer generates TimerElapsedEvent with 'm' as payload.
pingTimer = StartTimer(payload, 50, true);
}
private async Task DoPing()
{
// Start a periodic timer with timeout interval of 1sec.
// The timer generates TimerElapsedEvent with 'm' as payload.
pingTimer = StartTimer(payload, 5, true);
await this.StopTimer(pingTimer, flush : true);
this.Goto <Pong>();
}
public TimeSpan Timer(TimerId id)
{
if (id < (TimerId)0 || id >= TimerId.Count)
{
return(TimeSpan.Zero);
}
return(m_Timers[(int)id]);
}
async Task Initialize()
{
TimerId tid = (this.ReceivedEvent as TransferTimer).tid;
// trying to stop a timer created by a different machine.
// should throw an assertion violation
await this.StopTimer(tid, true);
this.Raise(new Halt());
}
static void TimerProcedure(WindowHandle window, WindowMessage message, TimerId timerId, uint time)
{
Windows.MessageBeep();
fFlipFlop = !fFlipFlop;
using (DeviceContext dc = window.GetDeviceContext())
{
RECT rect = window.GetClientRectangle();
using (BrushHandle brush = fFlipFlop ? Windows.CreateSolidBrush(255, 0, 0) : Windows.CreateSolidBrush(0, 0, 255))
{
dc.FillRectangle(rect, brush);
}
}
}
private async Task DoPing()
{
tcs = (this.ReceivedEvent as Configure).TCS;
// Start a periodic timer with timeout interval of 1sec.
// The timer generates TimerElapsedEvent with 'm' as payload.
pingTimer = StartTimer(payload, 5, true);
await Task.Delay(100);
await this.StopTimer(pingTimer, flush : true);
this.Goto <Pong>();
}
async Task Initialize()
{
TimerId tid = (this.ReceivedEvent as TransferTimerAndTCS).tid;
TaskCompletionSource <bool> tcs = (this.ReceivedEvent as TransferTimerAndTCS).TCS;
// trying to stop a timer created by a different machine.
// should throw an assertion violation
try
{
await this.StopTimer(tid, true);
}
catch (AssertionFailureException)
{
tcs.SetResult(true);
this.Raise(new Halt());
}
}
void InitOnEntry()
{
Configure e = (this.ReceivedEvent as Configure);
tcs = e.TCS;
periodic = e.periodic;
count = 0;
if (periodic)
{
// Start a periodic timer with 10ms timeouts
tid = StartTimer(payload, 10, true);
}
else
{
// Start a one-off timer
tid = StartTimer(payload, 10, false);
}
}
/// <summary>
/// Handle timeout events from the pongTimer.
/// </summary>
private void DoPong()
{
// Start a periodic timer with timeout interval of 0.5sec.
// The timer generates TimerElapsedEvent with 'm' as payload.
pongTimer = StartTimer(payload, 50, false);
}
public override Task OnActivateAsync()
{
this._id = TimerId.Parse(this.GetPrimaryKeyString());
this._logger = this._serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger(this._id.FunctionType);
return(Task.CompletedTask);
}
/// <summary>
/// Allocate a free timer from the stack of free timers, set expiration
/// add the timer to end of the list of running timers
/// </summary>
/// <param name="timeout">
/// A <see cref="System.Int64"/>
/// </param>
/// <param name="timer">
/// A <see cref="Timer"/>
/// Reference to the started timer. Can be used in call to Stop()
/// </param>
/// <param name="timerId">
/// A <see cref="System.Int64"/>
/// Timer list reuse refernces (objects) of type Timer. Reference to Timer is
/// not enough to make sure that you stop the correct timer. Value timerId
/// is a unique (system level) timer identifier
/// </param>
/// <param name="applicationHook">
/// A <see cref="System.Object"/>
/// Timer.applicationHook field will be set to this value
/// Field applicationHook can help to identify the timer in the context of timerExpired
/// callback
/// </param>
/// <param name="autoRestart">
/// A <see cref="System.Boolean"/>
/// If true the system will reschedule the expire timer automatically while taking care
/// that the next expiration tick is exactly startTick+2*timeout
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>
/// returns true of Ok, false is failed to allocate a new timer - no free
/// timers are available
/// </returns>
public bool Start(out ITimer iTimer, out long timerId, object applicationHook, bool autoRestart)
{
// timestamp the call as soon as possible
DateTime startTime = DateTime.Now;
long startTick = (startTime.Ticks) / TICKS_IN_MILLISECOND;
Timer timer = null;
iTimer = null;
timerId = 0;
Timers.Error error = Timers.Error.START_UNKNOWN;
do
{
// get new timer Id
timerId = TimerId.GetNext();
// allocate a timer from the stack of free timers
lock (this)
{
countStartAttempt++;
if (freeTimers.Count > 0)
{
timer = freeTimers.Pop();
}
else
{
error = Timers.Error.NO_FREE_TIMERS;
break;
}
}
// initialize the timer
timer.ApplicationHook = applicationHook;
timer.StartTick = startTick;
timer.ExpirationTime = startTick + Timeout;
timer.Running = true;
timer.TimerId = timerId;
timer.AutoRestart = autoRestart;
timer.Restarts = 1; // first start is considered a restart
iTimer = timer;
// add the timer to the queue of the pending timers
lock (this)
{
countStart++;
pendingTimers.Add(timer);
countMax = Math.Max(countMax, pendingTimers.Count);
}
// send wakeup call to the task handling the timers
timerTask.WakeupCall();
error = Timers.Error.NONE;
}while (false);
if (error != Timers.Error.NONE)
{
PrintError("Start failed ", error);
}
return(error == Timers.Error.NONE);
}
public static void InitTimerId()
{
TimerId.Init();
}
public ITimer GeTimer(TimerId id)
{
return(GeTimer(id.ToString()));
}
public ITimer CreatOrRestartTimer(TimerId id, float duration, bool loop)
{
return(CreatOrRestartTimer(id.ToString(), duration, loop));
}
public TransferTimer(TimerId tid)
{
this.tid = tid;
}
void Initialize()
{
tid = this.StartTimer(this.payload, 100, true);
m = CreateMachine(typeof(T3), new TransferTimer(tid));
this.Raise(new Halt());
}
public ITimer ResetTimerData(TimerId id, float duration, bool loop)
{
return(ResetTimerData(id.ToString(), duration, loop));
}
public static extern ResultCode GpioSetTimerFunc(TimerId timer, uint periodMilliseconds, [In, MarshalAs(UnmanagedType.FunctionPtr)] PiGpioTimerDelegate callback);
public static extern ResultCode GpioSetTimerFuncEx(TimerId timer, uint millisecondsTimeout, [In, MarshalAs(UnmanagedType.FunctionPtr)] PiGpioTimerExDelegate callback, UIntPtr userData);
public void Add(TimerId id, TimeSpan diff)
{
m_Timers[(int)id] += diff;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="tid">Tid</param>
public TimerElapsedEvent(TimerId tid)
{
this.Tid = tid;
}
public TimeSpan Timer(TimerId id)
{
if (id < (TimerId)0 || id >= TimerId.Count)
return TimeSpan.Zero;
return m_Timers[(int)id];
}
public void Add(TimerId id, TimeSpan diff)
{
m_Timers[(int)id] += diff;
}
