Beispiel #1
0
        public List <Point> ConvertToPoints(List <dnp3_protocol.dnp3types.sServerDatabasePoint> mangagedArray)
        {
            var list = new List <Point>();

            foreach (var item in mangagedArray)
            {
                if (item.eGroupID == dnp3_protocol.dnp3types.eDNP3GroupID.ANALOG_INPUT || item.eGroupID == dnp3_protocol.dnp3types.eDNP3GroupID.ANALOG_OUTPUTS)
                {
                    var point = new AnalogPoint()
                    {
                        GroupId   = item.eGroupID,
                        Index     = item.u16IndexNumber,
                        TimeStamp = new DateTime(item.sTimeStamp.u16Year, item.sTimeStamp.u8Month, item.sTimeStamp.u8Day, item.sTimeStamp.u8Hour, item.sTimeStamp.u8Minute, item.sTimeStamp.u8Seconds).ToString()
                    };
                    SingleInt32Union value = new SingleInt32Union(Marshal.ReadInt32(item.pvData, 0));
                    point.Value = CheckAnalogValueExp(value.f, point.GroupId, point.Index);
                    list.Add(point);
                }
                else
                {
                    var point = new BinaryPoint()
                    {
                        GroupId   = item.eGroupID,
                        Index     = item.u16IndexNumber,
                        TimeStamp = new DateTime(item.sTimeStamp.u16Year, item.sTimeStamp.u8Month, item.sTimeStamp.u8Day, item.sTimeStamp.u8Hour, item.sTimeStamp.u8Minute, item.sTimeStamp.u8Seconds).ToString()
                    };
                    SingleInt32Union value = new SingleInt32Union(Marshal.ReadInt32(item.pvData, 0));
                    point.Value = CheckBinaryValueExp(value.i, point.GroupId, point.Index);;
                    list.Add(point);
                }
            }
            return(list);
        }
        private void MainWindowViewModel_applyEvent(object sender, ClickEventArgs e)
        {
            var val = e.Point;

            if (e.Point.GroupId == dnp3_protocol.dnp3types.eDNP3GroupID.ANALOG_INPUT)
            {
                SingleInt32Union value = new SingleInt32Union();
                value.f = (e.Point as AnalogPoint).Value;
                _simulator.UpdatePoint((ushort)e.Point.Index, dnp3_protocol.dnp3types.eDNP3GroupID.ANALOG_INPUT, dnp3_protocol.tgttypes.eDataSizes.FLOAT32_SIZE, dnp3_protocol.tgtcommon.eDataTypes.FLOAT32_DATA, value);
            }
            else if (e.Point.GroupId == dnp3_protocol.dnp3types.eDNP3GroupID.ANALOG_OUTPUTS)
            {
                SingleInt32Union value = new SingleInt32Union();
                value.f = (e.Point as AnalogPoint).Value;
                _simulator.UpdatePoint((ushort)e.Point.Index, dnp3_protocol.dnp3types.eDNP3GroupID.ANALOG_OUTPUTS, dnp3_protocol.tgttypes.eDataSizes.FLOAT32_SIZE, dnp3_protocol.tgtcommon.eDataTypes.FLOAT32_DATA, value);
            }
            else if (e.Point.GroupId == dnp3_protocol.dnp3types.eDNP3GroupID.BINARY_INPUT)
            {
                SingleInt32Union value = new SingleInt32Union();
                value.i = (e.Point as BinaryPoint).Value;
                _simulator.UpdatePoint((ushort)e.Point.Index, dnp3_protocol.dnp3types.eDNP3GroupID.BINARY_INPUT, dnp3_protocol.tgttypes.eDataSizes.SINGLE_POINT_SIZE, dnp3_protocol.tgtcommon.eDataTypes.SINGLE_POINT_DATA, value);
            }
            else if (e.Point.GroupId == dnp3_protocol.dnp3types.eDNP3GroupID.BINARY_OUTPUT)
            {
                SingleInt32Union value = new SingleInt32Union();
                value.i = (e.Point as BinaryPoint).Value;
                _simulator.UpdatePoint((ushort)e.Point.Index, dnp3_protocol.dnp3types.eDNP3GroupID.BINARY_OUTPUT, dnp3_protocol.tgttypes.eDataSizes.SINGLE_POINT_SIZE, dnp3_protocol.tgtcommon.eDataTypes.SINGLE_POINT_DATA, value);
            }
        }
Beispiel #3
0
        private void UpdateRightBranch()
        {
            SingleInt32Union analogValue5 = new SingleInt32Union();

            analogValue5.f = TRCurrent3.Value;
            simulator.UpdatePoint(pairs["Current_Tap3"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue5);

            SingleInt32Union analogValue7 = new SingleInt32Union();

            analogValue7.f = TRVoltage3.Value;
            simulator.UpdatePoint(pairs["Voltage_Tap3"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue7);

            SingleInt32Union analogValue10 = new SingleInt32Union();

            analogValue10.f = tapChanger3.Value;
            simulator.UpdatePoint(pairs["Discrete_Tap3"], dnp3types.eDNP3GroupID.ANALOG_OUTPUTS, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue10);

            SingleInt32Union analogValue11 = new SingleInt32Union();

            analogValue11.f = pump3flow.Value;
            simulator.UpdatePoint(pairs["Flow_AM3"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue11);

            SingleInt32Union analogValue13 = new SingleInt32Union();

            analogValue13.f = pump3temp.Value;
            simulator.UpdatePoint(pairs["Temp_AM3"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue13);

            SingleInt32Union digitalValue9 = new SingleInt32Union();

            digitalValue9.i = breaker13.Value;
            simulator.UpdatePoint(pairs["Breaker_13Status"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue9);

            SingleInt32Union digitalValue11 = new SingleInt32Union();

            digitalValue11.i = breaker23.Value;
            simulator.UpdatePoint(pairs["Breaker_23Status"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue11);

            SingleInt32Union digitalValue13 = new SingleInt32Union();

            digitalValue13.i = dis13.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc13"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue13);

            SingleInt32Union digitalValue15 = new SingleInt32Union();

            digitalValue15.i = dis23.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc23"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue15);
        }
Beispiel #4
0
        private void UpdateLeftBranch()
        {
            SingleInt32Union analogValue = new SingleInt32Union();

            analogValue.f = TRCurrent1.Value;
            simulator.UpdatePoint(pairs["Current_Tap1"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue);

            SingleInt32Union analogValue6 = new SingleInt32Union();

            analogValue6.f = TRVoltage1.Value;
            simulator.UpdatePoint(pairs["Voltage_Tap1"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue6);

            SingleInt32Union analogValue9 = new SingleInt32Union();

            analogValue9.f = tapChanger1.Value;
            simulator.UpdatePoint(pairs["Discrete_Tap1"], dnp3types.eDNP3GroupID.ANALOG_OUTPUTS, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue9);

            SingleInt32Union analogValue12 = new SingleInt32Union();

            analogValue12.f = pump1temp.Value;
            simulator.UpdatePoint(pairs["Temp_AM1"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue12);

            SingleInt32Union analogValue16 = new SingleInt32Union();

            analogValue16.f = pump1flow.Value;
            simulator.UpdatePoint(pairs["Flow_AM1"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue16);

            SingleInt32Union digitalValue8 = new SingleInt32Union();

            digitalValue8.i = breaker11.Value;
            simulator.UpdatePoint(pairs["Breaker_11Status"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue8);

            SingleInt32Union digitalValue10 = new SingleInt32Union();

            digitalValue10.i = breaker21.Value;
            simulator.UpdatePoint(pairs["Breaker_21Status"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue10);

            SingleInt32Union digitalValue12 = new SingleInt32Union();

            digitalValue12.i = dis11.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc11"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue12);

            SingleInt32Union digitalValue14 = new SingleInt32Union();

            digitalValue14.i = dis21.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc21"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue14);
        }
Beispiel #5
0
        private void CheckFluidLevel()
        {
            if (fluidLever.Value < EmptyTank) //EMPTY TENK
            {
                SingleInt32Union digVal = new SingleInt32Union();
                digVal.i = 1;
                simulator.UpdatePoint(pairs["EmptyTank"], dnp3types.eDNP3GroupID.BINARY_INPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digVal);
            }

            if (fluidLever.Value >= EmptyTank && fluidLever.Value <= FullTank)
            {
                SingleInt32Union digVal = new SingleInt32Union();
                digVal.i = 0;
                simulator.UpdatePoint(pairs["EmptyTank"], dnp3types.eDNP3GroupID.BINARY_INPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digVal);
                simulator.UpdatePoint(pairs["FullTank"], dnp3types.eDNP3GroupID.BINARY_INPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digVal);
            }
        }
Beispiel #6
0
        private void OnEveryMinute()
        {
            if (debug)
            {
                if (index == 0 || index > 5)
                {
                    hours = WA.GetForecast();
                    index = 0;
                }
            }
            else
            {
                hours = WA.GetForecast();
            }


            simulator.MarshalUnmananagedArray2Struct(db.psServerDatabasePoint, (int)db.u32TotalPoints, out List <dnp3_protocol.dnp3types.sServerDatabasePoint> points);

            var result = simulator.ConvertToPoints(points);

            var item = result.SingleOrDefault(x => x.GroupId == dnp3types.eDNP3GroupID.ANALOG_INPUT && x.Index == pairs["FluidLevel_Tank"]);

            if (item != null)
            {
                var point = item as AnalogPoint;
                SingleInt32Union analogValue = new SingleInt32Union();

                analogValue.f = (int)(point.Value + (debug?(float)hours[index] / 60 * TankSurface: (float)hours[0] / 60 * TankSurface));
                simulator.UpdatePoint(pairs["FluidLevel_Tank"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue);

                if (point.Value > FullTank)
                {
                    SingleInt32Union digitalValue = new SingleInt32Union();
                    digitalValue.i = 1;
                    simulator.UpdatePoint(pairs["FullTank"], dnp3types.eDNP3GroupID.BINARY_INPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue);
                }
            }
            if (minutesCount == 60)
            {
                minutesCount = 0;
                index++;
            }
        }
Beispiel #7
0
 private void SetValues(List <Point> oldPoints)
 {
     foreach (var item in oldPoints)
     {
         if (item.GroupId == dnp3types.eDNP3GroupID.ANALOG_INPUT || item.GroupId == dnp3types.eDNP3GroupID.ANALOG_OUTPUTS)
         {
             var point = item as AnalogPoint;
             SingleInt32Union analogValue = new SingleInt32Union();
             analogValue.f = point.Value;
             Update(item.Index, item.GroupId, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue, ref ptErrorValue);
         }
         else
         {
             var point = item as BinaryPoint;
             SingleInt32Union binaryValue = new SingleInt32Union();
             binaryValue.i = point.Value;
             Update(item.Index, item.GroupId, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, binaryValue, ref ptErrorValue);
         }
     }
 }
Beispiel #8
0
 public void UpdatePoint(ushort index, dnp3types.eDNP3GroupID group, tgttypes.eDataSizes dataSize, tgtcommon.eDataTypes dataType, SingleInt32Union value)
 {
     Update(index, group, dataSize, dataType, value, ref ptErrorValue);
 }
Beispiel #9
0
        private void Update(ushort index, dnp3_protocol.dnp3types.eDNP3GroupID group, dnp3_protocol.tgttypes.eDataSizes dataSize, dnp3_protocol.tgtcommon.eDataTypes dataType, SingleInt32Union value, ref short ptErrorValue)
        {
            ushort uiCount = 1;

            dnp3_protocol.dnp3types.sDNP3DataAttributeID   psDAID     = new dnp3_protocol.dnp3types.sDNP3DataAttributeID();
            dnp3_protocol.dnp3types.sDNP3DataAttributeData psNewValue = new dnp3_protocol.dnp3types.sDNP3DataAttributeData();
            psDAID.u16SlaveAddress = 1;
            psDAID.eGroupID        = group;
            psDAID.u16IndexNumber  = index;

            psNewValue.eDataSize = dataSize;
            psNewValue.eDataType = dataType;

            psDAID.pvUserData   = IntPtr.Zero;
            psNewValue.tQuality = (ushort)(dnp3_protocol.dnp3types.eDNP3QualityFlags.ONLINE);
            psNewValue.pvData   = System.Runtime.InteropServices.Marshal.AllocHGlobal((int)dataSize);

            DateTime date = DateTime.Now;

            psNewValue.sTimeStamp.u8Day           = (byte)date.Day;
            psNewValue.sTimeStamp.u8Month         = (byte)date.Month;
            psNewValue.sTimeStamp.u16Year         = (ushort)date.Year;
            psNewValue.sTimeStamp.u8Hour          = (byte)date.Hour;
            psNewValue.sTimeStamp.u8Minute        = (byte)date.Minute;
            psNewValue.sTimeStamp.u8Seconds       = (byte)date.Second;
            psNewValue.sTimeStamp.u16MilliSeconds = (ushort)date.Millisecond;
            psNewValue.sTimeStamp.u16MicroSeconds = 0;
            psNewValue.sTimeStamp.i8DSTTime       = 0;
            psNewValue.sTimeStamp.u8DayoftheWeek  = (byte)date.DayOfWeek;

            Marshal.WriteInt32(psNewValue.pvData, value.i);
            iErrorCode = dnp3_protocol.dnp3api.DNP3Update(DNP3serverhandle, ref psDAID, ref psNewValue, uiCount, dnp3_protocol.dnp3types.eUpdateClassID.UPDATE_DEFAULT_EVENT, ref ptErrorValue);
            if (iErrorCode != 0)
            {
                Trace.TraceError("dnp3 Library API Function - DNP3Update() failed: {0:D} {1:D}", iErrorCode, ptErrorValue);
                Trace.TraceError("iErrorCode {0:D}: {1}", iErrorCode, errorcodestring(iErrorCode));
                Trace.TraceError("iErrorValue {0:D}: {1}", ptErrorValue, errorvaluestring(ptErrorValue));
            }
        }
Beispiel #10
0
        private static short cbOperate(ushort u16ObjectId, ref dnp3_protocol.dnp3types.sDNP3DataAttributeID psOperateID, ref dnp3_protocol.dnp3types.sDNP3DataAttributeData psOperateValue, ref dnp3_protocol.dnp3types.sDNP3CommandParameters psOperateParams, ref short ptErrorValue)
        {
            if (psOperateID.eGroupID == dnp3_protocol.dnp3types.eDNP3GroupID.ANALOG_OUTPUTS)
            {
                Trace.TraceInformation("GROUP ID : ANALOG_OUTPUT");
                Trace.TraceInformation("Index Number " + psOperateID.u16IndexNumber);
                psOperateValue.eDataSize = dnp3_protocol.tgttypes.eDataSizes.FLOAT32_SIZE;
                psOperateValue.eDataType = dnp3_protocol.tgtcommon.eDataTypes.FLOAT32_DATA;
                iErrorCode = dnp3_protocol.dnp3api.DNP3Update(DNP3serverhandle, ref psOperateID, ref psOperateValue, 1, dnp3_protocol.dnp3types.eUpdateClassID.UPDATE_NO_CLASS, ref ptErrorValue);
                if (iErrorCode != 0)
                {
                    Trace.TraceError("dnp3 Library API Function - DNP3DirectOperate() failed: {0:D} {1:D}", iErrorCode, ptErrorValue);
                    Trace.TraceError("iErrorCode {0:D}: {1}", iErrorCode, errorcodestring(iErrorCode));
                    Trace.TraceError("iErrorValue {0:D}: {1}", ptErrorValue, errorvaluestring(ptErrorValue));
                    return((short)dnp3_protocol.tgterrorcodes.eTgtErrorCodes.EC_NONE);
                }

                if (psOperateParams.eCommandVariation == dnp3_protocol.dnp3types.eCommandObjectVariation.ANALOG_OUTPUT_BLOCK_FLOAT32)
                {
                    Trace.TraceInformation("Variation : ANALOG_OUTPUT_BLOCK_FLOAT32");
                    SingleInt32Union f32Data;
                    f32Data.f = 0;
                    f32Data.i = System.Runtime.InteropServices.Marshal.ReadInt32(psOperateValue.pvData);
                    Trace.TraceInformation("Data : {0:F3}", f32Data.f);
                }
                else if (psOperateParams.eCommandVariation == dnp3_protocol.dnp3types.eCommandObjectVariation.ANALOG_OUTPUT_BLOCK_INTEGER32)
                {
                    Trace.TraceInformation("Variation : ANALOG_OUTPUT_BLOCK_INTEGER32");
                    Trace.TraceInformation("Data : {0:D}", System.Runtime.InteropServices.Marshal.ReadInt32(psOperateValue.pvData));
                }
                else if (psOperateParams.eCommandVariation == dnp3_protocol.dnp3types.eCommandObjectVariation.ANALOG_OUTPUT_BLOCK_INTEGER16)
                {
                    Trace.TraceInformation("Variation : ANALOG_OUTPUT_BLOCK_INTEGER16");
                    Trace.TraceInformation("Data : {0:D}", System.Runtime.InteropServices.Marshal.ReadInt16(psOperateValue.pvData));
                    SingleInt32Union digitalValue = new SingleInt32Union();
                    digitalValue.f = System.Runtime.InteropServices.Marshal.ReadInt16(psOperateValue.pvData);
                    UpdateMP(psOperateID.u16IndexNumber, dnp3types.eDNP3GroupID.ANALOG_OUTPUTS, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, digitalValue, ref ptErrorValue);
                }
                else
                {
                    Trace.TraceInformation("Invalid variation");
                }
            }

            if (psOperateID.eGroupID == dnp3_protocol.dnp3types.eDNP3GroupID.BINARY_OUTPUT)
            {
                Trace.TraceInformation("GROUP ID : BINARY_OUTPUT");
                Trace.TraceInformation("Index Number " + psOperateID.u16IndexNumber);
                psOperateValue.eDataSize = dnp3_protocol.tgttypes.eDataSizes.SINGLE_POINT_SIZE;
                psOperateValue.eDataType = dnp3_protocol.tgtcommon.eDataTypes.SINGLE_POINT_DATA;
                iErrorCode = dnp3_protocol.dnp3api.DNP3Update(DNP3serverhandle, ref psOperateID, ref psOperateValue, 1, dnp3_protocol.dnp3types.eUpdateClassID.UPDATE_DEFAULT_EVENT, ref ptErrorValue);
                if (iErrorCode != 0)
                {
                    Trace.TraceError("dnp3 Library API Function - DNP3DirectOperate() failed: {0:D} {1:D}", iErrorCode, ptErrorValue);
                    Trace.TraceError("iErrorCode {0:D}: {1}", iErrorCode, errorcodestring(iErrorCode));
                    Trace.TraceError("iErrorValue {0:D}: {1}", ptErrorValue, errorvaluestring(ptErrorValue));
                    return((short)dnp3_protocol.tgterrorcodes.eTgtErrorCodes.EC_NONE);
                }

                if (psOperateParams.eCommandVariation == dnp3_protocol.dnp3types.eCommandObjectVariation.CROB_G12V1)
                {
                    Trace.TraceInformation("Variation : CROB_G12V1");
                }
                else
                {
                    Trace.TraceInformation("Invalid variation");
                }
                SingleInt32Union digitalValue = new SingleInt32Union();
                digitalValue.i = System.Runtime.InteropServices.Marshal.ReadInt16(psOperateValue.pvData) > 1?0:1;
                UpdateMP(psOperateID.u16IndexNumber, dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue, ref ptErrorValue);
                Trace.TraceInformation("Operation Type " + psOperateParams.eOPType);
                Trace.TraceInformation("Count " + psOperateParams.u8Count);
                Trace.TraceInformation("On time " + psOperateParams.u32ONtime);
                Trace.TraceInformation("Off time " + psOperateParams.u32OFFtime);
                Trace.TraceInformation("CR {0}", psOperateParams.bCR);
            }
            Trace.TraceInformation("Date : {0:D}-{1:D}-{2:D}", psOperateValue.sTimeStamp.u8Day, psOperateValue.sTimeStamp.u8Month, psOperateValue.sTimeStamp.u16Year);
            Trace.TraceInformation("Time : {0:D}:{1:D2}:{2:D2}:{3:D3}", psOperateValue.sTimeStamp.u8Hour, psOperateValue.sTimeStamp.u8Minute, psOperateValue.sTimeStamp.u8Seconds, psOperateValue.sTimeStamp.u16MilliSeconds);
            return((short)dnp3_protocol.tgterrorcodes.eTgtErrorCodes.EC_NONE);
        }
Beispiel #11
0
        private void UpdatePoints()
        {
            SingleInt32Union analogValue2 = new SingleInt32Union();

            analogValue2.f = TRCurrent2.Value;
            simulator.UpdatePoint(pairs["Current_Tap2"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue2);

            SingleInt32Union analogValue3 = new SingleInt32Union();

            analogValue3.f = fluidLever.Value;
            simulator.UpdatePoint(pairs["FluidLevel_Tank"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue3);

            SingleInt32Union analogValue4 = new SingleInt32Union();

            analogValue4.f = TRVoltage2.Value;
            simulator.UpdatePoint(pairs["Voltage_Tap2"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue4);

            SingleInt32Union analogValue8 = new SingleInt32Union();

            analogValue8.f = tapChanger2.Value;
            simulator.UpdatePoint(pairs["Discrete_Tap2"], dnp3types.eDNP3GroupID.ANALOG_OUTPUTS, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue8);

            SingleInt32Union analogValue14 = new SingleInt32Union();

            analogValue14.f = pump2flow.Value;
            simulator.UpdatePoint(pairs["Flow_AM2"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue14);

            SingleInt32Union analogValue15 = new SingleInt32Union();

            analogValue15.f = pump2temp.Value;
            simulator.UpdatePoint(pairs["Temp_AM2"], dnp3types.eDNP3GroupID.ANALOG_INPUT, tgttypes.eDataSizes.FLOAT32_SIZE, tgtcommon.eDataTypes.FLOAT32_DATA, analogValue15);

            SingleInt32Union digitalValue = new SingleInt32Union();

            digitalValue.i = breaker01.Value;
            simulator.UpdatePoint(pairs["Breaker_01Status"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue);

            SingleInt32Union digitalValue2 = new SingleInt32Union();

            digitalValue2.i = breaker12.Value;
            simulator.UpdatePoint(pairs["Breaker_12Status"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue2);

            SingleInt32Union digitalValue3 = new SingleInt32Union();

            digitalValue3.i = breaker22.Value;
            simulator.UpdatePoint(pairs["Breaker_22Status"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue3);

            SingleInt32Union digitalValue4 = new SingleInt32Union();

            digitalValue4.i = dis01.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc01"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue4);

            SingleInt32Union digitalValue5 = new SingleInt32Union();

            digitalValue5.i = dis02.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc02"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue5);

            SingleInt32Union digitalValue6 = new SingleInt32Union();

            digitalValue6.i = dis12.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc12"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue6);

            SingleInt32Union digitalValue7 = new SingleInt32Union();

            digitalValue7.i = dis22.Value;
            simulator.UpdatePoint(pairs["Discrete_Disc22"], dnp3types.eDNP3GroupID.BINARY_OUTPUT, tgttypes.eDataSizes.SINGLE_POINT_SIZE, tgtcommon.eDataTypes.SINGLE_POINT_DATA, digitalValue7);
        }