조향 장치 변경 내용 적용.

Dev/OHV/OHV.Common/Shareds/SharedEnumType.cs

@@ -231,4 +231,34 @@
 		Stop,
     }
 
+	public enum eSteerCommand
+    {
+		None = -1,
+		LL,// 전 후 방 모두 Left 조향
+		LX,// 전방 Left
+		XL,// 후방 Left
+		RR,// 전후방 모두 Right
+		RX,// 전방 Right
+		XR,// 후방 Right
+		OffOff, //전후방 전원 Off
+		OnOn, //전후방 전원 On (방향 상관없음)
+		FrontOn,//전방 전원 On(방향 상관없음)
+		RearOn,//후방 전원 On(방향 상관없음)
+		FrontOff,// 전방 전원 Off
+		RearOff,// 후방 전원 Off
+    }
+
+	public enum eSteerState4ZMq
+    {
+		None = -1,
+		LL,
+		RR,
+		LR,
+		RL,
+		LX,
+		RX,
+		XL,
+		XR,
+		XX,
+    }
 }

Dev/OHV/OHV.Vehicle/MainWindowViewModel.cs

@@ -6,16 +6,11 @@ using Prism.Commands;
 using Prism.Events;
 using Prism.Mvvm;
 using VehicleControlSystem;
-using Prism.Modularity;
 using Prism.Regions;
 using OHV.Common.Shareds;
-using System.Windows.Documents;
 using System.Windows.Controls;
-using System.Windows;
 using OHV.Module.Interactivity;
-using Prism.Interactivity.InteractionRequest;
 using Prism.Services.Dialogs;
-using System.Collections.ObjectModel;
 using System.Windows.Media;
 using System.Windows.Threading;
 

Dev/OHV/VehicleControlSystem/ControlLayer/MQ/ZmqManager.cs

@@ -294,16 +294,16 @@ namespace VehicleControlSystem.ControlLayer.MQ
                 this.IsReqConnected = true;
                 this.SynchronizedParmeter();
             };
-            this.monitor.Disconnected += (s, a) => 
-            { 
-                this.IsReqConnected = false; 
-                logger.D("Request MQ DisConnected"); 
+            this.monitor.Disconnected += (s, a) =>
+            {
+                this.IsReqConnected = false;
+                logger.D("Request MQ DisConnected");
             };
 
             this.monitor.StartAsync();
             req.Connect("tcp://127.0.0.1:5567");
 
-            pubQueue.ReceiveReady += (s, e) => 
+            pubQueue.ReceiveReady += (s, e) =>
             {
                 MqPubilshMessage ret = null;
                 try
@@ -322,7 +322,7 @@ namespace VehicleControlSystem.ControlLayer.MQ
                     this.pub = null;
                     this.pub = new PublisherSocket();
                     this.pub.Bind("tcp://127.0.0.1:5570");
-                }            
+                }
             };
             pubQueuePoller.Add(pubQueue);
             pubQueuePoller.RunAsync();
@@ -436,17 +436,60 @@ namespace VehicleControlSystem.ControlLayer.MQ
                         case "3050":
                             {
                                 logger.D($"[Steering_Rep] - 3050/{v[0]}");
+                                //switch (v[1])
+                                //{
+                                //    case "1":
+                                //        this.RequestSteering = eSteeringState.Left;
+                                //        break;
+                                //    case "-1":
+                                //        this.RequestSteering = eSteeringState.Right;
+                                //        break;
+                                //    default:
+                                //        break;
+                                //}
+                                eSteerCommand command = eSteerCommand.None;
                                 switch (v[1])
                                 {
-                                    case "1":
-                                        this.RequestSteering = eSteeringState.Left;
+                                    case "LL":
+                                        command = eSteerCommand.LL;
+                                        break;
+                                    case "LX":
+                                        command = eSteerCommand.LX;
+                                        break;
+                                    case "XL":
+                                        command = eSteerCommand.XL;
+                                        break;
+                                    case "RR":
+                                        command = eSteerCommand.RR;
+                                        break;
+                                    case "RX":
+                                        command = eSteerCommand.RX;
+                                        break;
+                                    case "XR":
+                                        command = eSteerCommand.XR;
                                         break;
-                                    case "-1":
-                                        this.RequestSteering = eSteeringState.Right;
+                                    case "00":
+                                        command = eSteerCommand.OffOff;
+                                        break;
+                                    case "11":
+                                        command = eSteerCommand.OnOn;
+                                        break;
+                                    case "1X":
+                                        command = eSteerCommand.FrontOn;
+                                        break;
+                                    case "X1":
+                                        command = eSteerCommand.RearOn;
+                                        break;
+                                    case "0X":
+                                        command = eSteerCommand.FrontOff;
+                                        break;
+                                    case "X0":
+                                        command = eSteerCommand.RearOff;
                                         break;
                                     default:
                                         break;
                                 }
+                                this.steering.RequestCommand(command);
                             }
                             break;
 
@@ -564,13 +607,11 @@ namespace VehicleControlSystem.ControlLayer.MQ
                 {
                     var v = ret[1].Split('/');
                     rsp.SendMoreFrame(ret[0]).SendFrame($"ok/{ret[1]}"); //응답처리 부터 하자.
-
                 }
                 else if (ret[0].Equals("parameter"))
                 {
                     var v = ret[1].Split('/');
                     rsp.SendMoreFrame(ret[0]).SendFrame($"ok/{ret[1]}"); //응답처리 부터 하자.
-
                 }
                 else
                     rsp.SendMoreFrame(ret[0]).SendFrame($"ok/{ret[1]}");
@@ -1048,6 +1089,40 @@ namespace VehicleControlSystem.ControlLayer.MQ
             logger.D($"[Steering_Req] - 3060/{val}");
         }
 
+        /// <summary>
+        /// 전후진 조향 감지 센서의 상태를 전달한다.
+        /// </summary>
+        /// <param name="isFrontOn"></param>
+        internal void SetSteerDetectSensorState(bool frontLeft, bool frontRight, bool rearLeft, bool rearRight)
+        {
+            string frontState = string.Empty;
+            string rearState = string.Empty;
+
+            if (frontLeft && !frontRight)
+                frontState = "L";
+            if (!frontLeft && frontRight)
+                frontState = "R";
+            if (!frontLeft && !frontRight)
+                frontState = "X";
+
+            if (rearLeft && !rearRight)
+                rearState = "L";
+            if (!rearLeft && rearRight)
+                rearState = "R";
+            if (!rearLeft && !rearRight)
+                rearState = "X";
+
+
+            var rll = this.RequestDrive("setm", $"3060/{frontState}{rearState}");
+            if (rll.Count == 0)
+            {
+                logger.E($"[Set Steering State] - Response Time Out");
+                return;
+            }
+
+            logger.D($"[Steering_State] - 3060/{frontState}{rearState}");
+        }
+
         internal void SetSafetyBumper()
         {
             var rll = this.RequestDrive("setm", $"6105/1");
@@ -1383,7 +1458,7 @@ namespace VehicleControlSystem.ControlLayer.MQ
         {
             string warningList = string.Empty;
 
-            if ( on )
+            if (on)
                 warningList = "4094/0xff/0x00/0x00/0x01";
             else
                 warningList = "4094/0x00/0x00/0x00/0x00";

Dev/OHV/VehicleControlSystem/ControlLayer/Steering.cs

@@ -1,9 +1,9 @@
 using System;
-using System.Security.Principal;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using GSG.NET.Concurrent;
 using GSG.NET.Logging;
-using GSG.NET.Quartz;
 using GSG.NET.Utils;
 using OHV.Common.Shareds;
 using OHV.SqliteDAL;
@@ -19,7 +19,7 @@ namespace VehicleControlSystem.ControlLayer
         static Logger SteerLogger = Logger.GetLogger("SteerLogger");
 
         ThreadCancel threadCancel = new ThreadCancel();
-        TsQueue<eSteeringState> qReqSteer = new TsQueue<eSteeringState>();
+        TsQueue<eSteerCommand> qReqSteer = new TsQueue<eSteerCommand>();
 
         EzIO iO = null;
         SqliteManager sql = null;
@@ -58,100 +58,262 @@ namespace VehicleControlSystem.ControlLayer
         #region Thread Method
         void _DoControlSteer()
         {
-            while ( !this.threadCancel.Canceled )
+            while (!this.threadCancel.Canceled)
             {
                 var q = this.qReqSteer.Dequeue();
-                this.ControlSteerNWaitDone( q );
+                //this.ControlSteerNWaitDone( q );
+                this.ExecuteCommandSteer(q);
             }
         }
 
-        void ControlSteerNWaitDone( eSteeringState requestState )
+        void ControlSteerNWaitDone(eSteeringState requestState)
         {
-            logger.D( $"Steer - Start {requestState} -------------------------------------------------------" );
+            logger.D($"Steer - Start {requestState} -------------------------------------------------------");
 
-            if ( requestState == eSteeringState.Left )
+            if (requestState == eSteeringState.Left)
             {
-                this.iO.WriteOutputIO( "OUT_F_STEERING_CWCCW", false );
-                this.iO.WriteOutputIO( "OUT_R_STEERING_CWCCW", true );
+                this.iO.WriteOutputIO("OUT_F_STEERING_CWCCW", false);
+                this.iO.WriteOutputIO("OUT_R_STEERING_CWCCW", true);
             }
             else
             {
-                this.iO.WriteOutputIO( "OUT_F_STEERING_CWCCW", true );
-                this.iO.WriteOutputIO( "OUT_R_STEERING_CWCCW", false );
+                this.iO.WriteOutputIO("OUT_F_STEERING_CWCCW", true);
+                this.iO.WriteOutputIO("OUT_R_STEERING_CWCCW", false);
             }
 
             //Hight Voltage On
-            this.iO.WriteOutputIO( "OUT_F_STEERING_DA", true );
-            this.iO.WriteOutputIO( "OUT_R_STEERING_DA", true );
+            this.iO.WriteOutputIO("OUT_F_STEERING_DA", true);
+            this.iO.WriteOutputIO("OUT_R_STEERING_DA", true);
 
-            logger.D( $"Steer - OutPut On" );
+            logger.D($"Steer - OutPut On");
 
             var sT = SwUtils.CurrentTimeMillis;
             bool isCheckedOutput = false;
             var currentDirection = eSteeringState.None;
             long eT = 0;
-            while ( true )
+            while (true)
             {
-                LockUtils.Wait( 10 );
+                LockUtils.Wait(10);
 
                 currentDirection = GetSteerDirection();
-                if ( requestState == currentDirection )
+                if (requestState == currentDirection)
                     break;
 
-                eT = SwUtils.Elapsed( sT );
+                eT = SwUtils.Elapsed(sT);
 
-                if ( eT > 700 && !isCheckedOutput )
+                if (eT > 700 && !isCheckedOutput)
                 {
-                    this.iO.WriteOutputIO( "OUT_F_STEERING_DA", false );
-                    this.iO.WriteOutputIO( "OUT_R_STEERING_DA", false );
+                    this.iO.WriteOutputIO("OUT_F_STEERING_DA", false);
+                    this.iO.WriteOutputIO("OUT_R_STEERING_DA", false);
                     isCheckedOutput = true;
-                    logger.D( $"Steer - Output Off {eT}ms" );
+                    logger.D($"Steer - Output Off {eT}ms");
                 }
 
-                if ( eT > ConstUtils.ONE_SECOND * 2 )
+                if (eT > ConstUtils.ONE_SECOND * 2)
                 {
-                    logger.D( $"Steer - Wait Time Out {eT}ms" );
+                    logger.D($"Steer - Wait Time Out {eT}ms");
                     this.SteeringState = eSteeringState.None;
 
-                    if ( !isCheckedOutput )
+                    if (!isCheckedOutput)
                     {
-                        this.iO.WriteOutputIO( "OUT_F_STEERING_DA", false );
-                        this.iO.WriteOutputIO( "OUT_R_STEERING_DA", false );
-                        logger.D( $"Steer - Output Off {SwUtils.Elapsed( sT )}ms" );
+                        this.iO.WriteOutputIO("OUT_F_STEERING_DA", false);
+                        this.iO.WriteOutputIO("OUT_R_STEERING_DA", false);
+                        logger.D($"Steer - Output Off {SwUtils.Elapsed(sT)}ms");
                     }
                     return;
                 }
             }
 
-            if ( !isCheckedOutput ) //위에서 Off 를 안했을 경우가 생길 수 있음. (700ms 이내에 조향 바뀌었을때)
+            if (!isCheckedOutput) //위에서 Off 를 안했을 경우가 생길 수 있음. (700ms 이내에 조향 바뀌었을때)
             {
-                this.iO.WriteOutputIO( "OUT_F_STEERING_DA", false );
-                this.iO.WriteOutputIO( "OUT_R_STEERING_DA", false );
-                logger.D( $"Steer - Output Off {SwUtils.Elapsed( sT )}ms" );
+                this.iO.WriteOutputIO("OUT_F_STEERING_DA", false);
+                this.iO.WriteOutputIO("OUT_R_STEERING_DA", false);
+                logger.D($"Steer - Output Off {SwUtils.Elapsed(sT)}ms");
             }
 
-            logger.D( $"Steer - Drive Request Start" );
+            logger.D($"Steer - Drive Request Start");
             this.SteeringState = currentDirection;
-            logger.D( $"Steer - Contorl End {SwUtils.Elapsed( sT )}ms -------------------------------------------------------" );
+            logger.D($"Steer - Contorl End {SwUtils.Elapsed(sT)}ms -------------------------------------------------------");
 
-            SteerLogger.I( SwUtils.Elapsed( sT ) );
+            SteerLogger.I(SwUtils.Elapsed(sT));
+        }
+
+        void ExecuteCommandSteer(eSteerCommand command)
+        {
+            logger.D($"Execute Steer Command - {command}");
+            var cmdSt = SwUtils.CurrentTimeMillis;
+
+            Action<bool> actionSteerFront = (isLeft) =>
+            {
+                if (isLeft)
+                    this.iO.WriteOutputIO("OUT_F_STEERING_CWCCW", false);
+                else
+                    this.iO.WriteOutputIO("OUT_F_STEERING_CWCCW", true);
+            };
+
+            Action<bool> actionSteerRear = (isLeft) =>
+            {
+                if (isLeft)
+                    this.iO.WriteOutputIO("OUT_R_STEERING_CWCCW", true);
+                else
+                    this.iO.WriteOutputIO("OUT_R_STEERING_CWCCW", false);
+            };
+
+            Action<bool> actionOnFrontHightVolteOn = (isOn) =>
+            {
+                if (isOn)
+                    this.iO.WriteOutputIO("OUT_F_STEERING_DA", true);
+                else
+                    this.iO.WriteOutputIO("OUT_F_STEERING_DA", false);
+            };
+
+            Action<bool> actionOnRearHightVolteOn = (isOn) =>
+            {
+                if (isOn)
+                    this.iO.WriteOutputIO("OUT_R_STEERING_DA", true);
+                else
+                    this.iO.WriteOutputIO("OUT_R_STEERING_DA", false);
+            };
+
+            Action<eSteerCommand> actionSteer = (cmd) =>
+            {
+                List<Func<bool>> inputList = new List<Func<bool>>();
+                List<Action<bool>> outputList = new List<Action<bool>>();
+
+                switch (cmd)
+                {
+                    case eSteerCommand.LL:
+                        inputList.Add(IsFrontLeft);
+                        inputList.Add(IsRearLeft);
+                        actionSteerFront(true);
+                        actionSteerRear(true);
+                        outputList.Add(actionOnRearHightVolteOn);
+                        outputList.Add(actionOnFrontHightVolteOn);
+                        break;
+                    case eSteerCommand.LX:
+                        inputList.Add(IsFrontLeft);
+                        actionSteerFront(true);
+                        outputList.Add(actionOnFrontHightVolteOn);
+                        break;
+                    case eSteerCommand.XL:
+                        inputList.Add(IsRearLeft);
+                        actionSteerRear(true);
+                        outputList.Add(actionOnRearHightVolteOn);
+                        break;
+                    case eSteerCommand.RR:
+                        inputList.Add(IsFrontRight);
+                        inputList.Add(IsRearRight);
+                        actionSteerFront(false);
+                        actionSteerRear(false);
+                        outputList.Add(actionOnRearHightVolteOn);
+                        outputList.Add(actionOnFrontHightVolteOn);
+                        break;
+                    case eSteerCommand.RX:
+                        inputList.Add(IsFrontRight);
+                        actionSteerFront(false);
+                        outputList.Add(actionOnFrontHightVolteOn);
+                        break;
+                    case eSteerCommand.XR:
+                        inputList.Add(IsRearRight);
+                        actionSteerRear(false);
+                        outputList.Add(actionOnRearHightVolteOn);
+                        break;
+                    default:
+                        break;
+                }
+
+                outputList.ForEach(x => x.Invoke(true));
+
+                var sT = SwUtils.CurrentTimeMillis;
+                while (true)
+                {
+                    LockUtils.Wait(10);
+
+                    if (inputList.All(x => x.Invoke()))
+                    {
+                        logger.D($"Execute Steer - {cmd} - Sensor On {SwUtils.Elapsed(sT)}mm");
+                        break;
+                    }
+
+                    if (SwUtils.Elapsed(sT) > 700)
+                    {
+                        logger.D($"Execute Steer - {cmd} - {SwUtils.Elapsed(sT)}mm");
+                        break;
+                    }
+                }
+
+                outputList.ForEach(x => x.Invoke(false));
+            };
+
+            switch (command)
+            {
+                case eSteerCommand.LL:
+                case eSteerCommand.LX:
+                case eSteerCommand.XL:
+                case eSteerCommand.RR:
+                case eSteerCommand.RX:
+                case eSteerCommand.XR:
+                    actionSteer(command);
+                    break;
+                case eSteerCommand.OffOff:
+                    //Todo: 전후방 전원 Off
+                    this.iO.WriteOutputIO("OUT_F_STEERING_OFF", false);
+                    this.iO.WriteOutputIO("OUT_R_STEERING_OFF", false);
+                    break;
+                case eSteerCommand.OnOn:
+                    this.iO.WriteOutputIO("OUT_F_STEERING_OFF", true);
+                    this.iO.WriteOutputIO("OUT_R_STEERING_OFF", true);
+                    break;
+                case eSteerCommand.FrontOn:
+                    this.iO.WriteOutputIO("OUT_F_STEERING_OFF", true);
+                    break;
+                case eSteerCommand.RearOn:
+                    this.iO.WriteOutputIO("OUT_R_STEERING_OFF", true);
+                    break;
+                case eSteerCommand.FrontOff:
+                    this.iO.WriteOutputIO("OUT_F_STEERING_OFF", false);
+                    break;
+                case eSteerCommand.RearOff:
+                    this.iO.WriteOutputIO("OUT_R_STEERING_OFF", false);
+                    break;
+                default:
+                    break;
+            }
+
+            logger.D($"Complete Steer Command - {command} / {SwUtils.Elapsed(cmdSt)}ms");
         }
 
         eSteeringState GetSteerDirection()
         {
-            if ( this.IsLeft() )
+            if (this.IsLeft())
                 return eSteeringState.Left;
-            if ( this.IsRight() )
+            if (this.IsRight())
                 return eSteeringState.Right;
 
             return eSteeringState.None;
         }
 
-        public void RequestControl( eSteeringState state )
+        public void RequestControl(eSteeringState state)
         {
-            this.qReqSteer.Enqueue( state );
+            //this.qReqSteer.Enqueue( state );
+            switch (state)
+            {
+                case eSteeringState.None:
+                    break;
+                case eSteeringState.Left:
+                    this.RequestCommand(eSteerCommand.LL);
+                    break;
+                case eSteeringState.Right:
+                    this.RequestCommand(eSteerCommand.RR);
+                    break;
+                default:
+                    break;
+            }
         }
 
+        public void RequestCommand(eSteerCommand command) => this.qReqSteer.Enqueue(command);
+
+
         #endregion
 
         private void IO_OnChangedIO(BitBlock bit)
@@ -351,7 +513,7 @@ namespace VehicleControlSystem.ControlLayer
                   this.isExecuteSteering = false;
               });
         }
-        
+
         /// <summary>
         /// Test Control
         /// </summary>

Dev/OHV/VehicleControlSystem/ControlLayer/Vehicle.cs

@@ -2900,7 +2900,6 @@ namespace VehicleControlSystem.ControlLayer
                             this.OccurVehicleAlarm( 42 );
                         else
                             this.OccurVehicleAlarm( 29 );
-
                     }
                     break;
 
@@ -2947,6 +2946,12 @@ namespace VehicleControlSystem.ControlLayer
                 case "IN_F_STEERING_DETECT_RIGHT":
                 case "IN_R_STEERING_DETECT_LEFT":
                 case "IN_R_STEERING_DETECT_RIGHT":
+                    var frontLeft = this.refObjects.IO.IsOn("IN_F_STEERING_DETECT_LEFT");
+                    var frontRight = this.refObjects.IO.IsOn("IN_F_STEERING_DETECT_RIGHT");
+                    var rearLeft = this.refObjects.IO.IsOn("IN_R_STEERING_DETECT_LEFT");
+                    var rearRight = this.refObjects.IO.IsOn("IN_R_STEERING_DETECT_RIGHT");
+
+                    this.refObjects.ZmqManager.SetSteerDetectSensorState(frontLeft, frontRight, rearLeft, rearRight);
                     logger.D($"[STEERING DETECTED] - {bit.Tag} / {bit.IsBitOn}");
                     break;
 

Dev/OHV/VehicleControlSystem/VCSystem.cs

@@ -1,10 +1,8 @@
 #define TEST
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using FluentResults;
 using GSG.NET.Concurrent;

Dev/OHVDriveLogger/OHVDriveLogger/OHVDriveLogger/Config/log4net.xml

@@ -24,48 +24,6 @@
 	•FATAL  •FATAL  •FATAL  •FATAL  •FATAL  •FATAL
 	•OFF    •OFF    •OFF    •OFF    •OFF    •OFF    •OFF
 	-->
-	<appender name="remotingAppender" type="log4net.Appender.RemotingAppender">
-		<!-- The remoting URL to the remoting server object -->
-		<sink value="tcp://172.20.0.198:8085/Log4netRemotingServerService"/>
-		<!-- Send all events, do not discard events when the buffer is full -->
-		<lossy value="false"/>
-		<!-- The number of events to buffer before sending -->
-		<bufferSize value="10"/>
-		<!-- Do not store event data that is slow to generate -->
-		<onlyFixPartialEventData value="true"/>
-		<!-- Specify an evaluator to send the events immediately under certain conditions, e.g. when an error event ocurrs -->
-		<!--<evaluator type="log4net.Core.LevelEvaluator">
-			<threshold value="WARN"/>
-		</evaluator>-->
-	</appender>
-
-	<appender name="Front_BufferingForwarder" type="log4net.Appender.BufferingForwardingAppender">
-		<bufferSize value="1024"/>
-		<lossy value="false"/>
-		<Fix value ="268"/>
-		<appender-ref ref="PhysicalCheckupFileAppender_Front"/>
-	</appender>
-
-	<appender name="Rear_BufferingForwarder" type="log4net.Appender.BufferingForwardingAppender">
-		<bufferSize value="1024"/>
-		<lossy value="false"/>
-		<Fix value ="268"/>
-		<appender-ref ref="PhysicalCheckupFileAppender_Rear"/>
-	</appender>
-
-	<appender name="PhysicalCheckupFileAppender_Front" type="GSG.NET.Logging.FileAppender, GSG.NET">
-		<threshold value="INFO"/>
-		<file value="C:\LOG\OHV\DriveLogger\PhysicalCheckup\Front_Wheel.log" />
-		<staticLogFileName value="true"/>
-		<lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
-		<appendToFile value="true" />
-		<rollingStyle value="Date" />
-		<backupDays value="5" />
-		<datePattern value="-MMdd'.log'" />
-		<layout type="log4net.Layout.PatternLayout">
-			<conversionPattern value="%d{MM-dd HH:mm:ss.fff} %2t %p %m%n" />
-		</layout>
-	</appender>
 
 	<appender name="PhysicalCheckupFileAppender_Rear" type="GSG.NET.Logging.FileAppender, GSG.NET">
 		<threshold value="INFO"/>

Dev/OHVDriveLogger/OHVDriveLogger/OHVDriveLogger/OHVDriveLogger.csproj

@@ -145,6 +145,7 @@
   <ItemGroup>
     <None Include="Config\log4net.xml">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <SubType>Designer</SubType>
     </None>
   </ItemGroup>
   <ItemGroup>