void InputDataGloves(string addressRight, string addressLeft)
    {
        tuplel[0]  = VRPN.vrpnAnalog(addressLeft, 0);
        tuplel[1]  = VRPN.vrpnAnalog(addressLeft, 1);
        tuplel[2]  = VRPN.vrpnAnalog(addressLeft, 2);
        tuplel[3]  = VRPN.vrpnAnalog(addressLeft, 3);
        tuplel[4]  = VRPN.vrpnAnalog(addressLeft, 4);
        tuplel[5]  = VRPN.vrpnAnalog(addressLeft, 5);
        tuplel[6]  = VRPN.vrpnAnalog(addressLeft, 6);
        tuplel[7]  = VRPN.vrpnAnalog(addressLeft, 7);
        tuplel[8]  = VRPN.vrpnAnalog(addressLeft, 8);
        tuplel[9]  = VRPN.vrpnAnalog(addressLeft, 9);
        tuplel[10] = VRPN.vrpnAnalog(addressLeft, 10);
        tuplel[11] = VRPN.vrpnAnalog(addressLeft, 11);
        tuplel[12] = VRPN.vrpnAnalog(addressLeft, 12);
        tuplel[13] = VRPN.vrpnAnalog(addressLeft, 13);

        meansl = GetMeansFromFile(filenamesl, 2); //TODO
        infol  = TestFingers(tuplel, meansl);

        /*
         * Debug.Log("Glove raw left = " + String.Join(", ",
         *  new List<double>(tuplel)
         *  .ConvertAll(i => i.ToString())
         *  .ToArray()));
         * Debug.Log("GloveL = " + String.Join(", ",
         *  new List<int>(infol)
         *  .ConvertAll(i => i.ToString())
         *  .ToArray()));
         */

        tuple[0]  = VRPN.vrpnAnalog(addressRight, 0);
        tuple[1]  = VRPN.vrpnAnalog(addressRight, 1);
        tuple[2]  = VRPN.vrpnAnalog(addressRight, 2);
        tuple[3]  = VRPN.vrpnAnalog(addressRight, 3);
        tuple[4]  = VRPN.vrpnAnalog(addressRight, 4);
        tuple[5]  = VRPN.vrpnAnalog(addressRight, 5);
        tuple[6]  = VRPN.vrpnAnalog(addressRight, 6);
        tuple[7]  = VRPN.vrpnAnalog(addressRight, 7);
        tuple[8]  = VRPN.vrpnAnalog(addressRight, 8);
        tuple[9]  = VRPN.vrpnAnalog(addressRight, 9);
        tuple[10] = VRPN.vrpnAnalog(addressRight, 10);
        tuple[11] = VRPN.vrpnAnalog(addressRight, 11);
        tuple[12] = VRPN.vrpnAnalog(addressRight, 12);
        tuple[13] = VRPN.vrpnAnalog(addressRight, 13);

        means = GetMeansFromFile(filenames, 2); //TODO
        info  = TestFingers(tuple, means);      //TODO

        /*
         * Debug.Log("Glove raw right= " + String.Join(", ",
         *  new List<double>(tuple)
         *  .ConvertAll(i => i.ToString())
         *  .ToArray()));
         * Debug.Log("GloveR = " + String.Join(", ",
         *  new List<int>(info)
         *  .ConvertAll(i => i.ToString())
         *  .ToArray()));
         */
    }
Example #2
0
    /// <summary>
    /// Asyncronous method that handles all the input from the analog stick
    /// </summary>
    /// <returns></returns>
    private IEnumerator Analog()
    {
        while (true)
        {
            //Get the X and Y values from the joystick
            double analogVertical   = VRPN.vrpnAnalog(trackerAddress, channelVertical);
            double analogHorizontal = VRPN.vrpnAnalog(trackerAddress, channelHorizontal);

            //Translate the holder
            toolManager.handleAnalog(analogHorizontal, analogVertical);
            yield return(null);
        }
    }
 /// <summary>
 /// Obtains the correct trackpad and trigger button values directly from VRPN and sets
 /// ClusterInput entries to correct value. Implemented because initial values
 /// from ClusterInput are incorrect.
 /// </summary>
 private static System.Collections.IEnumerator endOfFrameForMaster() {
     yield return new WaitForEndOfFrame();
     //Trackpad button updates
     ClusterInput.SetButton("leftTrackpad", VRPN.vrpnButton("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 32));
     ClusterInput.SetButton("rightTrackpad", VRPN.vrpnButton("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 32));
     //Trackpad axis updates
     ClusterInput.SetAxis("leftXAxis", (float)VRPN.vrpnAnalog("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 0));
     ClusterInput.SetAxis("leftYAxis", (float)VRPN.vrpnAnalog("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 1));
     ClusterInput.SetAxis("rightXAxis", (float)VRPN.vrpnAnalog("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 0));
     ClusterInput.SetAxis("rightYAxis", (float)VRPN.vrpnAnalog("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 1));
     //Trigger button updates
     ClusterInput.SetButton("leftTrigger", VRPN.vrpnButton("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 33));
     ClusterInput.SetButton("rightTrigger", VRPN.vrpnButton("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 33));
     //Trigger axis updates
     ClusterInput.SetAxis("leftTriggerAxis", (float)VRPN.vrpnAnalog("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 2));
     ClusterInput.SetAxis("rightTriggerAxis", (float)VRPN.vrpnAnalog("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 2));
 }
 /// <summary>
 /// Initial call to VRPN to allow data retrieval later
 /// in the program.
 /// </summary>
 private static System.Collections.IEnumerator oneTimeServerVrpnSet() {
     yield return new WaitForEndOfFrame();
     //Trackpad button entries
     VRPN.vrpnButton("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 32);
     VRPN.vrpnButton("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 32);
     //Trackpad axis entries
     VRPN.vrpnAnalog("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 0);
     VRPN.vrpnAnalog("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 1);
     VRPN.vrpnAnalog("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 0);
     VRPN.vrpnAnalog("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 1);
     //Trigger button entries
     VRPN.vrpnButton("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 33);
     VRPN.vrpnButton("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 33);
     //Trigger axis entry
     VRPN.vrpnAnalog("CC_FLAT_WAND0@" + CC_CONFIG.serverIP, 2);
     VRPN.vrpnAnalog("CC_FLAT_WAND1@" + CC_CONFIG.serverIP, 2);
 }
Example #5
0
    public void GetFingersData(string nameLeft, string nameRight)
    {
        //Left Glove
        TupleLeft[0]  = VRPN.vrpnAnalog(nameLeft, 0);
        TupleLeft[1]  = VRPN.vrpnAnalog(nameLeft, 1);
        TupleLeft[2]  = VRPN.vrpnAnalog(nameLeft, 2);
        TupleLeft[3]  = VRPN.vrpnAnalog(nameLeft, 3);
        TupleLeft[4]  = VRPN.vrpnAnalog(nameLeft, 4);
        TupleLeft[5]  = VRPN.vrpnAnalog(nameLeft, 5);
        TupleLeft[6]  = VRPN.vrpnAnalog(nameLeft, 6);
        TupleLeft[7]  = VRPN.vrpnAnalog(nameLeft, 7);
        TupleLeft[8]  = VRPN.vrpnAnalog(nameLeft, 8);
        TupleLeft[9]  = VRPN.vrpnAnalog(nameLeft, 9);
        TupleLeft[10] = VRPN.vrpnAnalog(nameLeft, 10);
        TupleLeft[11] = VRPN.vrpnAnalog(nameLeft, 11);
        TupleLeft[12] = VRPN.vrpnAnalog(nameLeft, 12);
        TupleLeft[13] = VRPN.vrpnAnalog(nameLeft, 13);
        MeansLeft     = GetMeansFromFile(FilenamesLeft, 2); //TODO
        InfoLeft      = TestFingers(TupleLeft, MeansLeft);
        //Right Glove
        TupleRight[0]  = VRPN.vrpnAnalog(nameRight, 0);
        TupleRight[1]  = VRPN.vrpnAnalog(nameRight, 1);
        TupleRight[2]  = VRPN.vrpnAnalog(nameRight, 2);
        TupleRight[3]  = VRPN.vrpnAnalog(nameRight, 3);
        TupleRight[4]  = VRPN.vrpnAnalog(nameRight, 4);
        TupleRight[5]  = VRPN.vrpnAnalog(nameRight, 5);
        TupleRight[6]  = VRPN.vrpnAnalog(nameRight, 6);
        TupleRight[7]  = VRPN.vrpnAnalog(nameRight, 7);
        TupleRight[8]  = VRPN.vrpnAnalog(nameRight, 8);
        TupleRight[9]  = VRPN.vrpnAnalog(nameRight, 9);
        TupleRight[10] = VRPN.vrpnAnalog(nameRight, 10);
        TupleRight[11] = VRPN.vrpnAnalog(nameRight, 11);
        TupleRight[12] = VRPN.vrpnAnalog(nameRight, 12);
        TupleRight[13] = VRPN.vrpnAnalog(nameRight, 13);
        Means          = GetMeansFromFile(Filenames, 2); //TODO
        InfoRight      = TestFingers(TupleRight, Means); //TODO

        //Old data
        if (InfoRight != null && InfoLeft != null)
        {
            InfoRightAnt = InfoRight;
            InfoLeftAnt  = InfoLeft;
        }
    }
Example #6
0
 //added by pohl 16.12.16
 public static double vrpnTrackerAnalog(string address, int channel)
 {
     return(VRPN.vrpnAnalog(address, channel));
 }
Example #7
0
    private IEnumerator Analog()
    {
        //some basic default analog wand movement.
        if (wandObject == null)
        {
            wandObject = GameObject.Find("Wand");
        }

        Vector3 modTrans;

        while (true)
        {
            double analogVertical   = VRPN.vrpnAnalog(trackerAddress, channelVertical);
            double analogHorizontal = VRPN.vrpnAnalog(trackerAddress, channelHorizontal);
            if (analogVertical >= deadZone || analogVertical <= -deadZone)
            {
                if (debugOutput)
                {
                    Debug.Log("Analog input value " + analogVertical + " on channel " + channelVertical);
                }

                if (holder != null)
                {
                    if (wandObject != null)
                    {
                        modTrans = wandObject.transform.localRotation * Vector3.forward * movementSpeed;
                    }
                    else
                    {
                        modTrans = Vector3.forward * movementSpeed;
                    }

                    if (restrictVerticalMovement)
                    {
                        modTrans.y = 0;
                    }

                    if (analogVertical >= deadZone)
                    {   //moving forward
                        holder.transform.Translate(modTrans);
                    }
                    else
                    {   //moving back
                        holder.transform.Translate(-modTrans);
                    }
                }
            }

            if (rotationMovement)
            {
                if (analogHorizontal >= deadZone || analogHorizontal <= -deadZone)
                {
                    if (debugOutput)
                    {
                        Debug.Log("Analog input value " + analogHorizontal + " on channel " + channelHorizontal);
                    }

                    if (holder != null)
                    {
                        if (analogHorizontal >= deadZone)
                        {   //rotating right
                            holder.transform.Rotate(new Vector3(0, rotationSpeed, 0));
                        }
                        else
                        {   //rotating left
                            holder.transform.Rotate(new Vector3(0, -rotationSpeed, 0));
                        }
                    }
                }
            }

            yield return(null);
        }
    }