Esempio n. 1
0
 private void On_VecUpdateData(object sender, JCVT_VEC data)
 {
     EvtUpdateStatus?.Invoke(this, new UDATESTATUS()
     {
         id = eVIWER.Pnl_Vec, mthd = data.typeName, msg = data.json
     });
 }
Esempio n. 2
0
            public static JCVT_VEC Set <T>(T data)
            {
                var obj = new JCVT_VEC();

                obj.typeName = $"{typeof(T).Name}";
                obj.json     = JsonConvert.SerializeObject(data, Formatting.Indented);
                return(obj);
            }
Esempio n. 3
0
        private void ReportLog(string msg, bool bSend = true)
        {
            var jsonLog = JCVT_VEC.Set(new LOG()
            {
                bSend = bSend, msg = msg
            });

            Evt_UpdateData?.Invoke(this, jsonLog);
        }
Esempio n. 4
0
        private void On_RecvdData(object sender, string data)
        {
            var temp = new LD_STATUS(data);

            switch (temp.cmd)
            {
            case eSTATE_CMD_TYPE.EXTENDEDSTATUSFORHUMANS:
            case eSTATE_CMD_TYPE.STATUS:
            case eSTATE_CMD_TYPE.ERROR:
            case eSTATE_CMD_TYPE.PAUSETASK:
                _curr.state.st     = temp.state.st;
                _curr.state.dst    = temp.state.dst;
                _curr.state.subMsg = temp.state.subMsg;
                break;

            case eSTATE_CMD_TYPE.STATEOFCHARGE: _curr.batt = temp.batt; break;

            case eSTATE_CMD_TYPE.LOCALIZATIONSCORE: _curr.local = temp.local; break;

            case eSTATE_CMD_TYPE.TEMPERATURE: _curr.temp = temp.temp; break;

            case eSTATE_CMD_TYPE.LOCATION: _curr.pos = new POS()
            {
                    x = temp.pos.x, y = temp.pos.y, ang = temp.pos.ang
            }; break;

            case eSTATE_CMD_TYPE.PARKING: _curr.state.st = temp.state.st; break;

            default: break;
            }

            switch (temp.cmd)
            {
            case eSTATE_CMD_TYPE.NONE: ReportLog($"Parsing Failed : {data}", false); break;

            case eSTATE_CMD_TYPE.PASSWORD:
                SendQuery("adept", false);
                bInit = true;
                break;

            case eSTATE_CMD_TYPE.END_OF_COMMAND:
                break;

            default:
                var rcv = JCVT_VEC.Set(_curr);
                Evt_UpdateData?.Invoke(this, rcv);
                if (_beforeSt.state.st != _curr.state.st || _beforeSt.state.dst != _curr.state.dst)
                {
                    _beforeSt.state.st  = _curr.state.st;
                    _beforeSt.state.dst = _curr.state.dst;
                    ReportLog(data, false);
                }
                break;
            }
        }
Esempio n. 5
0
        public void Vec_SendCmd(eVEC_CMD cmd, SENDARG s)
        {
            var arg = JCVT_VEC.Set(s);

            _Vec.Send(cmd, arg);
        }
 public void SetStatus(string rcvMsg)
 {
     JCVT_VEC.Get(rcvMsg, out status);
 }
Esempio n. 7
0
        public void Send(eVEC_CMD cmd, JCVT_VEC data = null)
        {
            bool   bSend  = true;
            string cmdmsg = string.Empty;

            switch (data.typeName)
            {
            case "SENDARG":
            {
                if (null != data)
                {
                    SENDARG arg;
                    JCVT_VEC.Get(data.json, out arg);
                    switch (cmd)
                    {
                    case eVEC_CMD.Say: cmdmsg = $"say {arg.msg}"; break;

                    case eVEC_CMD.LocalizeAtGoal: cmdmsg = $"dotask localizeatgoal {arg.goal_1st}"; break;

                    case eVEC_CMD.Go2Goal:
                    case eVEC_CMD.Go2Point:
                    case eVEC_CMD.Go2Straight:
                    {
                        ChangeToIdleMode();
                        switch (cmd)
                        {
                        case eVEC_CMD.Go2Goal: cmdmsg = $"goto {arg.goal_1st}"; break;

                        case eVEC_CMD.Go2Point: cmdmsg = $"gotopoint {arg.pos.x} {arg.pos.y}"; break;

                        case eVEC_CMD.Go2Straight: cmdmsg = $"doTask gotostraight {arg.goal_1st}"; break;
                        }
                        break;
                    }

                    case eVEC_CMD.MoveDeltaHeading:
                    case eVEC_CMD.MoveFront:
                    {
                        if (0 >= arg.acc)
                        {
                            arg.acc = 10;
                        }
                        if (0 >= arg.dec)
                        {
                            arg.acc = 10;
                        }
                        switch (cmd)
                        {
                        case eVEC_CMD.MoveDeltaHeading:
                            if (30 >= arg.dec)
                            {
                                arg.acc = 30;
                            }
                            cmdmsg = $"dotask deltaheading {arg.move} {arg.spd} {arg.acc} {arg.dec}";
                            break;

                        case eVEC_CMD.MoveFront:
                            if (50 >= arg.dec)
                            {
                                arg.acc = 50;
                            }
                            cmdmsg = $"dotask move {arg.move} {arg.spd} {arg.acc} {arg.dec} 10";
                            break;
                        }
                        break;
                    }

                    case eVEC_CMD.GetDistBetween: cmdmsg = $"distancebetween {arg.goal_1st} {arg.goal_2nd}"; break;

                    case eVEC_CMD.GetDistFromHere: cmdmsg = $"distanceFromHere {arg.goal_1st}"; break;

                    default: bSend = false; break;
                    }
                }
                else
                {
                    switch (cmd)
                    {
                    case eVEC_CMD.Stop: cmdmsg = $"stop"; break;

                    case eVEC_CMD.PauseCancel: cmdmsg = $"pausetaskcancel"; break;

                    case eVEC_CMD.Dock: cmdmsg = $"dock"; break;

                    case eVEC_CMD.Undock: cmdmsg = $"undock"; break;

                    default: bSend = false; break;
                    }
                }

                if (true == bSend)
                {
                    SendQuery(cmdmsg);
                }
                break;
            }

            default: break;
            }
        }