internal void Remove(CARecord record)
 {
     lock (records)
     {
         records.Remove(record.Name);
     }
 }
        static public DataPacket Encode(EpicsType type, object value, CARecord record, int nbElements = 1)
        {
            DataPacket res = DataPacket.Create(16 + 424);

            res.DataCount = 1;
            res.DataType  = (ushort)type;

            res.SetInt16(16, (short)record.AlarmStatus);
            res.SetInt16(16 + 2, (short)record.CurrentAlarmSeverity);

            string[] names = Enum.GetNames(value.GetType());
            res.SetInt16(16 + 4, (short)names.Length);
            res.SetInt16(16 + 422, Convert.ToInt16(value));

            for (int i = 0; i < names.Length; i++)
            {
                res.SetDataAsString(
                    names[i],
                    6 + i * 26,
                    26
                    );
            }

            return(res);
        }
 internal void Add(CARecord record)
 {
     lock (records)
     {
         records.Add(record.Name, record);
     }
 }
        static public DataPacket Encode(EpicsType type, object source, CARecord record, int nbElements = 1)
        {
            switch (type)
            {
            case EpicsType.Byte:
            case EpicsType.Short:
            case EpicsType.Int:
            case EpicsType.Float:
            case EpicsType.Double:
            case EpicsType.String:
                return(SimpleChannel.Encode(type, source, record, nbElements));

            case EpicsType.Status_Byte:
            case EpicsType.Status_Short:
            case EpicsType.Status_Int:
            case EpicsType.Status_Float:
            case EpicsType.Status_Double:
            case EpicsType.Status_String:
                return(ExtChannel.Encode(type, source, record, nbElements));

            case EpicsType.Time_Byte:
            case EpicsType.Time_Short:
            case EpicsType.Time_Int:
            case EpicsType.Time_Float:
            case EpicsType.Time_Double:
            case EpicsType.Time_String:
                return(TimeChannel.Encode(type, source, record, nbElements));

            case EpicsType.Control_Byte:
            case EpicsType.Control_Short:
            case EpicsType.Control_Int:
            case EpicsType.Control_Float:
            case EpicsType.Control_Double:
            case EpicsType.Control_String:
                return(ControlChannel.Encode(type, source, record, nbElements));

            case EpicsType.Display_Byte:
            case EpicsType.Display_Short:
            case EpicsType.Display_Int:
            case EpicsType.Display_Float:
            case EpicsType.Display_Double:
            case EpicsType.Display_String:
                return(DisplayChannel.Encode(type, source, record, nbElements));

            case EpicsType.Labeled_Enum:
                return(EnumControlChannel.Encode(type, source, record, nbElements));

            default:
                throw new Exception("Not yet supported");
            }
        }
Ejemplo n.º 5
0
        static public DataPacket Encode(EpicsType type, object value, CARecord record, int nbElements = 1)
        {
            int size     = 12;
            int startPos = 0;

            switch (type)
            {
            case EpicsType.Time_Double:
                size    += 4 + nbElements * 8;
                startPos = 4;
                break;

            case EpicsType.Time_Byte:
                size    += 3 + nbElements;
                startPos = 3;
                break;

            case EpicsType.Time_Int:
            case EpicsType.Time_Float:
                size    += nbElements * 4;
                startPos = 0;
                break;

            case EpicsType.Time_Short:
                size    += 2 + nbElements * 2;
                startPos = 2;
                break;

            case EpicsType.Time_String:
                startPos = 0;
                size    += 40;
                break;

            default:
                break;
            }
            size += DataPacketBuilder.Padding(size);

            DataPacket res = DataPacket.Create(16 + size);

            res.DataCount = (uint)nbElements;
            res.DataType  = (ushort)type;

            res.SetInt16(16, (short)record.AlarmStatus);
            res.SetInt16(16 + 2, (short)record.CurrentAlarmSeverity);
            res.SetDateTime(16 + 4, DateTime.Now);

            DataPacketBuilder.Encode(res, type, 12 + startPos, value, nbElements);
            return(res);
        }
        internal void RegisterEvent(CAServer server, uint sid, uint subscriptionId, int dataCount, Constants.EpicsType type)
        {
            CARecord record   = ((ServerTcpReceiver)this.Pipe.FirstFilter).FindRecord(server, sid);
            string   property = ((ServerTcpReceiver)this.Pipe.FirstFilter).FindProperty(server, sid);

            DataPacket response = DataPacketBuilder.Encode(
                type,
                record[property],
                record,
                dataCount
                );

            response.Command    = (ushort)CommandID.CA_PROTO_EVENT_ADD;
            response.Parameter1 = 1;
            response.Parameter2 = (uint)subscriptionId;
            ((TcpReceiver)this.Pipe.FirstFilter).Send(response);

            EventHandler newEvent = delegate(object obj, EventArgs evt)
            {
                if (!record.IsDirty)
                {
                    return;
                }
                DataPacket p = DataPacketBuilder.Encode(type, record[property], record, dataCount);
                p.Command    = (ushort)CommandID.CA_PROTO_EVENT_ADD;
                p.Parameter1 = 1;
                p.Parameter2 = (uint)subscriptionId;
                ((TcpReceiver)this.Pipe.FirstFilter).Send(p);
            };

            record.RecordProcessed += newEvent;

            lock (subscribedEvents)
            {
                subscribedEvents.Add(
                    subscriptionId,
                    new EpicsEvent {
                    Handler   = newEvent,
                    Record    = record,
                    DataCount = dataCount,
                    EpicsType = type,
                    SID       = sid
                }
                    );
            }
        }
Ejemplo n.º 7
0
        internal void RegisterEvent(CAServer server, uint sid, uint subscriptionId, int nbElements, EpicsType type, MonitorMask mask)
        {
            CARecord record   = ((ServerTcpReceiver)this.Pipe.FirstFilter).FindRecord(server, sid);
            string   property = ((ServerTcpReceiver)this.Pipe.FirstFilter).FindProperty(server, sid);

            DataPacket response = DataPacketBuilder.Encode(type, record[property], record, (nbElements == 0) ? record.ElementsInRecord : Math.Min(nbElements, record.ElementsInRecord));

            response.Command    = (ushort)CommandID.CA_PROTO_EVENT_ADD;
            response.Parameter1 = 1;
            response.Parameter2 = (uint)subscriptionId;
            ((TcpReceiver)this.Pipe.FirstFilter).Send(response);

            var          lastStatus = record.AlarmStatus;
            EventHandler newEvent   = delegate(object obj, EventArgs evt)
            {
                if (!record.IsDirty)
                {
                    return;
                }
                // We have a alarm mask, if the status didn't change, don't send the event
                if (mask == MonitorMask.ALARM && lastStatus == record.AlarmStatus)
                {
                    return;
                }
                lastStatus = record.AlarmStatus;
                DataPacket p = DataPacketBuilder.Encode(type, record[property], record, (nbElements == 0) ? record.ElementsInRecord : Math.Min(nbElements, record.ElementsInRecord));
                p.Command    = (ushort)CommandID.CA_PROTO_EVENT_ADD;
                p.Parameter1 = 1;
                p.Parameter2 = (uint)subscriptionId;
                ((TcpReceiver)this.Pipe.FirstFilter).Send(p);
            };

            record.RecordProcessed += newEvent;

            lock (subscribedEvents)
            {
                subscribedEvents.Add(subscriptionId, new EpicsEvent {
                    Handler = newEvent, Record = record, DataCount = nbElements, EpicsType = type, SID = sid
                });
            }
        }
        static public DataPacket Encode(EpicsType type, object value, CARecord record, int nbElements = 1)
        {
            int size = 0;

            switch (type)
            {
            case EpicsType.Double:
                size += 4 + nbElements * 8;
                break;

            case EpicsType.Byte:
                size += nbElements;
                break;

            case EpicsType.Int:
            case EpicsType.Float:
                size += nbElements * 4;
                break;

            case EpicsType.Short:
                size += nbElements * 2;
                break;

            case EpicsType.String:
                size += 40;
                break;

            default:
                break;
            }

            DataPacket res = DataPacket.Create(16 + size + DataPacketBuilder.Padding(size));

            res.DataCount = (uint)nbElements;
            res.DataType  = (ushort)type;
            DataPacketBuilder.Encode(res, type, 0, value, nbElements);
            return(res);
        }
Ejemplo n.º 9
0
        private object MapPacketValueToRecordType(DataPacket packet, CARecord record, string property)
        {
            object obj          = ExtractValueFromPacket(packet);
            Type   destType     = record.GetPropertyType(property);
            string destTypeName = destType.ToString();

            if (destType.IsGenericType)
            {
                destTypeName = destType.GenericTypeArguments[0].ToString();
            }
            switch (destTypeName)
            {
            case "System.String":
                return(Convert.ToString(obj, System.Globalization.CultureInfo.InvariantCulture));

            case "System.Int32":
                if (packet.DataCount == 1 && !destType.IsGenericType && !destType.IsArray)
                {
                    return(Convert.ToInt32(obj));
                }
                else
                {
                    dynamic d = obj;
                    int[]   t = new int[packet.DataCount];
                    for (var i = 0; i < packet.DataCount; i++)
                    {
                        t[i] = Convert.ToInt32(d[i]);
                    }
                    return(t);
                }

            case "System.Byte":
                if (packet.DataCount == 1 && !destType.IsGenericType && !destType.IsArray)
                {
                    return(Convert.ToByte(obj));
                }
                else
                {
                    dynamic d = obj;
                    byte[]  t = new byte[packet.DataCount];
                    for (var i = 0; i < packet.DataCount; i++)
                    {
                        t[i] = Convert.ToByte(d[i]);
                    }
                    return(t);
                }

            case "System.Int16":
                if (packet.DataCount == 1 && !destType.IsGenericType && !destType.IsArray)
                {
                    return(Convert.ToInt16(obj));
                }
                else
                {
                    dynamic d = obj;
                    short[] t = new short[packet.DataCount];
                    for (var i = 0; i < packet.DataCount; i++)
                    {
                        t[i] = Convert.ToInt16(d[i]);
                    }
                    return(t);
                }

            case "System.Single":
                if (packet.DataCount == 1 && !destType.IsGenericType && !destType.IsArray)
                {
                    return(Convert.ToSingle(obj));
                }
                else
                {
                    dynamic d = obj;
                    float[] t = new float[packet.DataCount];
                    for (var i = 0; i < packet.DataCount; i++)
                    {
                        t[i] = Convert.ToSingle(d[i]);
                    }
                    return(t);
                }

            case "System.Double":
                if (packet.DataCount == 1 && !destType.IsGenericType && !destType.IsArray)
                {
                    return(Convert.ToDouble(obj));
                }
                else
                {
                    dynamic  d = obj;
                    double[] t = new double[packet.DataCount];
                    for (var i = 0; i < packet.DataCount; i++)
                    {
                        t[i] = Convert.ToDouble(d[i]);
                    }
                    return(t);
                }
            }
            throw new Exception($"Cannot map packet type {packet.DataType} to {destTypeName}");
        }
Ejemplo n.º 10
0
        static public DataPacket Encode(EpicsType type, object value, CARecord record, int nbElements = 1)
        {
            int size     = 0;
            int startPos = 0;

            switch (type)
            {
            case EpicsType.Control_Double:
                size    += 8 + 8 + 8 * 8 + nbElements * 8;
                startPos = 8 + 8 + 8 * 8;
                break;

            case EpicsType.Control_Byte:
                size    += 4 + 8 + 8 + 1 + nbElements;
                startPos = 4 + 8 + 8 + 1;
                break;

            case EpicsType.Control_Int:
                size    += 4 + 8 + 8 * 4 + nbElements * 4;
                startPos = 4 + 8 + 8 * 4;
                break;

            case EpicsType.Control_Float:
                size    += 8 + 8 + 8 * 4 + nbElements * 4;
                startPos = 8 + 8 + 8 * 4;
                break;

            case EpicsType.Control_Short:
                size    += 4 + 8 + 8 * 2 + nbElements * 2;
                startPos = 4 + 8 + 8 * 2;
                break;

            case EpicsType.Control_String:
                startPos = 4;
                size    += 40;
                break;

            default:
                break;
            }
            size += DataPacketBuilder.Padding(size);

            DataPacket res = DataPacket.Create(16 + size);

            res.DataCount = (uint)nbElements;
            res.DataType  = (ushort)type;

            res.SetInt16(16, (short)record.AlarmStatus);
            res.SetInt16(16 + 2, (short)record.CurrentAlarmSeverity);

            switch (type)
            {
            case EpicsType.Control_Double:
                res.SetInt16(16 + 4, (short)((dynamic)record).DisplayPrecision);
                res.SetDataAsString(((dynamic)record).EngineeringUnits, 8, 8);
                res.SetDouble(16 + 8 + 8, (double)((dynamic)record).HighDisplayLimit);
                res.SetDouble(16 + 8 + 8 + 8, (double)((dynamic)record).LowDisplayLimit);
                res.SetDouble(16 + 8 + 8 + 8 * 2, (double)((dynamic)record).HighHighAlarmLimit);
                res.SetDouble(16 + 8 + 8 + 8 * 3, (double)((dynamic)record).HighAlarmLimit);
                res.SetDouble(16 + 8 + 8 + 8 * 4, (double)((dynamic)record).LowAlarmLimit);
                res.SetDouble(16 + 8 + 8 + 8 * 5, (double)((dynamic)record).LowLowAlarmLimit);
                res.SetDouble(16 + 8 + 8 + 8 * 6, (double)((dynamic)record).LowOperatingRange);
                res.SetDouble(16 + 8 + 8 + 8 * 7, (double)((dynamic)record).HighOperatingRange);
                break;

            case EpicsType.Control_Float:
                res.SetInt16(16 + 4, (short)((dynamic)record).DisplayPrecision);
                res.SetDataAsString(((dynamic)record).EngineeringUnits, 8, 8);
                res.SetFloat(16 + 8 + 8, (float)((dynamic)record).HighDisplayLimit);
                res.SetFloat(16 + 8 + 8 + 4, (float)((dynamic)record).LowDisplayLimit);
                res.SetFloat(16 + 8 + 8 + 4 * 2, (float)((dynamic)record).HighHighAlarmLimit);
                res.SetFloat(16 + 8 + 8 + 4 * 3, (float)((dynamic)record).HighAlarmLimit);
                res.SetFloat(16 + 8 + 8 + 4 * 4, (float)((dynamic)record).LowAlarmLimit);
                res.SetFloat(16 + 8 + 8 + 4 * 5, (float)((dynamic)record).LowLowAlarmLimit);
                res.SetFloat(16 + 8 + 8 + 4 * 6, (float)((dynamic)record).LowOperatingRange);
                res.SetFloat(16 + 8 + 8 + 4 * 7, (float)((dynamic)record).HighOperatingRange);
                break;

            case EpicsType.Control_Int:
                res.SetDataAsString(((dynamic)record).EngineeringUnits, 4, 8);
                res.SetInt32(16 + 4 + 8, (int)((dynamic)record).HighDisplayLimit);
                res.SetInt32(16 + 4 + 8 + 4, (int)((dynamic)record).LowDisplayLimit);
                res.SetInt32(16 + 4 + 8 + 4 * 2, (int)((dynamic)record).HighHighAlarmLimit);
                res.SetInt32(16 + 4 + 8 + 4 * 3, (int)((dynamic)record).HighAlarmLimit);
                res.SetInt32(16 + 4 + 8 + 4 * 4, (int)((dynamic)record).LowAlarmLimit);
                res.SetInt32(16 + 4 + 8 + 4 * 5, (int)((dynamic)record).LowLowAlarmLimit);
                res.SetInt32(16 + 4 + 8 + 4 * 6, (int)((dynamic)record).LowOperatingRange);
                res.SetInt32(16 + 4 + 8 + 4 * 7, (int)((dynamic)record).HighOperatingRange);
                break;

            case EpicsType.Control_Short:
                res.SetDataAsString(((dynamic)record).EngineeringUnits, 4, 8);
                res.SetInt16(16 + 4 + 8, (short)((dynamic)record).HighDisplayLimit);
                res.SetInt16(16 + 4 + 8 + 2, (short)((dynamic)record).LowDisplayLimit);
                res.SetInt16(16 + 4 + 8 + 2 * 2, (short)((dynamic)record).HighHighAlarmLimit);
                res.SetInt16(16 + 4 + 8 + 2 * 3, (short)((dynamic)record).HighAlarmLimit);
                res.SetInt16(16 + 4 + 8 + 2 * 4, (short)((dynamic)record).LowAlarmLimit);
                res.SetInt16(16 + 4 + 8 + 2 * 5, (short)((dynamic)record).LowLowAlarmLimit);
                res.SetInt16(16 + 4 + 8 + 2 * 6, (short)((dynamic)record).LowOperatingRange);
                res.SetInt16(16 + 4 + 8 + 2 * 7, (short)((dynamic)record).HighOperatingRange);
                break;

            case EpicsType.Control_Byte:
                res.SetDataAsString(((dynamic)record).EngineeringUnits, 4, 8);
                res.SetByte(16 + 4 + 8, (byte)((dynamic)record).HighDisplayLimit);
                res.SetByte(16 + 4 + 8 + 1, (byte)((dynamic)record).LowDisplayLimit);
                res.SetByte(16 + 4 + 8 + 1 * 2, (byte)((dynamic)record).HighHighAlarmLimit);
                res.SetByte(16 + 4 + 8 + 1 * 3, (byte)((dynamic)record).HighAlarmLimit);
                res.SetByte(16 + 4 + 8 + 1 * 4, (byte)((dynamic)record).LowAlarmLimit);
                res.SetByte(16 + 4 + 8 + 1 * 5, (byte)((dynamic)record).LowLowAlarmLimit);
                res.SetByte(16 + 4 + 8 + 1 * 6, (byte)((dynamic)record).LowOperatingRange);
                res.SetByte(16 + 4 + 8 + 1 * 7, (byte)((dynamic)record).HighOperatingRange);
                break;

            default:
                break;
            }

            DataPacketBuilder.Encode(res, type, startPos, value, nbElements);
            return(res);
        }