private AdsErrorCode TryWriteSymbolic(ISymbol address, int offset, int byteSize, byte[] value) { if (address == null) { throw new ArgumentNullException("address"); } if (this.Connection == null) { throw new AdsException("Connection not established!"); } int handle = 0; using (new AdsConnectionRestore(this)) { AdsErrorCode code = this.Connection.RawInterface.TryCreateVariableHandle(address.InstancePath, false, out handle); if (code == AdsErrorCode.NoError) { try { return(this.Connection.RawInterface.Write(handle, offset, byteSize, value, false)); } finally { code = this.Connection.RawInterface.TryDeleteVariableHandle(handle, false); } } return(AdsErrorCode.DeviceSymbolNotFound); } }
private void CheckResult(bool throwAdsException, AdsErrorCode result) { if (throwAdsException && (result != AdsErrorCode.NoError)) { ThrowAdsException(result); } }
public AdsErrorCode TryDeleteVariableHandle(int variableHandle) { AdsErrorCode noError = AdsErrorCode.NoError; Dictionary <int, SymbolEntry> dictionary = this._symbolTable; lock (dictionary) { if (!this._symbolTable.ContainsKey(variableHandle)) { noError = AdsErrorCode.DeviceSymbolNotFound; } else { SymbolEntry entry = this._symbolTable[variableHandle]; int num = entry.referenceCount - 1; entry.referenceCount = num; if (num != 0) { noError = AdsErrorCode.NoError; } else { noError = this._syncPort.Write(0xf006, 0, entry.serverHandle, false); bool flag2 = this._symbolTable.Remove(variableHandle); bool flag3 = this._symbolPathTable.Remove(entry.symbolPath); } } } return(noError); }
private AdsErrorCode TryReadSymbolic(ISymbol address, int numBytes, byte[] value, out int read) { if (address == null) { throw new ArgumentNullException("address"); } if (this.Connection == null) { throw new AdsException("Connection not established!"); } AdsErrorCode noError = AdsErrorCode.NoError; using (new AdsConnectionRestore(this)) { int handle = 0; noError = this.Connection.RawInterface.TryCreateVariableHandle(address.InstancePath, false, out handle); read = 0; if (noError == AdsErrorCode.NoError) { try { return(this.Connection.RawInterface.Read(handle, 0, numBytes, value, false, out read)); } finally { AdsErrorCode code2 = this.Connection.RawInterface.TryDeleteVariableHandle(handle, false); if (noError == AdsErrorCode.NoError) { noError = code2; } } } return(AdsErrorCode.DeviceSymbolNotFound); } }
public AdsErrorCode Disconnect(Func <AdsErrorCode> action) { AdsErrorCode result = action(); this.AfterDisconnect(result); return(result); }
public AdsErrorCode TryRead(out object[] values, out AdsErrorCode[] returnCodes) { IList <SumDataEntity> sumEntities = this.CreateSumEntityInfos(); base.innerCommand = new SumRead(base.connection, sumEntities, TwinCAT.Ads.SumCommand.SumCommand.SumAccessMode.IndexGroupIndexOffset); values = null; IList <byte[]> readData = null; AdsErrorCode code = base.innerCommand.TryReadRaw(out readData, out returnCodes); if (code == AdsErrorCode.NoError) { values = new object[sumEntities.Count]; IList <Symbol> unwrappedSymbols = base.UnwrappedSymbols; ValueAccessor valueAccessor = base.ValueAccessor; for (int i = 0; i < base.symbols.Count; i++) { ISymbol symbol = base.symbols[i]; if (returnCodes[i] == AdsErrorCode.NoError) { values[i] = valueAccessor.ValueFactory.CreateValue(symbol, readData[i], 0, DateTime.UtcNow); } } } return(code); }
protected override void Dispose(bool disposing) { if (!base._disposed) { Module.Trace.TraceVerbose($"TcAdsSyncPort.Dispose({this._id:d}); disposing={disposing.ToString()}"); if (disposing) { if (this._notificationMngt != null) { this._notificationMngt.Dispose(); this._notificationMngt = null; } if (this._routerSyncWindow != null) { this._routerSyncWindow.Dispose(); this._routerSyncWindow = null; } if (this._symbolTable != null) { this._symbolTable.Dispose(); this._symbolTable = null; } } AdsErrorCode code = this.OnClosePort(); base.Dispose(disposing); } }
protected override void OnAfterWriteState(StateInfo adsState, AdsErrorCode result) { foreach (ICommunicationInterceptHandler handler in this._list) { handler.AfterWriteState(adsState, result); } }
protected override void OnAfterDisconnect(AdsErrorCode errorCode) { foreach (ICommunicationInterceptHandler handler in this._list) { handler.AfterDisconnect(errorCode); } }
public AdsErrorCode TryCreateHandles(out ISumHandleCollection handles) { IList <SumDataEntity> sumEntities = this.CreateSumEntityInfos(); handles = null; AdsErrorCode[] returnCodes = null; List <byte[]> writeData = new List <byte[]>(); IList <byte[]> readData = null; foreach (InstancePathSumEntity entity in sumEntities) { writeData.Add(entity.GetWriteBytes()); } base.innerCommand = new SumReadWrite(this._connection, sumEntities, TwinCAT.Ads.SumCommand.SumCommand.SumAccessMode.AquireHandleByName); AdsErrorCode code = base.innerCommand.TryReadWriteRaw(writeData, out readData, out returnCodes); if (code == AdsErrorCode.NoError) { handles = new SumHandleList(); for (int i = 0; i < sumEntities.Count; i++) { uint handle = 0; if (returnCodes[i] == AdsErrorCode.NoError) { handle = BitConverter.ToUInt32(readData[i], 0); } handles.Add(new SumHandleInstancePathEntry(this._instancePaths[i], handle, returnCodes[i])); } } return(code); }
public AdsErrorCode TryCreateHandles(out ISumHandleCollection handles) { IList <SumDataEntity> list = this.CreateSumEntityInfos(); handles = null; AdsErrorCode[] returnCodes = null; IList <byte[]> readData = null; int[] readDataSizes = null; AdsErrorCode code = base.Execute(null, out readData, out readDataSizes, out returnCodes); if (code == AdsErrorCode.NoError) { handles = new SumHandleList(); for (int i = 0; i < list.Count; i++) { uint notificationHandle = 0; if (returnCodes[i] == AdsErrorCode.NoError) { notificationHandle = BitConverter.ToUInt32(readData[i], 0); } handles.Add(new SumNotificationHandleEntry(this._variableHandles[i], notificationHandle, returnCodes[i])); } } return(code); }
private TcLocalSystem(TransportProtocol protocol) { object[] args = new object[] { this.GetHashCode() }; using (new MethodTrace("ID: {0:d})", args)) { if (protocol == TransportProtocol.All) { this._port = this.AdsPortOpen(); } else { if (protocol != TransportProtocol.Router) { throw new NotSupportedException("Enforced Tcp/IP Transport not available yet!"); } this._port = this.AdsPortOpenEx(); } this._routerPort = this._port >= 0x8000; if (this._port == 0) { ThrowAdsException(AdsErrorCode.ClientPortNotOpen); } this._refCount = 0; this._amsRouterNotificationDelegate = new TcAdsDllWrapper.AmsRouterNotificationDelegate(this.OnRouterNotification); base.address = new AmsAddress(base.GetLocalNetId(), AmsPort.SystemService); this.UpdateRouterState(); AdsErrorCode code = this.AmsRegisterRouterNotification(this._amsRouterNotificationDelegate, false); this._routerNotificationsRegistered = code == AdsErrorCode.NoError; } }
public DisposableNotificationExHandleBag(IAdsConnection client, IDictionary <string, AnyTypeSpecifier> dict, NotificationSettings settings, object userData) : base(client) { if (dict == null) { throw new ArgumentNullException("dict"); } if (dict.Count == 0) { throw new ArgumentOutOfRangeException("dict"); } base.handleDict = new SumHandleList(); base.validHandleDict = new Dictionary <string, uint>(); foreach (KeyValuePair <string, AnyTypeSpecifier> pair in dict) { uint handle = 0; AnyTypeSpecifier specifier = pair.Value; Type tp = null; int[] args = null; specifier.GetAnyTypeArgs(out tp, out args); AdsErrorCode errorCode = client.TryAddDeviceNotificationEx(pair.Key, settings, userData, tp, args, out handle); base.handleDict.Add(new SumHandleInstancePathEntry(pair.Key, handle, errorCode)); if (errorCode == AdsErrorCode.NoError) { base.validHandleDict.Add(pair.Key, handle); } } }
public AdsErrorCode BeforeDisconnect(Func <AdsErrorCode> action) { AdsErrorCode code = action(); ((ICommunicationInterceptHandler)this).BeforeDisconnect(); return(code); }
private void UpdateRouterState() { bool enabled = false; if (!base._disposed) { try { if (this.AmsPortEnabled(false, out enabled) == AdsErrorCode.NoError) { if (enabled) { this._routerState = AmsRouterState.Start; } else { StateInfo info; AdsErrorCode code = this.ReadState(false, out info); this._routerState = AmsRouterState.Stop; if (code == AdsErrorCode.PortNotConnected) { this._routerState = AmsRouterState.Removed; } } } } catch (Exception exception) { Module.Trace.TraceError(exception); } } }
public virtual NotificationEntry DeleteNotification(int notificationHandle, out AdsErrorCode result) { result = AdsErrorCode.NoError; NotificationEntry entry = null; Dictionary <int, NotificationEntry> dictionary = this._notificationTable; lock (dictionary) { if (this._notificationTable.ContainsKey(notificationHandle)) { entry = this._notificationTable[notificationHandle]; } } if (entry == null) { result = AdsErrorCode.ClientRemoveHash; return(null); } Dictionary <int, NotificationEntry> dictionary2 = this._notificationTable; lock (dictionary2) { this._notificationTable.Remove(notificationHandle); } return(entry); }
protected override void OnAfterWriteState(TwinCAT.Ads.StateInfo adsState, AdsErrorCode result) { if (result == AdsErrorCode.NoError) { this.setAdsState(adsState); } }
public LostCommunicationState(TimeSpan timeout, AdsErrorCode causingError) : base(timeout) { this._lostTime = DateTime.UtcNow; this._error = causingError; object[] args = new object[] { causingError }; Module.TraceSession.TraceInformation("FailFastHandlerInterceptor --> Lost (Caused by '{0}')", args); }
public DisposableNotificationHandleBag(IAdsConnection client, IEnumerable <ISymbol> symbols, NotificationSettings settings, object userData) : base(client) { if (symbols == null) { throw new ArgumentNullException("dict"); } int length = Enumerable.Sum <ISymbol>(symbols, s => s.ByteSize); this._stream = new AdsStream(length); base.handleDict = new SumHandleList(); this._handleSymbolDict = new Dictionary <uint, ISymbol>(); base.validHandleDict = new Dictionary <string, uint>(); int offset = 0; foreach (ISymbol symbol in symbols) { uint handle = 0; int byteSize = symbol.ByteSize; AdsErrorCode errorCode = client.TryAddDeviceNotification(symbol.InstancePath, this._stream, offset, byteSize, settings, userData, out handle); base.handleDict.Add(new SumHandleInstancePathEntry(symbol.InstancePath, handle, errorCode)); if (errorCode == AdsErrorCode.NoError) { base.validHandleDict.Add(symbol.InstancePath, handle); this._handleSymbolDict.Add(handle, symbol); } offset += byteSize; } }
public AdsErrorCode InjectError(AdsErrorCode error, bool throwAdsException) { if (throwAdsException) { ThrowAdsException(error); } return(error); }
private static AdsErrorException CreateException(string message, AdsErrorCode adsErrorCode) { if (adsErrorCode == AdsErrorCode.NoError) { throw new ArgumentException("No error indicated!", "adsErrorCode"); } return(new AdsErrorException(ResMan.GetString(message, adsErrorCode), adsErrorCode)); }
public AdsErrorCode AdsWriteRes(AmsAddress rAddr, uint invokeId, AdsErrorCode result) { TcAdsWriteResHeader adsHeader = new TcAdsWriteResHeader { _result = result }; return(this.AdsResponse(rAddr, invokeId, 3, 0, adsHeader, null)); }
public AdsErrorCode InjectError(AdsErrorCode error, bool throwAdsException) { AdsErrorCode noError = AdsErrorCode.NoError; Func <AdsErrorCode> del = () => ((IAdsErrorInjector)this._inner).InjectError(error, false); noError = this.Invoke(del); this.CheckResult(throwAdsException, noError); return(noError); }
public override void GetObjectData(SerializationInfo info, StreamingContext context) { if (info == null) { throw new ArgumentNullException("info"); } this._errorCode = (AdsErrorCode)info.GetInt32("ErrorCode"); this.GetObjectData(info, context); }
public void Connect() { AdsErrorCode adsErrorCode = this.OnOpenPort(); if (adsErrorCode != AdsErrorCode.NoError) { ThrowAdsException(adsErrorCode); } }
public void Disconnect() { AdsErrorCode adsErrorCode = this.OnClosePort(); if (adsErrorCode != AdsErrorCode.NoError) { ThrowAdsException(adsErrorCode); } }
public override int TryWriteArrayElementValue(ISymbol arraySymbol, int[] indices, byte[] value, int valOffset, out DateTime writeTime) { if (this.Connection == null) { throw new AdsException("Connection not established!"); } if (arraySymbol == null) { throw new ArgumentNullException("arraySymbol"); } AdsErrorCode noError = AdsErrorCode.NoError; IArrayType arrayType = null; IResolvableType dataType = arraySymbol.DataType as IResolvableType; arrayType = (dataType == null) ? (arraySymbol.DataType as IArrayType) : (dataType.ResolveType(DataTypeResolveStrategy.AliasReference) as IArrayType); if (arrayType == null) { throw new ArgumentException("Is not an array type", "arraySymbol"); } ValueAccessMode mode = this.calcAccessMethod(arraySymbol); writeTime = DateTime.MinValue; if ((indices == null) || (indices.Length == 0)) { int byteSize = arraySymbol.ByteSize; IAdsSymbol symbol2 = (IAdsSymbol)Symbol.Unwrap(arraySymbol); if (value.Length != byteSize) { throw new ArgumentException("Value array size mismatch!", "value"); } if (mode == ValueAccessMode.IndexGroupOffset) { noError = this.Connection.RawInterface.Write(symbol2.IndexGroup, symbol2.IndexOffset, valOffset, byteSize, value, false); } } else { ArrayType.CheckIndices(indices, arrayType, false); int elementOffset = ArrayType.GetElementOffset(indices, arrayType); int byteSize = arrayType.ElementType.ByteSize; if (mode != ValueAccessMode.IndexGroupOffset) { noError = this.TryWriteSymbolic(arraySymbol, valOffset, byteSize, value); } else { IAdsSymbol symbol = (IAdsSymbol)Symbol.Unwrap(arraySymbol); noError = this.Connection.RawInterface.Write(symbol.IndexGroup, symbol.IndexOffset + ((uint)elementOffset), valOffset, byteSize, value, false); } } if (noError != AdsErrorCode.NoError) { writeTime = DateTime.UtcNow; } return((int)noError); }
protected override unsafe AdsErrorCode GetLocalAddress(byte *data, bool throwAdsException) { AdsErrorCode adsErrorCode = TcAdsDllWrapper.UnsafeNativeMethods.AdsGetLocalAddressEx(base._port, (void *)data); if ((adsErrorCode != AdsErrorCode.NoError) & throwAdsException) { ThrowAdsException(adsErrorCode); } return(adsErrorCode); }
protected override AdsErrorCode SetTimeout(int timeout, bool throwAdsException) { AdsErrorCode adsErrorCode = TcAdsDllWrapper.UnsafeNativeMethods.AdsSyncSetTimeoutEx(base._port, timeout); if ((adsErrorCode != AdsErrorCode.NoError) & throwAdsException) { ThrowAdsException(adsErrorCode); } return(adsErrorCode); }
public void WriteRaw(IList <byte[]> writeData) { AdsErrorCode[] returnCodes = null; AdsErrorCode code = this.TryWriteRaw(writeData, out returnCodes); if (base.Failed) { throw new AdsSumCommandException("SumWriteCommand failed!", this); } }