132 lines
4.2 KiB
C#
132 lines
4.2 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
|
|
using Swan;
|
|
|
|
using Unosquare.RaspberryIO.Abstractions;
|
|
using Unosquare.RaspberryIO.Abstractions.Native;
|
|
|
|
namespace Unosquare.WiringPi {
|
|
/// <summary>
|
|
/// Provides access to using the SPI buses on the GPIO.
|
|
/// SPI is a bus that works like a ring shift register
|
|
/// The number of bytes pushed is equal to the number of bytes received.
|
|
/// </summary>
|
|
public sealed class SpiChannel : ISpiChannel {
|
|
/// <summary>
|
|
/// The minimum frequency of a SPI Channel.
|
|
/// </summary>
|
|
public const Int32 MinFrequency = 500000;
|
|
|
|
/// <summary>
|
|
/// The maximum frequency of a SPI channel.
|
|
/// </summary>
|
|
public const Int32 MaxFrequency = 32000000;
|
|
|
|
private static readonly Object SyncRoot = new Object();
|
|
private static readonly Dictionary<SpiChannelNumber, SpiChannel> Buses = new Dictionary<SpiChannelNumber, SpiChannel>();
|
|
private readonly Object _syncLock = new Object();
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="SpiChannel"/> class.
|
|
/// </summary>
|
|
/// <param name="channel">The channel.</param>
|
|
/// <param name="frequency">The frequency.</param>
|
|
private SpiChannel(SpiChannelNumber channel, Int32 frequency) {
|
|
lock(SyncRoot) {
|
|
this.Frequency = frequency.Clamp(MinFrequency, MaxFrequency);
|
|
this.Channel = (Int32)channel;
|
|
this.FileDescriptor = Native.WiringPi.WiringPiSPISetup((Int32)channel, this.Frequency);
|
|
|
|
if(this.FileDescriptor < 0) {
|
|
HardwareException.Throw(nameof(SpiChannel), channel.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Int32 FileDescriptor {
|
|
get;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Int32 Channel {
|
|
get;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Int32 Frequency {
|
|
get;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Byte[] SendReceive(Byte[] buffer) {
|
|
if(buffer == null || buffer.Length == 0) {
|
|
return null;
|
|
}
|
|
|
|
lock(this._syncLock) {
|
|
Byte[] spiBuffer = new Byte[buffer.Length];
|
|
Array.Copy(buffer, spiBuffer, buffer.Length);
|
|
|
|
Int32 result = Native.WiringPi.WiringPiSPIDataRW(this.Channel, spiBuffer, spiBuffer.Length);
|
|
if(result < 0) {
|
|
HardwareException.Throw(nameof(SpiChannel), nameof(SendReceive));
|
|
}
|
|
|
|
return spiBuffer;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends data and simultaneously receives the data in the return buffer.
|
|
/// </summary>
|
|
/// <param name="buffer">The buffer.</param>
|
|
/// <returns>
|
|
/// The read bytes from the ring-style bus.
|
|
/// </returns>
|
|
public Task<Byte[]> SendReceiveAsync(Byte[] buffer) => Task.Run(() => this.SendReceive(buffer));
|
|
|
|
/// <inheritdoc />
|
|
public void Write(Byte[] buffer) {
|
|
lock(this._syncLock) {
|
|
Int32 result = Native.SysCall.Write(this.FileDescriptor, buffer, buffer.Length);
|
|
|
|
if(result < 0) {
|
|
HardwareException.Throw(nameof(SpiChannel), nameof(Write));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the specified buffer the the underlying FileDescriptor.
|
|
/// Do not use this method if you expect data back.
|
|
/// This method is efficient if used in a fire-and-forget scenario
|
|
/// like sending data over to those long RGB LED strips.
|
|
/// </summary>
|
|
/// <param name="buffer">The buffer.</param>
|
|
/// <returns>The awaitable task.</returns>
|
|
public Task WriteAsync(Byte[] buffer) => Task.Run(() => this.Write(buffer));
|
|
|
|
/// <summary>
|
|
/// Retrieves the spi bus. If the bus channel is not registered it sets it up automatically.
|
|
/// If it had been previously registered, then the bus is simply returned.
|
|
/// </summary>
|
|
/// <param name="channel">The channel.</param>
|
|
/// <param name="frequency">The frequency.</param>
|
|
/// <returns>The usable SPI channel.</returns>
|
|
internal static ISpiChannel Retrieve(SpiChannelNumber channel, Int32 frequency) {
|
|
lock(SyncRoot) {
|
|
if(Buses.ContainsKey(channel)) {
|
|
return Buses[channel];
|
|
}
|
|
|
|
SpiChannel newBus = new SpiChannel(channel, frequency);
|
|
Buses[channel] = newBus;
|
|
return newBus;
|
|
}
|
|
}
|
|
}
|
|
}
|