2019-12-06 21:09:52 +01:00
using System ;
using Swan ;
using Unosquare.RaspberryIO.Abstractions ;
using Unosquare.RaspberryIO.Abstractions.Native ;
namespace Unosquare.WiringPi {
/// <summary>
/// Use this class to access threading methods using interop.
/// </summary>
/// <seealso cref="IThreading" />
public class Threading : IThreading {
2019-12-04 18:57:18 +01:00
/// <summary>
2019-12-06 21:09:52 +01:00
/// 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).
2019-12-04 18:57:18 +01:00
/// </summary>
2019-12-06 21:09:52 +01:00
/// <param name="priority">The priority.</param>
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 ) ) ;
}
}
/// <summary>
/// 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.
/// </summary>
/// <param name="key">The key.</param>
public void Lock ( ThreadLockKey key ) = > Native . WiringPi . PiLock ( ( Int32 ) key ) ;
/// <summary>
/// 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.
/// </summary>
/// <param name="key">The key.</param>
public void Unlock ( ThreadLockKey key ) = > Native . WiringPi . PiUnlock ( ( Int32 ) key ) ;
/// <inheritdoc />
/// <summary>
/// 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.
/// </summary>
/// <exception cref="ArgumentNullException">worker.</exception>
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 ) ) ;
}
}
/// <inheritdoc />
public UIntPtr StartThreadEx ( Action < UIntPtr > worker , UIntPtr userData ) = > throw new NotSupportedException ( "WiringPi does only support a simple thread callback that has no parameters." ) ;
/// <inheritdoc />
public void StopThreadEx ( UIntPtr handle ) = > throw new NotSupportedException ( "WiringPi does not support stopping threads." ) ;
}
2019-12-04 18:57:18 +01:00
}