using System; using Swan; using Unosquare.RaspberryIO.Abstractions; using Unosquare.RaspberryIO.Abstractions.Native; namespace Unosquare.WiringPi { /// /// Use this class to access threading methods using interop. /// /// public class Threading : IThreading { /// /// This attempts to shift your program (or thread in a multi-threaded program) to a higher priority and /// enables a real-time scheduling. The priority parameter should be from 0 (the default) to 99 (the maximum). /// This won’t make your program go any faster, but it will give it a bigger slice of time when other programs /// are running. The priority parameter works relative to others – so you can make one program priority 1 and /// another priority 2 and it will have the same effect as setting one to 10 and the other to 90 /// (as long as no other programs are running with elevated priorities). /// /// The priority. public void SetThreadPriority(Int32 priority) { priority = priority.Clamp(0, 99); Int32 result = Native.WiringPi.PiHiPri(priority); if(result < 0) { HardwareException.Throw(nameof(Timing), nameof(SetThreadPriority)); } } /// /// These allow you to synchronize variable updates from your main program to any threads running in your program. /// keyNum is a number from 0 to 3 and represents a “key”. When another process tries to lock the same key, /// it will be stalled until the first process has unlocked the same key. /// /// The key. public void Lock(ThreadLockKey key) => Native.WiringPi.PiLock((Int32)key); /// /// These allow you to synchronize variable updates from your main program to any threads running in your program. /// keyNum is a number from 0 to 3 and represents a “key”. When another process tries to lock the same key, /// it will be stalled until the first process has unlocked the same key. /// /// The key. public void Unlock(ThreadLockKey key) => Native.WiringPi.PiUnlock((Int32)key); /// /// /// This is really nothing more than a simplified interface to the Posix threads mechanism that Linux supports. /// See the manual pages on Posix threads (man pthread) if you need more control over them. /// /// worker. public void StartThread(Action worker) { if(worker == null) { throw new ArgumentNullException(nameof(worker)); } Int32 result = Native.WiringPi.PiThreadCreate(new Native.ThreadWorker(worker)); if(result != 0) { HardwareException.Throw(nameof(Timing), nameof(StartThread)); } } /// public UIntPtr StartThreadEx(Action worker, UIntPtr userData) => throw new NotSupportedException("WiringPi does only support a simple thread callback that has no parameters."); /// public void StopThreadEx(UIntPtr handle) => throw new NotSupportedException("WiringPi does not support stopping threads."); } }