public ReceiveStream(signals.EType type, signals.IEPRecvFrom recv) { m_type = type; m_recv = recv; m_thread = new Thread(new ThreadStart(start)); m_thread.IsBackground = true; m_thread.Start(); }
private void OnChanged(signals.IAttribute attr, object value) { lock(st_screenLock) { if (value == null) { Console.Out.WriteLine(String.Format("{0}: null", attr.Name)); } else { Console.Out.WriteLine(String.Format("{0}: ({1}){2}", attr.Name, value.GetType().Name, value)); } } }
public Vector(signals.EType type, ITypeMarshaller inner) { enumType = type; innerType = inner; }
public Complex(signals.EType type) { enumType = type; }
public static ITypeMarshaller getTypeInfo(signals.EType typ) { switch (typ) { case signals.EType.String: return new String(); case signals.EType.WinHdl: return new Handle(); case signals.EType.Boolean: return new Boolean(); case signals.EType.VecBoolean: return new Vector(typ, new Boolean()); case signals.EType.Byte: return new Byte(); case signals.EType.VecByte: return new Vector(typ, new Byte()); case signals.EType.Short: return new Short(); case signals.EType.VecShort: return new Vector(typ, new Short()); case signals.EType.Long: return new Long(); case signals.EType.VecLong: return new Vector(typ, new Long()); case signals.EType.Int64: return new Int64(); case signals.EType.VecInt64: return new Vector(typ, new Int64()); case signals.EType.Single: return new Single(); case signals.EType.VecSingle: return new Vector(typ, new Single()); case signals.EType.Double: return new Double(); case signals.EType.VecDouble: return new Vector(typ, new Double()); case signals.EType.Complex: case signals.EType.LRSingle: return new Complex(typ); case signals.EType.VecComplex: return new Vector(typ, new Complex(signals.EType.Complex)); case signals.EType.VecLRSingle: return new Vector(typ, new Complex(signals.EType.LRSingle)); case signals.EType.CmplDbl: return new ComplexDouble(); case signals.EType.VecCmplDbl: return new Vector(typ, new ComplexDouble()); default: return null; } }
public bool WriteOne(signals.EType type, object val, int msTimeout) { if (val == null) throw new ArgumentNullException("val"); if (type != m_sendType || m_sendTypeInfo == null) { m_sendType = type; m_sendTypeInfo = ProxyTypes.getTypeInfo(type); if (m_sendTypeInfo == null) throw new NotSupportedException("Cannot retrieve value for this type."); } Array pinArray = m_sendTypeInfo.toPinnableArray(new object[] { val }); GCHandle pin = GCHandle.Alloc(pinArray, GCHandleType.Pinned); try { return m_nativeSend.WriteOne(type, pin.AddrOfPinnedObject(), (uint)msTimeout); } finally { pin.Free(); } }
public CppProxyOutputFunction(signals.IModule module, IntPtr native) : base(module, native) { m_nativeSendRef = new IntPtr(native.ToInt64() + IntPtr.Size); m_nativeSend = (Native.IEPSendTo)CppNativeProxy.CreateCallout(m_nativeSendRef, typeof(Native.IEPSendTo)); m_nativeSend.AddRef(IntPtr.Zero); }
// Self created methods private void send_data_toArduino(signals signal) { serial_setup_andSend(signal); toolStripStatusLabel1.Text = "Signal '" + signal + "' toggle sent to Arduino"; //display actual statusStrip1.Refresh(); //send address "a" off signal to LED32 }
public object ReadOne(signals.EType type, int msTimeout) { if (type != m_recvType || m_recvTypeInfo == null) { m_recvType = type; m_recvTypeInfo = ProxyTypes.getTypeInfo(type); if (m_recvTypeInfo == null) throw new NotSupportedException("Cannot retrieve value for this type."); } Array pinArray = m_recvTypeInfo.makePinnableArray(1); GCHandle pin = GCHandle.Alloc(pinArray, GCHandleType.Pinned); bool read; try { read = m_nativeRecv.ReadOne(type, pin.AddrOfPinnedObject(), (uint)msTimeout); } finally { pin.Free(); } return read ? m_recvTypeInfo.fromPinnableArray(pinArray, 1).GetValue(0) : null; }
public void Read(signals.EType type, out Array values, bool bReadAll, int msTimeout) { if (type != m_recvType || m_recvTypeInfo == null) { m_recvType = type; m_recvTypeInfo = ProxyTypes.getTypeInfo(type); if (m_recvTypeInfo == null) throw new NotSupportedException("Cannot retrieve value for this type."); } Array pinArray = m_recvTypeInfo.makePinnableArray(BufferSize); GCHandle pin = GCHandle.Alloc(pinArray, GCHandleType.Pinned); uint read; try { read = m_nativeRecv.Read(type, pin.AddrOfPinnedObject(), (uint)BufferSize, bReadAll, (uint)msTimeout); } finally { pin.Free(); } values = m_recvTypeInfo.fromPinnableArray(pinArray, (int)read); }
public CppProxyInputFunction(signals.IModule module, IntPtr native) : base(native) { if (module == null) throw new ArgumentNullException("module"); if (native == IntPtr.Zero) throw new ArgumentNullException("native"); m_module = module; m_nativeRecvRef = new IntPtr(native.ToInt64() + IntPtr.Size); m_nativeRecv = (Native.IEPRecvFrom)CppNativeProxy.CreateCallout(m_nativeRecvRef, typeof(Native.IEPRecvFrom)); }
public CppProxyFunction(signals.IFunctionSpec spec, IntPtr native) { if (spec == null) throw new ArgumentNullException("spec"); if (native == IntPtr.Zero) throw new ArgumentNullException("native"); m_nativeRef = native; m_spec = spec; Registration.storeObject(native, this); m_native = (Native.IFunction)CppNativeProxy.CreateCallout(native, typeof(Native.IFunction)); }
public int Write(signals.EType type, Array values, int msTimeout) { if (values == null) throw new ArgumentNullException("values"); if (type != m_type || m_typeInfo == null) { m_type = type; m_typeInfo = ProxyTypes.getTypeInfo(type); if (m_typeInfo == null) throw new NotSupportedException("Cannot retrieve value for this type."); } Array pinArray = m_typeInfo.toPinnableArray(values); GCHandle pin = GCHandle.Alloc(pinArray, GCHandleType.Pinned); try { return (int)m_native.Write(type, pin.AddrOfPinnedObject(), (uint)values.Length, (uint)msTimeout); } finally { pin.Free(); } }
public CppProxyEPSender(signals.IBlockDriver driver, IntPtr native) { if (driver == null) throw new ArgumentNullException("driver"); if (native == IntPtr.Zero) throw new ArgumentNullException("native"); m_driver = driver; m_nativeRef = native; Registration.storeObject(native, this); m_native = (Native.IEPSendTo)CppNativeProxy.CreateCallout(native, typeof(Native.IEPSendTo)); m_native.AddRef(IntPtr.Zero); }
private void serial_setup_andSend(signals signal) { if (!serialPort1.IsOpen) { try { serialPort1.Open(); serialPort1.Write(signal.ToString()); toolStripStatusLabel2.Text = serialPort1.ReadLine(); serialPort1.Close(); } catch { MessageBox.Show("There was an error. Please make sure that the correct port was selected, and the device, plugged in."); } } }
public IEnumerator<signals.IAttribute> Itemize(signals.EAttrEnumFlags flags) { uint numAttr = m_native.Itemize(IntPtr.Zero, 0, (uint)flags); if (numAttr == 0) return ((IList<signals.IAttribute>)new signals.IAttribute[0]).GetEnumerator(); IntPtr[] ptrArr = new IntPtr[numAttr]; GCHandle pin = GCHandle.Alloc(ptrArr, GCHandleType.Pinned); uint numObj; try { numObj = m_native.Itemize(pin.AddrOfPinnedObject(), numAttr, (uint)flags); } finally { pin.Free(); } signals.IAttribute[] attrArray = new signals.IAttribute[numObj]; for (int idx = 0; idx < numObj; idx++) { if (ptrArr[idx] != IntPtr.Zero) { signals.IAttribute newObj = (signals.IAttribute)Registration.retrieveObject(ptrArr[idx]); if (newObj == null) newObj = new CppProxyAttribute(ptrArr[idx]); attrArray[idx] = newObj; } } return ((IList<signals.IAttribute>)attrArray).GetEnumerator(); }
public CppProxyBlock(signals.IBlockDriver driver, signals.IBlock parent, IntPtr native) { if (driver == null) throw new ArgumentNullException("driver"); if (native == IntPtr.Zero) throw new ArgumentNullException("native"); m_nativeRef = native; m_driver = driver; m_parent = parent; Registration.storeObject(native, this); m_native = (Native.IBlock)CppNativeProxy.CreateCallout(native, typeof(Native.IBlock)); interrogate(); }
public CppProxyOutEndpoint(signals.IModule module, IntPtr native) { if (module == null) throw new ArgumentNullException("module"); if (native == IntPtr.Zero) throw new ArgumentNullException("native"); m_module = module; m_nativeRef = native; Registration.storeObject(native, this); m_native = (Native.IOutEndpoint)CppNativeProxy.CreateCallout(native, typeof(Native.IOutEndpoint)); interrogate(); }
private void OnAttrValueChanged(signals.IAttribute attr, object value) { if (attr == mBoundAttr) { Action action = delegate() { Value = Convert.ToInt64(value); }; if (InvokeRequired) { Invoke(action); } else { action(); } } }
public bool Connect(signals.IEPSendTo recv) { { CppProxyEPSender proxy = recv as CppProxyEPSender; if (proxy != null) { return m_native.Connect(proxy.Native); } } { CppProxyBuffer proxy = recv as CppProxyBuffer; if (proxy != null) { return m_native.Connect(proxy.NativeSender); } } { CppProxyOutputFunction proxy = recv as CppProxyOutputFunction; if (proxy != null) { return m_native.Connect(proxy.NativeSender); } } throw new NotSupportedException("Native connections not yet implemented."); }