imported Sharp7.Rx

This commit is contained in:
Thomas Stangl
2018-11-05 16:23:37 +01:00
parent aedfa4075f
commit d8d07c1679
18 changed files with 1169 additions and 0 deletions

301
Sharp7.Rx/Sharp7Plc.cs Normal file
View File

@@ -0,0 +1,301 @@
using System;
using System.Reactive;
using System.Reactive.Linq;
using System.Reactive.Subjects;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Sharp7.Rx.Enums;
using Sharp7.Rx.Interfaces;
using Sharp7.Rx.Resources;
namespace Sharp7.Rx
{
public class Sharp7Plc : IPlc
{
private readonly string ipAddress;
private readonly int rackNumber;
private readonly int cpuMpiAddress;
private readonly S7VaraibleNameParser varaibleNameParser;
private bool disposed;
private ISubject<Unit> disposingSubject = new Subject<Unit>();
private IS7Connector s7Connector;
public Sharp7Plc(string ipAddress, int rackNumber, int cpuMpiAddress)
{
this.ipAddress = ipAddress;
this.rackNumber = rackNumber;
this.cpuMpiAddress = cpuMpiAddress;
varaibleNameParser = new S7VaraibleNameParser();
}
public IObservable<ConnectionState> ConnectionState { get; private set; }
public async Task<bool> InitializeAsync()
{
s7Connector = new Sharp7Connector(ipAddress, rackNumber, cpuMpiAddress);
ConnectionState = s7Connector.ConnectionState;
await s7Connector.InitializeAsync();
#pragma warning disable 4014
Task.Run(async () =>
{
try
{
await s7Connector.Connect();
}
catch (Exception)
{
}
});
#pragma warning restore 4014
return true;
}
public Task<TValue> GetValue<TValue>(string variableName)
{
return GetValue<TValue>(variableName, CancellationToken.None);
}
public async Task<TValue> GetValue<TValue>(string variableName, CancellationToken token)
{
var address = varaibleNameParser.Parse(variableName);
if (address == null) throw new ArgumentException("Input variable name is not valid", nameof(variableName));
if (typeof(TValue) == typeof(bool))
{
var b = await s7Connector.ReadBit(address.Operand, address.Start, address.Bit, address.DbNr, token);
token.ThrowIfCancellationRequested();
return (TValue)(object)b;
}
if (typeof(TValue) == typeof(int))
{
var b = await s7Connector.ReadBytes(address.Operand, address.Start, address.Length, address.DbNr, token);
token.ThrowIfCancellationRequested();
if (address.Length == 2)
return (TValue)(object)((b[0] << 8) + b[1]);
if (address.Length == 4)
{
Array.Reverse(b);
return (TValue)(object)Convert.ToInt32(b);
}
throw new InvalidOperationException($"length must be 2 or 4 but is {address.Length}");
}
if (typeof(TValue) == typeof(ulong))
{
var b = await s7Connector.ReadBytes(address.Operand, address.Start, address.Length, address.DbNr, token);
token.ThrowIfCancellationRequested();
Array.Reverse(b);
return (TValue)(object)Convert.ToUInt64(b);
}
if (typeof(TValue) == typeof(short))
{
var b = await s7Connector.ReadBytes(address.Operand, address.Start, 2, address.DbNr, token);
token.ThrowIfCancellationRequested();
return (TValue)(object)(short)((b[0] << 8) + b[1]);
}
if (typeof(TValue) == typeof(byte) || typeof(TValue) == typeof(char))
{
var b = await s7Connector.ReadBytes(address.Operand, address.Start, 1, address.DbNr, token);
token.ThrowIfCancellationRequested();
return (TValue)(object)b[0];
}
if (typeof(TValue) == typeof(byte[]))
{
var b = await s7Connector.ReadBytes(address.Operand, address.Start, address.Length, address.DbNr, token);
token.ThrowIfCancellationRequested();
return (TValue)(object)b;
}
if (typeof(TValue) == typeof(double) || typeof(TValue) == typeof(float))
{
var bytes = await s7Connector.ReadBytes(address.Operand, address.Start, 4, address.DbNr, token);
token.ThrowIfCancellationRequested();
var d = Convert.ToSingle(bytes);
return (TValue)(object)d;
}
if (typeof(TValue) == typeof(string))
{
if (address.Type == DbType.String)
{
var bytes = await s7Connector.ReadBytes(address.Operand, address.Start, 2, address.DbNr, token);
token.ThrowIfCancellationRequested();
var stringLength = bytes[1];
var stringStartAddress = (ushort)(address.Start + 2);
var stringInBytes = await s7Connector.ReadBytes(address.Operand, stringStartAddress, stringLength, address.DbNr, token);
token.ThrowIfCancellationRequested();
return (TValue)(object)Encoding.ASCII.GetString(stringInBytes);
}
else
{
var stringInBytes = await s7Connector.ReadBytes(address.Operand, address.Start, address.Length, address.DbNr, token);
token.ThrowIfCancellationRequested();
return (TValue)(object)Encoding.ASCII.GetString(stringInBytes).Trim();
}
}
throw new InvalidOperationException(string.Format("type '{0}' not supported.", typeof(TValue)));
}
public Task SetValue<TValue>(string variableName, TValue value)
{
return SetValue(variableName, value, CancellationToken.None);
}
public async Task SetValue<TValue>(string variableName, TValue value, CancellationToken token)
{
var address = varaibleNameParser.Parse(variableName);
if (address == null) throw new ArgumentException("Input variable name is not valid", "variableName");
if (typeof(TValue) == typeof(bool))
{
await s7Connector.WriteBit(address.Operand, address.Start, address.Bit, (bool)(object)value, address.DbNr, token);
}
else if (typeof(TValue) == typeof(int) || typeof(TValue) == typeof(short))
{
byte[] bytes;
if (address.Length == 4)
bytes = BitConverter.GetBytes((int)(object)value);
else
bytes = BitConverter.GetBytes((short)(object)value);
Array.Reverse(bytes);
await s7Connector.WriteBytes(address.Operand, address.Start, bytes, address.DbNr, token);
}
else if (typeof(TValue) == typeof(byte) || typeof(TValue) == typeof(char))
{
var bytes = new[] { Convert.ToByte(value) };
await s7Connector.WriteBytes(address.Operand, address.Start, bytes, address.DbNr, token);
}
else if (typeof(TValue) == typeof(byte[]))
{
await s7Connector.WriteBytes(address.Operand, address.Start, (byte[])(object)value, address.DbNr, token);
}
else if (typeof(TValue) == typeof(float))
{
var buffer = new byte[sizeof(float)];
S7.SetRealAt(buffer, 0, (float)(object)value);
await s7Connector.WriteBytes(address.Operand, address.Start, buffer, address.DbNr, token);
}
else if (typeof(TValue) == typeof(string))
{
var stringValue = value as string;
if (stringValue == null) throw new ArgumentException("Value must be of type string", "value");
var bytes = Encoding.ASCII.GetBytes(stringValue);
Array.Resize(ref bytes, address.Length);
if (address.Type == DbType.String)
{
var bytesWritten = await s7Connector.WriteBytes(address.Operand, address.Start, new[] { (byte)address.Length, (byte)bytes.Length }, address.DbNr, token);
token.ThrowIfCancellationRequested();
if (bytesWritten == 2)
{
var stringStartAddress = (ushort)(address.Start + 2);
token.ThrowIfCancellationRequested();
await s7Connector.WriteBytes(address.Operand, stringStartAddress, bytes, address.DbNr, token);
}
}
else
{
await s7Connector.WriteBytes(address.Operand, address.Start, bytes, address.DbNr, token);
token.ThrowIfCancellationRequested();
}
}
else
{
throw new InvalidOperationException($"type '{typeof(TValue)}' not supported.");
}
}
public IObservable<TValue> CreateNotification<TValue>(string variableName, TransmissionMode transmissionMode, TimeSpan cycle)
{
var address = varaibleNameParser.Parse(variableName);
if (address == null) throw new ArgumentException("Input variable name is not valid", nameof(variableName));
if (cycle < TimeSpan.FromMilliseconds(100))
cycle = TimeSpan.FromMilliseconds(100);
var notification = ConnectionState.FirstAsync().Select(states => states == Enums.ConnectionState.Connected)
.SelectMany(async connected =>
{
var value = default(TValue);
if (connected)
{
value = await GetValue<TValue>(variableName, CancellationToken.None);
}
return new
{
HasValue = connected,
Value = value
};
})
// TODO: .RepeatAfterDelay(cycle)
// TODO: .LogAndRetryAfterDelay(Logger, cycle, StringResources.StrLogErrorReadingDataFromPlc)
.TakeUntil(disposingSubject)
.Where(union => union.HasValue)
.Select(union => union.Value);
if (transmissionMode == TransmissionMode.Cyclic)
return notification;
if (transmissionMode == TransmissionMode.OnChange)
return notification.DistinctUntilChanged();
throw new ArgumentException("Transmission mode can either be Cyclic or OnChange", nameof(transmissionMode));
}
public void Dispose()
{
Dispose(true);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (disposingSubject != null)
{
disposingSubject.OnNext(Unit.Default);
disposingSubject.OnCompleted();
var disposable = (disposingSubject as IDisposable);
if (disposable != null) disposable.Dispose();
disposingSubject = null;
}
if (s7Connector != null)
{
s7Connector.Disconnect().Wait();
s7Connector.Dispose();
s7Connector = null;
}
}
disposed = true;
}
}
~Sharp7Plc()
{
Dispose(false);
}
}
}