예제 #1
0
        /* decode une trame en Message */
        public MessageProtocol DecodeTrame(TrameProtocole trame)
        {
            MessageProtocol message = new MessageProtocol();

            switch (trame.data[0]) // Header
            {
            case (byte)EMBtoPCmessHeads.ACK:
                message            = new EMBtoPCMessageGlobalAck();
                message.headerMess = trame.data[0];
                ((EMBtoPCMessageGlobalAck)message).idTrame  = (ushort)(trame.data[1] << 8);
                ((EMBtoPCMessageGlobalAck)message).idTrame += trame.data[2];
                ((EMBtoPCMessageGlobalAck)message).valueAck = trame.data[3];
                break;

            case (byte)EMBtoPCmessHeads.ASK_CONN:
                message            = new EMBtoPCMessageAskConn();
                message.headerMess = trame.data[0];
                break;

            case (byte)EMBtoPCmessHeads.RESP_PING:
                message            = new EMBtoPCMessageRespPing();
                message.headerMess = trame.data[0];
                break;

            case (byte)EMBtoPCmessHeads.RESP_SENSOR:
                message            = new EMBtoPCMessageRespSensor();
                message.headerMess = trame.data[0];
                ((EMBtoPCMessageRespSensor)message).idSensor    = trame.data[1];
                ((EMBtoPCMessageRespSensor)message).valueSensor = trame.data[2];
                break;

            case (byte)EMBtoPCmessHeads.AUTO_MODE_OFF:
                message            = new EMBtoPCMessageAutoModeOff();
                message.headerMess = trame.data[0];
                break;

            default:
                Logger.GlobalLogger.error("Erreur Message recu inconnu !");
                break;
            }
            return(message);
        }
        /* Traite la trame et retourne si la trame doit remonter a la couche supérieure (true) */
        private bool TraiteTrameRecue(TrameProtocole trame)
        {
            MessageProtocol message = _SerialXbee.DecodeTrame(trame);
            ArduinoBotComm  robot   = ArduinoManager.getArduinoBotById(trame.src);

            if (message is EMBtoPCMessageAskConn)
            {
                if (robot == null) // Le robot n'as jamais été céer, on le créer
                {
                    robot = new ArduinoBotComm(trame.src);
                    robot.DateLastMessageReceived = DateTime.Now;
                    _ArduinoManager.addArduinoBot(robot);
                }
                Logger.GlobalLogger.debug("Reception du message EMBtoPCMessageAskConn par " + robot.id);
                if (!robot.Connected) // Robot non connecté, on l'ajoute dans la liste des connectés
                {
                    robot.Connect();
                    robot.DateLastMessageReceived = DateTime.Now;
                    robot.stateComm = StateArduinoComm.STATE_COMM_NONE;
                    robot.CountSend = trame.num; // Utilisation du compteur du robot

                    MessageProtocol reponse = MessageBuilder.createRespConnMessage(0x01);

                    // Ajout a la liste à envoyer
                    //TrameProtocole trameRet = _SerialXbee.EncodeTrame(_IdPc, trame.src, robot.CountSend++, reponse);
                    //trameRet.num = robot.CountSend++;
                    robot.PushMessageAEnvoyer(reponse);
                    //_SerialXbee.PushTrameToSend(trameRet);

                    return(true); // Notification a l'application
                }
                else
                {
                    Logger.GlobalLogger.error("Reception d'une demande de connexion d'un bot déjà connecté");
                    return(false);
                }
            }
            else if (message is EMBtoPCMessageGlobalAck)
            {
                Logger.GlobalLogger.debug("Reception du message EMBtoPCMessageGlobalAck par " + robot.id);

                if (robot == null)
                {
                    Logger.GlobalLogger.error("Robot Inconnu in EMBtoPCMessageGlobalAck");
                    return(false); // Marquer comme traité
                }


                if (robot.Connected) // Robot connecté
                {
                    robot.DateLastMessageReceived = DateTime.Now;

                    EMBtoPCMessageGlobalAck msg = ((EMBtoPCMessageGlobalAck)message);
                    if (msg.valueAck == 0x00) // !akitement negatif Message erreur
                    {
                        Logger.GlobalLogger.error("Ackitement Negatif !");
                    }
                    else if (msg.valueAck == 0x01)
                    {
                        if (robot.stateComm == StateArduinoComm.STATE_COMM_WAIT_ACK) // On attendais un ACK
                        {
                            robot.stateComm = StateArduinoComm.STATE_COMM_NONE;
                        }

                        robot.AckRecu(msg.idTrame);
                        //_SerialXbee.DeleteTrame(msg.idTrame);
                    }
                    else if (msg.valueAck == 0x02)
                    {
                        Logger.GlobalLogger.error("CRC corrompu, on r'envois !");
                    }
                    else
                    {
                        Logger.GlobalLogger.error("Ackitement inconnu !");
                    }


                    return(false);
                }
                else
                {
                    Logger.GlobalLogger.error("Reception d'un ACK alors que le robot n'est pas connecté !");
                    return(false);
                }
            }
            else if (message is EMBtoPCMessageRespPing)
            {
                Logger.GlobalLogger.debug("Reception du message EMBtoPCMessageRespPing par " + robot.id);
                if (robot == null)
                {
                    Logger.GlobalLogger.error("Robot Inconnu in EMBtoPCMessageRespPing");
                    return(false); // Marquer comme traité
                }

                if (robot.Connected) // Robot connecté
                {
                    robot.DateLastMessageReceived = DateTime.Now;
                    if (robot.stateComm == StateArduinoComm.STATE_COMM_WAIT_PING) // On attendais un ACK
                    {
                        robot.stateComm = StateArduinoComm.STATE_COMM_NONE;
                    }


                    /* Supprimer les demande de ping sans ackitements en provenance du robot */
                    foreach (MessageProtocol mp in robot.ListMessageAttenteAck())
                    {
                        if (mp.headerMess == (byte)PCtoEMBmessHeads.ASK_PING)
                        {
                            robot.SupprimerMessage(mp);
                        }
                    }
                    //List<TrameProtocole> Listtp = _SerialXbee.FetchTrameSentNoAck();

                    /*foreach (TrameProtocole tp in Listtp)
                     * {
                     * if (tp.data[0] == (byte)PCtoEMBmessHeads.ASK_PING)
                     *      if(tp.dst == robot.id)
                     *          _SerialXbee.DeleteTrame(tp.num);
                     * }*/

                    return(false);
                }
                else
                {
                    Logger.GlobalLogger.error("Reception d'un ACK alors que le robot n'est pas connecté !");
                    return(false);
                }
            }
            else if (message is EMBtoPCMessageAutoModeOff)
            {
                if (robot == null)
                {
                    Logger.GlobalLogger.error("Robot Inconnu in EMBtoPCMessageAutoModeOff");
                    return(false); // Marquer comme traité
                }
                Logger.GlobalLogger.debug("Reception du message EMBtoPCMessageAutoModeOff par " + robot.id);

                if (robot.Connected) // Robot connecté
                {
                    robot.DateLastMessageReceived = DateTime.Now;

                    /*if (robot.stateComm == StateArduinoComm.STATE_COMM_WAIT_PING) // On attendais un ACK
                     *  robot.stateComm = StateArduinoComm.STATE_COMM_NONE;*/

                    return(true); // Envoie au couche suppérieure
                }
                else
                {
                    Logger.GlobalLogger.error("Reception d'un message alors que le robot n'est pas connecté ! EMBtoPCMessageAutoModeOff");
                    return(false);
                }
            }
            else if (message is EMBtoPCMessageRespSensor)
            {
                Logger.GlobalLogger.debug("Reception du message EMBtoPCMessageRespSensor par " + robot.id);
                if (robot == null)
                {
                    Logger.GlobalLogger.error("Robot Inconnu in EMBtoPCMessageRespSensor");
                    return(false); // Marquer comme traité
                }

                if (robot.Connected) // Robot connecté
                {
                    robot.DateLastMessageReceived = DateTime.Now;
                    if (robot.stateComm == StateArduinoComm.STATE_COMM_WAIT_SENSOR) // On attendais un ACK
                    {
                        robot.stateComm = StateArduinoComm.STATE_COMM_NONE;
                    }

                    foreach (MessageProtocol mp in robot.ListMessageAttenteAck())
                    {
                        if (mp.headerMess == (byte)PCtoEMBmessHeads.ASK_SENSOR)
                        {
                            robot.SupprimerMessage(mp);
                        }
                    }

                    return(true); // Envoi a l'apllication pour traitement
                }
                else
                {
                    Logger.GlobalLogger.error("Reception d'un message alors que le robot n'est pas connecté ! EMBtoPCMessageRespSensor");
                    return(false);
                }
            }
            else
            {
                if (robot == null)
                {
                    Logger.GlobalLogger.error("Robot Inconnu");
                }
                Logger.GlobalLogger.error("Message de type Inconnu !");
                return(false); // Marquer comme traité
            }
        }