Esempio n. 1
0
    // Use this for initialization
    void Start()
    {
        if (GetComponent <NetworkIdentity>().isServer)
        {
            IniFile ini = new IniFile("Assets\\Scripts\\FahrradCom.EXE.ini");


            string ip1 = ini.IniReadValue("TCP", "IP");


            avr = new AVR_NetClient(ini.IniReadValue("TCP", "IP"),
                                    Int32.Parse(ini.IniReadValue("TCP", "Port")),
                                    Int32.Parse(ini.IniReadValue("TCP", "BufferSize")));

            Debug.Log("avr" + avr);

            speed = new Speed(Int32.Parse(ini.IniReadValue("Speed", "SensorCount")),
                              Int32.Parse(ini.IniReadValue("Speed", "SpeedSample")),
                              Double.Parse(ini.IniReadValue("Speed", "WheelLine")));

            //Debug.Log (ini.IniReadValue ("Speed", "SensorCount") + ini.IniReadValue ("Speed", "SpeedSample") + ini.IniReadValue ("Speed", "WheelLine"));

            // Winkel
            Angle angle = new Angle(Int32.Parse(ini.IniReadValue("Angle", "SensorMinValue")),
                                    Int32.Parse(ini.IniReadValue("Angle", "SensorMaxValue")),
                                    Int32.Parse(ini.IniReadValue("Angle", "SensorRange")),
                                    ini.IniReadValue("Angle", "SwitchDirection") == "0" ? true : false);


            // Daten zum lesen via TCP - die werden immer abgefragt
            NetData rd = new NetData();
            // Zum Beispiel:
            rd.addData(CONST.getANGLE());   //Winkel
            rd.addData(CONST.getSPEED());   //Geschwindigkeit
                                            // rd.addData(CONST.getSTATE());	//Status


            // Zuordnung der Datensets für die Kommunikation mit AVR
            avr.setDataToRead(rd);



            /* Ein Thread für die Kommunikation.
             * Ist wichtig vor allem für die Geschwindigkeitsberechnung.
             * Der SpeedSensor liefert eigentlich nur FALSE, wenn die MetallStücke am Rad (9 Stück)
             * vorbei "fahren" und TRUE wenn "die Luft rein ist". Die Abstände sind gleich (?),
             * deswegen auf Grund bekantes Radumfangs, auch die Teilstrecken (zwischen 2 Metallstücken)
             * einfach zu berechnen.
             * Für die Geschwindigkeit fehlt nun nur die Zeit. Die bekommt man, in dem man die Zeituterschiede
             * in Millisekunden zwischen 2 SpeedSensor-Aktivierungen ablesen kann. Je genauer desto besser.
             */
            tavr = new Thread(avr.startThread);
            tavr.Start();

            // Thread zum Lesen von Daten von AVR
            trd  = new Test_ReadData(speed, angle, rd, Int32.Parse(ini.IniReadValue("Speed", "SpeedResetAfter")));
            ttrd = new Thread(trd.StartThread);
            ttrd.Start();
        }
    }
Esempio n. 2
0
    public void StartThread()
    {
        stopThread = false;
        bool     sensor          = false;
        bool     allowSpeedReset = true;
        DateTime dt = DateTime.Now;
        long     resetSpeedStart = dt.Ticks;
        int      val;
        double   currWinkel;
        double   lastWinkel = -1000.0;

        Debug.Log("WORKER INSIDE");

        while (!stopThread)
        {
            // ****************************************
            // Winkel
            //*****************************************
            angle.setValue(rnd.getValue(CONST.getANGLE()));
            currWinkel = angle.getAngle();

            if (currWinkel != lastWinkel)
            {
                // um die Ausgabe der kleinsten Winkeländerungen zu vermeiden,
                // darf der Winkelunterschied nicht in Bereich <-1,1> liegen
                if (!inRange(currWinkel - lastWinkel, -1, 1))
                {
                    AngleForMono = currWinkel;
                    //Debug.Log("Winkel \n"+ currWinkel.ToString());
                    lastWinkel = currWinkel;
                }
            }

            // ****************************************
            // Geschwindigkeit
            //*****************************************
            if (rnd.getValue(CONST.getSPEED()).Length > 0)
            {
                val = Int32.Parse(rnd.getValue(CONST.getSPEED()));
                // Debug.Log("string: " + rnd.getValue(CONST.getSPEED()) + " parsed: " + val);


                if (val < this.fGrenze && sensor == false)
                {
                    sensor = true;
                    speed.setSensorTime(rnd.getDate(CONST.getSPEED()));
                    speedForMono = speed.getSpeed();
                    //Debug.Log("Speed m/s " + speedForMono.ToString());

                    resetSpeedStart = rnd.getDate(CONST.getSPEED());
                    allowSpeedReset = true;
                }

                if (val > this.fGrenze && sensor == true)
                {
                    sensor          = false;
                    resetSpeedStart = rnd.getDate(CONST.getSPEED());
                    allowSpeedReset = true;
                }

                //Es kann passieren, dass das Rad sich nicht bewegt, aber auf Grund
                //gespeicherten Daten Geschwindichkeit > 0 ist.
                //Wenn solcher Zustand länger als 2 Sek. dauert, wird die
                //Geschwindigkeit genullt.
                if (rnd.getDate(CONST.getSPEED()) - resetSpeedStart > this.fSpeedResetTime && allowSpeedReset)
                {
                    //speed.resetSpeed();
                    resetSpeedStart = rnd.getDate(CONST.getSPEED());
                    allowSpeedReset = false;
                    //Debug.Log("Speed m/s\n" + speed.getSpeed().ToString());
                }
            }
        }
    }