Example #1
0
        public void TrameRecue(Trame t)
        {
            Sauvegarde.AjouterTrameEntrante(t);

            if (NouvelleTrameRecue != null)
                NouvelleTrameRecue(t);
        }
Example #2
0
        public void TrameEnvoyee(Trame t)
        {
            Sauvegarde.AjouterTrameSortante(t);

            if (NouvelleTrameEnvoyee != null)
                NouvelleTrameEnvoyee(t);
        }
Example #3
0
        public static Trame AccelPivot(int accel, Robot robot)
        {
            byte[] tab = new byte[4];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.AccelerationPivot;
            tab[2] = (byte)ByteDivide(accel, true);
            tab[3] = (byte)ByteDivide(accel, false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #4
0
        public static Trame AccelLigne(int accelDebut, int accelFin, Robot robot)
        {
            byte[] tab = new byte[6];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.AccelerationLigne;
            tab[2] = (byte)ByteDivide(accelDebut, true);
            tab[3] = (byte)ByteDivide(accelDebut, false);
            tab[4] = (byte)ByteDivide(accelFin, true);
            tab[5] = (byte)ByteDivide(accelFin, false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #5
0
        private void btnEnvoyer_Click(object sender, EventArgs e)
        {
            Trame trame = null;
            try
            {
                trame = new Trame(txtTrame.Text);
            }
            catch (Exception)
            {
                txtTrame.ErrorMode = true;
                return;
            }

            if (boxMove.Checked)
                Connexions.ConnexionMove.SendMessage(trame);
            if (boxIO.Checked)
                Connexions.ConnexionIO.SendMessage(trame);
        }
Example #6
0
        public static Trame Stop(StopMode mode, Robot robot)
        {
            byte[] tab = new byte[3];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.Stop;
            tab[2] = (byte)mode;

            Trame retour = new Trame(tab);
            return retour;
        }
Example #7
0
        public static Trame Recallage(SensAR sens, Robot robot)
        {
            byte[] tab = new byte[3];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.Recallage;
            tab[2] = (byte)sens;

            Trame retour = new Trame(tab);
            return retour;
        }
Example #8
0
        /// <summary>
        /// Réception d'un message envoyé par la carte de la balise
        /// </summary>
        /// <param name="trame">Message reçu</param>
        public void connexion_NouvelleTrame(Trame trame)
        {
            if (trame == null)
                return;

            try
            {
                // On ne traite que les messages qui nous sont adressés
                if (trame[0] != (byte)0xB1)
                    return;

                if (trame[1] == (byte)FonctionBalise.DetectionRapide)
                {
                    if (Position != null)
                    {
                        int capteur = trame[2];

                        double debut = 360 - ((trame[3] * 256 + trame[4]) / 100.0) + Config.CurrentConfig.GetOffsetBalise(capteur);
                        double fin = 360 - ((trame[5] * 256 + trame[6]) / 100.0) + Config.CurrentConfig.GetOffsetBalise(capteur);

                        debut = debut + Position.Angle;
                        fin = fin + Position.Angle;

                        if (DetectionsRapides == null)
                            DetectionsRapides = new List<DetectionBalise>();

                        DetectionBalise detect = new DetectionBalise(this, debut, fin);

                        bool recalcul = false;
                        if (capteur == 2 && detect.Distance > 1250)
                        {
                            recalcul = true;
                            detect.Distance = 1250;
                        }
                        else if (capteur == 2 && detect.Distance < 480)
                        {
                            recalcul = true;
                            detect.Distance = 480;
                        }
                        else if (capteur == 3 && detect.Distance > 600)
                        {
                            recalcul = true;
                            detect.Distance = 600;
                        }
                        else if (capteur == 3 && detect.Distance < 300)
                        {
                            recalcul = true;
                            detect.Distance = 300;
                        }

                        if (recalcul)
                        {
                            // Un peu de trigo pas bien compliquée
                            double xPoint = Position.Coordonnees.X + Math.Cos(Maths.DegreeToRadian(detect.AngleCentral)) * detect.Distance;
                            double yPoint = Position.Coordonnees.Y + Math.Sin(Maths.DegreeToRadian(detect.AngleCentral)) * detect.Distance;

                            detect.Position = new PointReel(xPoint, yPoint);
                        }

                        DetectionsRapides.Add(detect);

                        nbDetectionsRapides++;

                        PositionsChange();
                    }
                }

                if (trame[1] == (byte)FonctionBalise.Detection)
                {
                    if (Position != null)
                    {
                        if (DetectionsRapides != null)
                        {
                            // Vide les détections rapides datant de plus d'un tour
                            for (int i = 0; i < DetectionsRapides.Count - nbDetectionsRapides; i++)
                                DetectionsRapides.RemoveAt(0);
                        }

                        nbDetectionsRapides = 0;

                        // Réception d'une mesure sur un tour de rotation
                        // Vérification checksum

                        // Calcul de la vitesse de rotation
                        int nbTicks = trame[2] * 256 + trame[3];
                        VitesseToursSecActuelle = 1 / (nbTicks * 0.0000064);

                        int nouvelleVitesse = 0;
                        if (ReglageVitesse)
                            nouvelleVitesse = AsservissementVitesse();

                        // Réception des données angulaires

                        int nbMesures1 = trame[4];
                        int nbMesures2 = trame[5];

                        // Si on a un nombre impair de fronts on laisse tomber cette mesure, elle n'est pas bonne
                        if (nbMesures1 % 2 != 0 || nbMesures2 % 2 != 0)
                        {
                            Console.WriteLine("Erreur de détection (fronts impairs)");
                            return;
                        }

                        nbMesures1 = nbMesures1 / 2;
                        nbMesures2 = nbMesures2 / 2;

                        // Vérification de la taille de la trame
                        if (trame.Length != 6 + nbMesures1 * 4 + nbMesures2 * 4)
                        {
                            Console.WriteLine("Erreur de taille de trame");
                            return;
                        }

                        // Réception des mesures du capteur 1
                        DetectionsCapteur1.Clear();
                        List<int> tabAngle = new List<int>();

                        long verif = 0;
                        for (int i = 0; i < nbMesures1 * 4; i += 2)
                        {
                            int valeur = trame[6 + i] * 256 + trame[6 + i + 1];
                            tabAngle.Add(valeur);
                            verif += valeur * (i / 2 + 1);
                        }

                        tabAngle.Sort();

                        for (int i = 0; i < nbMesures1 * 2; i++)
                        {
                            verif -= tabAngle[i] * (i + 1);
                        }

                        if (verif != 0)
                        {
                            Console.WriteLine("Inversion détectée capteur 1");
                        }

                        for (int i = 0; i < nbMesures1; i++)
                        {
                            double debut = 360 - (tabAngle[i * 2] / 100.0) + Config.CurrentConfig.GetOffsetBalise(1);
                            double fin = 360 - (tabAngle[i * 2 + 1] / 100.0) + Config.CurrentConfig.GetOffsetBalise(1);

                            debut = debut + Position.Angle;
                            fin = fin + Position.Angle;

                            DetectionBalise detect = new DetectionBalise(this, debut, fin);

                            bool recalcul = false;
                            if (detect.Distance > 600)
                            {
                                recalcul = true;
                                detect.Distance = 600;
                            }
                            else if (detect.Distance < 300)
                            {
                                recalcul = true;
                                detect.Distance = 300;
                            }

                            if (recalcul)
                            {
                                // Un peu de trigo pas bien compliquée
                                double xPoint = Position.Coordonnees.X + Math.Cos(Maths.DegreeToRadian(detect.AngleCentral)) * detect.Distance;
                                double yPoint = Position.Coordonnees.Y + Math.Sin(Maths.DegreeToRadian(detect.AngleCentral)) * detect.Distance;

                                detect.Position = new PointReel(xPoint, yPoint);
                            }

                            DetectionsCapteur1.Add(detect);
                        }

                        // Réception des mesures du capteur 2

                        int offSet = nbMesures1 * 4 + 6;

                        DetectionsCapteur2.Clear();

                        // tableau pour trier les angles ( correction logiciel )
                        tabAngle.Clear();

                        verif = 0;
                        for (int i = 0; i < nbMesures2 * 4; i += 2)
                        {
                            int valeur = trame[offSet + i] * 256 + trame[offSet + i + 1];
                            tabAngle.Add(valeur);
                            verif += valeur * (i / 2 + 1);
                        }

                        tabAngle.Sort();

                        for (int i = 0; i < nbMesures2 * 2; i++)
                        {
                            verif -= tabAngle[i] * (i + 1);
                        }

                        if (verif != 0)
                        {
                            Console.WriteLine("Inversion détectée capteur 2");
                        }

                        for (int i = 0; i < nbMesures2; i++)
                        {
                            double debut = 360 - (tabAngle[i * 2] / 100.0) + Config.CurrentConfig.GetOffsetBalise(2);
                            double fin = 360 - (tabAngle[i * 2 + 1] / 100.0) + Config.CurrentConfig.GetOffsetBalise(2);

                            debut = debut + Position.Angle;
                            fin = fin + Position.Angle;

                            DetectionBalise detect = new DetectionBalise(this, debut, fin);

                            bool recalcul = false;
                            if (detect.Distance > 1250)
                            {
                                recalcul = true;
                                detect.Distance = 1250;
                            }
                            else if (detect.Distance < 480)
                            {
                                recalcul = true;
                                detect.Distance = 480;
                            }

                            if (recalcul)
                            {
                                // Un peu de trigo pas bien compliquée
                                double xPoint = Position.Coordonnees.X + Math.Cos(Maths.DegreeToRadian(detect.AngleCentral)) * detect.Distance;
                                double yPoint = Position.Coordonnees.Y + Math.Sin(Maths.DegreeToRadian(detect.AngleCentral)) * detect.Distance;

                                detect.Position = new PointReel(xPoint, yPoint);
                            }

                            DetectionsCapteur2.Add(detect);
                        }

                        // Réglage de l'offset d'angle des capteurs
                        if (ReglageOffset)
                        {
                            // Si on a une mesure incorrecte (une mesure correcte demande 2 détections sur chaque balise : un reflecteur au "centre" et un autre en bas de la piste)
                            // Le réglage est annulé
                            /*if (DetectionsCapteur1.Count == 2 && DetectionsCapteur2.Count == 2)
                            {
                                // 3 cas où on passe d'abord par la balise en bas de la piste avant celle du milieu (sens de rotation anti-horaire)
                                if (Carte == GoBot.Carte.RecBun && Plateau.NotreCouleur == Plateau.CouleurGaucheJaune ||
                                    Carte == GoBot.Carte.RecBeu && Plateau.NotreCouleur == Plateau.CouleurGaucheJaune ||
                                    Carte == GoBot.Carte.RecBoi && Plateau.NotreCouleur == Plateau.CouleurDroiteVert)
                                {
                                    DetectionsCapteur1.RemoveAt(0);
                                    DetectionsCapteur2.RemoveAt(0);
                                }

                                if (ReglageOffset)
                                {
                                    compteurReglageOffset--;
                                    // On ajoute les angles mesurés à l'historique
                                    anglesMesuresPourOffsetCapteur2.Add(DetectionsCapteur2[0].AngleCentral);
                                    anglesMesuresPourOffsetCapteur1.Add(DetectionsCapteur1[0].AngleCentral);
                                }
                            }*/
                            if (DetectionsCapteur1.Count == 1 && DetectionsCapteur2.Count == 1)
                            {
                                compteurReglageOffset--;
                                // On ajoute les angles mesurés à l'historique
                                anglesMesuresPourOffsetCapteur2.Add(DetectionsCapteur2[0].AngleCentral);
                                anglesMesuresPourOffsetCapteur1.Add(DetectionsCapteur1[0].AngleCentral);
                            }

                            if (ReglageOffset && compteurReglageOffset == 0)
                            {
                                // Compteur arrivé à la fin, on calcule l'offset
                                double moyenne = 0;

                                foreach (double dv in anglesMesuresPourOffsetCapteur1)
                                    moyenne += dv;

                                moyenne /= anglesMesuresPourOffsetCapteur1.Count;

                                // Calcul l'offset en fonction de ce qu'il est censé mesurer au centre
                                moyenne = 0 - moyenne;

                                // On le sauve dans la config (haut)
                                Config.CurrentConfig.SetOffsetBalise(1, moyenne + Config.CurrentConfig.GetOffsetBalise(1));

                                moyenne = 0;

                                foreach (double dv in anglesMesuresPourOffsetCapteur2)
                                    moyenne += dv;

                                moyenne /= anglesMesuresPourOffsetCapteur2.Count;
                                moyenne = 0 - moyenne;

                                // On le sauve dans la config (bas)
                                Config.CurrentConfig.SetOffsetBalise(2, moyenne + Config.CurrentConfig.GetOffsetBalise(2));
                                Config.Save();
                                // Réglage terminé
                                ReglageOffset = false;
                                if (CalibrationAngulaireTerminee != null) CalibrationAngulaireTerminee();
                            }
                        }

                        Detections = new List<DetectionBalise>();
                        Detections.AddRange(DetectionsCapteur1);
                        Detections.AddRange(DetectionsCapteur2);

                        // Retire les détections correspondant à la position de robots alliés
                        if (!ReglageOffset && Plateau.ReflecteursNosRobots)
                        {
                            foreach (Robot robot in Robots.DicRobots.Values)
                            {
                                for (int i = 0; i < Detections.Count; i++)
                                {
                                    DetectionBalise detection = Detections[i];
                                    // Calcul du 3ème point du triangle rectangle Balise / Gros robot
                                    Droite droiteBalise0Degres = new Droite(Position.Coordonnees, new PointReel(Position.Coordonnees.X + 500, Position.Coordonnees.Y));
                                    Droite perpendiculaire = droiteBalise0Degres.GetPerpendiculaire(robot.Position.Coordonnees);
                                    PointReel troisiemePoint = perpendiculaire.getCroisement(droiteBalise0Degres);
                                    double distanceBaliseTroisiemePoint = troisiemePoint.Distance(Position.Coordonnees);
                                    double distanceBaliseRobot = robot.Position.Coordonnees.Distance(Position.Coordonnees);

                                    double a = Math.Acos(distanceBaliseTroisiemePoint / distanceBaliseRobot);
                                    Angle angleGrosRobot = new Angle(a, AnglyeType.Radian);
                                    Angle angleDetection = new Angle(detection.AngleCentral);

                                    double marge = 4;

                                    if (Plateau.NotreCouleur == Plateau.CouleurDroiteVert)
                                    {
                                        Angle diff = new Angle(180) - (angleDetection - angleGrosRobot);
                                        if (Math.Abs((diff).AngleDegres) < marge)
                                        {
                                            Detections.RemoveAt(i);
                                            i--;
                                        }
                                    }
                                    else if (Plateau.NotreCouleur == Plateau.CouleurGaucheViolet)
                                    {
                                        Angle diff = angleGrosRobot - angleDetection;
                                        if (Math.Abs((diff).AngleDegres) < marge)
                                        {
                                            Detections.RemoveAt(i);
                                            i--;
                                        }
                                    }
                                }
                            }
                        }

                        // Génération de l'event de notification de détection
                        PositionsChange();
                        Actualisation();
                    }
                }
            }
            catch (Exception)
            { }

            Connexion.ConnexionCheck.MajConnexion();
        }
Example #9
0
 /// <summary>
 /// Ajoute une trame envoyée avec l'heure actuelle
 /// </summary>
 /// <param name="trame">Trame à ajouter</param>
 public void AjouterTrameSortante(Trame trame)
 {
     AjouterTrameSortante(trame, DateTime.Now);
 }
Example #10
0
        /// <summary>
        /// Envoi le message au client actuellement connecté
        /// </summary>
        /// <param name="message">Message à envoyer au client</param>
        /// <param name="bloquant">Vrai si la fonction doit être bloquante en attente d'un acquittement</param>
        /// <returns>Nombre de caractères envoyés</returns>
        public override int SendMessage(Trame message, bool bloquant = false)
        {
            if (!Connexions.ActivationConnexion[message.Carte])
                return 0;

            // TODO attente acquittement
            int retour = 0;
            try
            {
                if (!isConnect)
                    if (Connexion(AdresseIp, PortSortie, PortEntree) != Etat.Ok)
                        return -1;

                byte[] envoi = message.ToTabBytes();

                retour = client.Send(envoi, envoi.Length);
                TrameEnvoyee(message);
            }
            catch (SocketException)
            {
                isConnect = false;
            }

            return retour;
        }
Example #11
0
        public static Trame VitessePivot(int vitesse, Robot robot)
        {
            byte[] tab = new byte[4];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.VitessePivot;
            tab[2] = (byte)ByteDivide(vitesse, true);
            tab[3] = (byte)ByteDivide(vitesse, false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #12
0
        public static Trame EnvoiConsigneBrute(int consigne, SensAR sens, Robot robot)
        {
            byte[] tab = new byte[5];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.EnvoiConsigneBrute;
            tab[2] = (byte)sens;
            tab[3] = (byte)ByteDivide(consigne, true);
            tab[4] = (byte)ByteDivide(consigne, false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #13
0
        public static Trame Deplacer(SensAR sens, int distance, Robot robot)
        {
            byte[] tab = new byte[5];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.Deplace;
            tab[2] = (byte)sens;
            tab[3] = ByteDivide(distance, true);
            tab[4] = ByteDivide(distance, false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #14
0
        public static Trame DemandeValeursAnalogiques(Carte carte)
        {
            byte[] tab = new byte[2];
            tab[0] = (byte)carte;
            tab[1] = (byte)FonctionIO.DemandeValeursAnalogiques;

            Trame retour = new Trame(tab);
            return retour;
        }
Example #15
0
        public static Trame DemandePositionsCodeurs(Robot robot)
        {
            byte[] tab = new byte[2];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.DemandePositionsCodeurs;

            Trame retour = new Trame(tab);
            return retour;
        }
Example #16
0
        public static Trame DemandePositionContinue(int intervalle, Robot robot)
        {
            byte[] tab = new byte[3];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.DemandePositionContinue;
            tab[2] = (byte)(intervalle / 10.0);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #17
0
        public static Trame DemandeCpuPwm(Robot robot)
        {
            byte[] tab = new byte[2];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.DemandeDiagnostic;

            Trame retour = new Trame(tab);
            return retour;
        }
Example #18
0
        public static Trame TrajectoirePolaire(SensAR sensAr, List<PointReel> points, Robot robot)
        {
            byte[] tab = new byte[5 + points.Count * 2 * 2];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.TrajectoirePolaire;
            tab[2] = (byte)sensAr;
            tab[3] = (byte)ByteDivide(points.Count, true);
            tab[4] = (byte)ByteDivide(points.Count, false);
            for (int i = 0; i < points.Count; i++)
            {
                tab[5 + i * 4 + 0] = ByteDivide((int)(points[i].X * 10), true);
                tab[5 + i * 4 + 1] = ByteDivide((int)(points[i].X * 10), false);
                tab[5 + i * 4 + 2] = ByteDivide((int)(points[i].Y * 10), true);
                tab[5 + i * 4 + 3] = ByteDivide((int)(points[i].Y * 10), false);
            }

            Trame retour = new Trame(tab);
            return retour;
        }
Example #19
0
        public static Trame Virage(SensAR sensAr, SensGD sensGd, int rayon, double angle, Robot robot)
        {
            byte[] tab = new byte[8];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.Virage;
            tab[2] = (byte)sensAr;
            tab[3] = (byte)sensGd;
            tab[4] = (byte)ByteDivide(rayon, true);
            tab[5] = (byte)ByteDivide(rayon, false);
            tab[6] = (byte)ByteDivide((int)(angle * 100), true);
            tab[7] = (byte)ByteDivide((int)(angle * 100), false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #20
0
        public static Trame EnvoyerUart(Carte carte, Trame trame)
        {
            byte[] tab = new byte[3 + trame.Length];
            tab[0] = (byte)carte;
            tab[1] = (byte)FonctionMove.EnvoiUart;
            tab[2] = (byte)trame.Length;
            for (int i = 0; i < trame.Length; i++)
                tab[3 + i] = trame[i];

            Trame retour = new Trame(tab);
            return retour;
        }
Example #21
0
        public static Trame CoeffAsservCap(int p, int i, int d, Robot robot)
        {
            byte[] tab = new byte[8];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.PIDCap;
            tab[2] = (byte)ByteDivide(p / 100, true);
            tab[3] = (byte)ByteDivide(p / 100, false);
            tab[4] = (byte)ByteDivide(i, true);
            tab[5] = (byte)ByteDivide(i, false);
            tab[6] = (byte)ByteDivide(d / 100, true);
            tab[7] = (byte)ByteDivide(d / 100, false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #22
0
        public void MessageRecu(Trame trame)
        {
            if ((FonctionBalise)trame[1] == FonctionBalise.TestEmissionCorrompu)
            {
                Reponses[trame[2]].Add(ReponseLiaison.CorrompuEmission);

                NombreMessagesCorrompusEmission++;
                if (trame[2] != IDTestReceptionActuel)
                {
                    if (trame[2] < IDTestReceptionActuel)
                    {
                        NombreMessagesPerdusReception += 255 - IDTestReceptionActuel;
                        NombreMessagesPerdusReception += trame[2];

                        for (int i = IDTestReceptionActuel + 1; i < 256; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);

                        for (int i = 0; i < trame[2]; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);
                    }
                    else
                    {
                        NombreMessagesPerdusReception += trame[2] - IDTestReceptionActuel;

                        for (int i = IDTestReceptionActuel; i < trame[2]; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);
                    }
                }

                IDTestReceptionActuel = (byte)(trame[2] + 1);
            }
            if ((FonctionBalise)trame[1] == FonctionBalise.TestEmissionReussi)
            {
                if (trame[2] != IDTestReceptionActuel)
                {
                    if (trame[2] < IDTestReceptionActuel)
                    {
                        NombreMessagesPerdusReception += 255 - IDTestReceptionActuel;
                        NombreMessagesPerdusReception += trame[2];

                        for (int i = IDTestReceptionActuel + 1; i < 256; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);

                        for (int i = 0; i < trame[2]; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);
                    }
                    else
                    {
                        NombreMessagesPerdusReception += trame[2] - IDTestReceptionActuel;

                        for (int i = IDTestReceptionActuel; i < trame[2]; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);
                    }
                }

                bool verif = true;
                if (trame.Length == 19)
                {
                    for (int i = 0; i < 16; i++)
                        if (trame[i + 3] != i)
                            verif = false;

                    if (verif)
                    {
                        NombreMessagesCorrects++;
                        Reponses[trame[2]].Add(ReponseLiaison.OK);
                    }
                    else
                    {
                        NombreMessagesCorrompusReception++;
                        Reponses[trame[2]].Add(ReponseLiaison.CorrompuReception);
                    }
                }

                IDTestReceptionActuel = (byte)(trame[2] + 1);
            }
            if ((FonctionBalise)trame[1] == FonctionBalise.TestEmissionPerdu)
            {
                byte idAttendu = trame[2];
                byte idRecu = trame[3];

                if (idRecu > idAttendu)
                    NombreMessagesPerdusEmission += idRecu - idAttendu;
                else
                {
                    NombreMessagesPerdusEmission += 255 - idAttendu;
                    NombreMessagesPerdusEmission += idRecu;
                }

                if (trame[2] != IDTestReceptionActuel)
                {
                    if (trame[2] < IDTestReceptionActuel)
                    {
                        NombreMessagesPerdusReception += 255 - IDTestReceptionActuel;
                        NombreMessagesPerdusReception += trame[2];

                        for (int i = IDTestReceptionActuel + 1; i < 256; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);

                        for (int i = 0; i < trame[2]; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);
                    }
                    else
                    {
                        NombreMessagesPerdusReception += trame[2] - IDTestReceptionActuel;

                        for (int i = IDTestReceptionActuel; i < trame[2]; i++)
                            Reponses[i].Add(ReponseLiaison.PerduReception);
                    }
                }

                IDTestReceptionActuel = (byte)(idRecu + 1);
            }
        }
Example #23
0
        private void ReceptionCallback(IAsyncResult ar)
        {
            try
            {
                UdpClient u = (UdpClient)((UdpState)(ar.AsyncState)).u;

                IPEndPoint e = new IPEndPoint(IPAddress.Any, PortEntree);

                Byte[] receiveBytes = u.EndReceive(ar, ref e);

                ConnexionCheck.MajConnexion();

                Trame trameRecue = new Trame(receiveBytes);
                if (trameRecue.ToString() == "C2 A1 C5")
                    trameRecue = new Trame("C2 A1 C3");
                TrameRecue(trameRecue);

                UdpState s = new UdpState();
                s.e = e;
                s.u = u;
                u.BeginReceive(ReceptionCallback, s);
            }
            catch (Exception)
            {
            }
        }
Example #24
0
 public TrameReplay(Trame trame, DateTime date, bool entrant = true)
 {
     Trame = trame.ToString();
     Date = date;
     Entrant = entrant;
 }
Example #25
0
        /// <summary>
        /// Permet de simuler la réception des trames enregistrées en respectant les intervalles de temps entre chaque trame
        /// </summary>
        public void Rejouer()
        {
            for (int i = 0; i < Trames.Count;i++)
            {
                Trame trame = new Trame(Trames[i].Trame);

                if (Trames[i].Entrant)
                    Connexions.ConnexionParCarte[trame.Carte].TrameRecue(trame);
                //else
                //    Connexions.ConnexionParCarte[trame.Carte].SendMessage(trame);

                if (i - 1 > 0)
                    Thread.Sleep(Trames[i].Date - Trames[i - 1].Date);
            }
        }
Example #26
0
 public static Carte Identifiant(Trame trame)
 {
     try
     {
         switch (trame[0])
         {
             default:
                 return (Carte)trame[0];
         }
     }
     catch (Exception)
     {
         return Carte.PC;
     }
 }
Example #27
0
 /// <summary>
 /// Ajoute une trame reçue avec l'heure définie
 /// </summary>
 /// <param name="trame">Trame à ajouter</param>
 /// <param name="date">Heure de réception de la trame</param>
 public void AjouterTrameEntrante(Trame trame, DateTime date)
 {
     lock (Trames)
         Trames.Add(new TrameReplay(trame, date, true));
 }
Example #28
0
        public static Trame OffsetPos(int offsetX, int offsetY, double offsetTeta, Robot robot)
        {
            byte[] tab = new byte[8];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.EnvoiPositionAbsolue;
            tab[2] = ByteDivide(offsetX, true);
            tab[3] = ByteDivide(offsetX, false);
            tab[4] = ByteDivide(offsetY, true);
            tab[5] = ByteDivide(offsetY, false);
            tab[6] = ByteDivide((int)(offsetTeta * 100), true);
            tab[7] = ByteDivide((int)(offsetTeta * 100), false);

            Trame retour = new Trame(tab);
            return retour;
        }
Example #29
0
 /// <summary>
 /// Ajoute une trame envoyée avec l'heure définie
 /// </summary>
 /// <param name="trame">Trame à ajouter</param>
 /// <param name="date">Heure de réception de la trame</param>
 public void AjouterTrameSortante(Trame trame, DateTime date)
 {
     lock (Trames)
         Trames.Add(new TrameReplay(trame, date, false));
 }
Example #30
0
        public static Trame Pivot(SensGD sens, double angle, Robot robot)
        {
            //angle = angle * Math.PI * 268.471260977282 / 2.0 / 180.0;
            byte[] tab = new byte[7];
            tab[0] = (byte)robot.Carte;
            tab[1] = (byte)FonctionMove.Pivot;
            tab[2] = (byte)sens;
            tab[3] = ByteDivide((int)(angle * 100.0), true);
            tab[4] = ByteDivide((int)(angle * 100.0), false);

            Trame retour = new Trame(tab);
            return retour;
        }