Python vrep.simxSynchronousTrigger函数代码示例

 def getRange(self):
     "get motor range"
     eCode, value = vrep.simxGetFloatSignal(self.robot, "HOMEO_SIGNAL_"+self._wheel+"Wheel"+"_MAX_SPEED",getattr(vrep,self._opMode))
     vrep.simxSynchronousTrigger(self.robot)
     if eCode != 0:
         raise TransducerException("Cannot get maxSpeed of VREP motor: " + self._wheel+"Wheel")
     return value

    def restart(self,earlyStop = False):
        if (self.cid != None):
            vrep.simxStopSimulation(self.cid, self.mode())
            vrep.simxSynchronousTrigger(self.cid)
        vrep.simxFinish(-1)  # just in case, close all opened connections
        time.sleep(1)
        self.connect()
        time.sleep(1)

        vrep.simxLoadScene(self.cid, '/home/elias/[email protected]/_Winter2015/CSC494/Scenes/Base_Quad.ttt', 0, self.mode())
        if earlyStop:
            vrep.simxStopSimulation(self.cid, self.mode())
            vrep.simxSynchronousTrigger(self.cid)
            vrep.simxFinish(-1)  # just in case, close all opened connections
            return
        vrep.simxStartSimulation(self.cid, self.mode())
        self.runtime = 0
        err, self.copter = vrep.simxGetObjectHandle(self.cid, "Quadricopter_base",
                                               vrep.simx_opmode_oneshot_wait)
        err, self.target = vrep.simxGetObjectHandle(self.cid, "Quadricopter_target",
                                               vrep.simx_opmode_oneshot_wait)

        err, self.front_camera = vrep.simxGetObjectHandle(self.cid, 'Quadricopter_frontCamera', vrep.simx_opmode_oneshot)

        err, lin, ang = vrep.simxGetObjectVelocity(self.cid, self.copter, vrep.simx_opmode_streaming)
        self.getTargetStart()
        for i in range(4):
            self.propellerScripts[i] = vrep.simxGetObjectHandle(self.cid,
                                                            'Quadricopter_propeller_respondable' + str(i) + str(1),
                                                            self.mode())

 def cleanUp(self):
     print "About to stop simulation connected to self.simulID: ", self.simulID
     vrep.simxStopSimulation(self.simulID, vrep.simx_opmode_oneshot)
     vrep.simxSynchronousTrigger(self.simulID)                    
     vrep.simxFinish(self.simulID)
     vrep.simxFinish(-1)
     print "Disconnected from V-REP"

 def testMaxSpeed(self, maxSpeed, mode):
     """test max speed of khepera-like robot in V-Rep
        revving the motors up to maxSpeed in the self.noSteps and then backward.
        mode--> 1, both motors, 2: right only, 3: left only"""
     if mode == 1: 
         rightOn = leftOn = 1
     elif mode == 2:             
         rightOn = 1
         leftOn = 0
     elif mode == 3:
         rightOn = 0
         leftOn = 1
     unitSpeed = maxSpeed /self.noSteps
          
     for i in xrange(self.noSteps):
         eCode = vrep.simxSetJointTargetVelocity(self.simulID, self.rightMotor, unitSpeed *(i+1)*rightOn, vrep.simx_opmode_oneshot_wait)
         eCode = vrep.simxSetJointTargetVelocity(self.simulID, self.leftMotor,  unitSpeed *(i+1)*leftOn, vrep.simx_opmode_oneshot_wait)
         vrep.simxSynchronousTrigger(self.simulID)
         print "Step: %s\t Speed now: %.2f" %(str(i),(unitSpeed *(i+1)))
    
     for i in xrange(self.noSteps):
         eCode = vrep.simxSetJointTargetVelocity(self.simulID, self.rightMotor, -(maxSpeed/(i+1))*rightOn, vrep.simx_opmode_oneshot_wait)
         eCode = vrep.simxSetJointTargetVelocity(self.simulID, self.leftMotor,  -(maxSpeed/(i+1))*leftOn, vrep.simx_opmode_oneshot_wait)
         vrep.simxSynchronousTrigger(self.simulID)
         print "Step: %s\t Speed now: %.2f" % (str(i), (maxSpeed/(i+1))*rightOn) 

 def __call__(self, t, values):
     self.count += 1
     if self.count == int(round(self.sim_dt/self.nengo_dt)):
         self.count = 0
         self.handle_input( values )
         if self.sync:
           vrep.simxSynchronousTrigger( self.cid )
     return self.handle_output()

    def act(self):
        '''activates the wheel motor by calling the actuator function (transdFunction) with 
           VREP client (stored in self.robot) and the needed parameters (stored in funcParameters)'''
#         parametersString =  str(self.robot) + ", " + str(self._transducID) + ", " + str(self.funcParameters) + ", " + 'vrep.'+self._opMode
        eCode = self.transdFunction(self.robot, self._transducID, self.funcParameters, getattr(vrep, self._opMode))
        vrep.simxSynchronousTrigger(self.robot)
        if eCode != 0:
            stderr.write("Motor command to VREP motor:%sWheel failed " % self._wheel)

    def __init__(self, simulatorModel=None):
        self.robotOrientationFirstTime = True
        self.getDistanceToGoalFirstTime = True
        self.getUpDistanceFirstTime = True
        self.getObjectPositionFirstTime = True
        self.sysConf = LoadSystemConfiguration()
        #this data structure is like a cache for the joint handles
        self.jointHandleMapping = {} 
        robotConf = LoadRobotConfiguration()
        self.model = simulatorModel
        self.LucyJoints = robotConf.getJointsName()            
        for joint in self.LucyJoints:
            self.jointHandleMapping[joint]=0
        self.clientId = self.connectVREP()
        RETRY_ATTEMPTS = 50
        if simulatorModel:
            for i in range(RETRY_ATTEMPTS):
                #TODO try to reutilize the same scene for the sake of performance
                error = self.loadscn(self.clientId, simulatorModel)
                if not error:
                    break
                print "retrying connection to vrep"

            if error:
                raise VrepException("error loading Vrep robot model", -1)
       
        if int(self.sysConf.getProperty("synchronous mode?"))==1:
            self.synchronous = True
            vrep.simxSynchronousTrigger(self.clientId)
        else:
            self.synchronous = False
        
        self.speedmodifier = int(self.sysConf.getProperty("speedmodifier"))

        #setting the simulation time step                           
        self.simulationTimeStepDT = float(self.sysConf.getProperty("simulation time step"))

        '''#testing printing in vrep
        error, consoleHandler = vrep.simxAuxiliaryConsoleOpen(self.clientId, "lucy debugging", 8, 22, None, None, None, None, vrep.simx_opmode_oneshot_wait)
        print "console handler: ", consoleHandler
        vrep.simxAuxiliaryConsoleShow(self.clientId, consoleHandler, 1, vrep.simx_opmode_oneshot_wait)
        error = vrep.simxAuxiliaryConsolePrint(self.clientId, consoleHandler, "Hello World", vrep.simx_opmode_oneshot_wait)'''

        error, self.upDistanceHandle = vrep.simxGetDistanceHandle(self.clientId, "upDistance#", vrep.simx_opmode_blocking)
        error, self.distLFootToGoalHandle = vrep.simxGetDistanceHandle(self.clientId, "distanceLFootGoal#", vrep.simx_opmode_blocking)
        error, self.distRFootToGoalHandle = vrep.simxGetDistanceHandle(self.clientId, "distanceRFootGoal#", vrep.simx_opmode_blocking)
        error, self.bioloidHandle = vrep.simxGetObjectHandle(self.clientId,"Bioloid", vrep.simx_opmode_oneshot_wait)
        error, self.cuboidHandle = vrep.simxGetObjectHandle(self.clientId,"Cuboid", vrep.simx_opmode_oneshot_wait)
        error, self.armHandler = vrep.simxGetObjectHandle(self.clientId, "Pivot", vrep.simx_opmode_oneshot_wait)

        self.populateJointHandleCache(self.clientId)

        self.isRobotUpFirstCall = True
        self.getDistanceToSceneGoal() #to fix the first invocation
        self.getUpDistance()
        self.isRobotUp(self.clientId)
        self.armPositionXAxis = -9.0000e-02

    def stepsim(self, steps):
        """
        Do n-steps of simulation.

        :param steps: Number of steps you want to simulate
        :type steps: int
        """
        for i in xrange(steps):
            vrep.simxSynchronousTrigger(self._clientID)

 def reset(self):
     """In VREP we reset a simulation by stopping and restarting it"""
     eCode = vrep.simxStopSimulation(self._VREP_clientId, vrep.simx_opmode_oneshot_wait)  
     if eCode != 0:
         raise Exception("Could not stop VREP simulation")
     eCode = vrep.simxStartSimulation(self._VREP_clientId, vrep.simx_opmode_oneshot_wait)   
     if eCode != 0:
         raise Exception("Could not start VREP simulation")
     vrep.simxSynchronousTrigger(self._VREP_clientId)

    def read(self):
#         sensingParameters = self.robot + ", " + self._VREPSignalName +  ", " + 'vrep.'+self._opMode
        eCode, value = self._transdFunction(self.robot, self._VREPSignalName , getattr(vrep, self._opMode))
        vrep.simxSynchronousTrigger(self.robot)
        if eCode != 0:
#             raise Exception("Cannot read value for sensor " + self._eye+"Eye")
            stderr.write("Cannot read value for sensor " + self._eye+"Eye")
            return 0
        return value

 def sendSignalVREP(self,signalName, signalValue):
     if type(signalValue) == str:
         eCode = vrep.simxSetStringSignal(self._VREP_clientId, signalName, asByteArray(signalValue), vrep.simx_opmode_oneshot_wait)
     elif type(signalValue) == int:
         eCode = vrep.simxSetIntegerSignal(self._VREP_clientId, signalName, signalValue, vrep.simx_opmode_oneshot_wait)
     elif type(signalValue) == float:
         eCode = vrep.simxSetFloatSignal(self._VREP_clientId, signalName, signalValue, vrep.simx_opmode_oneshot_wait)
     else:
         raise Exception("Trying to send a signal of unknown data type. Only strings, floats and and ints are accepted")
     if eCode != 0:
         raise Exception("Could not send string signal", signalValue)
     vrep.simxSynchronousTrigger(self._VREP_clientId)

 def setJointPosition(self, clientID, joint, angle):
     error = False
     handle = self.jointHandleMapping[joint]
     if handle == 0:
         errorGetObjetHandle, handle=vrep.simxGetObjectHandle(clientID,joint,vrep.simx_opmode_oneshot_wait)
         error = errorGetObjetHandle or error
         self.jointHandleMapping[joint]=handle
     #error = error or vrep.simxSetJointPosition(clientID,handle,angle,vrep.simx_opmode_oneshot_wait)
     error = error or vrep.simxSetJointPosition(clientID,handle,angle,vrep.simx_opmode_oneshot) #using oneshot instead of oneshot_wait make it a nonblocking call but is the only way to avoid 5 seconds wait in the execution of the individual
     if self.synchronous:
         vrep.simxSynchronousTrigger(clientID)
     return error

    def __call__( self, t, values ):
        """ This class will be callable within a nengo node. It will accept as input
        the control signals for each rotor, and will output the relevant state
        variables (position, velocity, orientation, angular velocity).
        """
        self.count += 1
        if self.count == int(round(sim_dt/dt)):
            self.count = 0
            self.handle_input( values )

            if SYNC:
                vrep.simxSynchronousTrigger( self.cid )
        return self.handle_output()

 def VREPConnect(self):
     vrep.simxFinish(-1)
     "Connect to Simulation"
     self.simulID = vrep.simxStart(self.robot_host,self.simulation_port,True,True, 5000,5)
     eCode = vrep.simxSynchronous(self.simulID, True)
     if eCode != 0:
         print "Could not get V-REP to synchronize operation with me"
 
     if not self.simulID == -1:
         eCode = vrep.simxStartSimulation(self.simulID, vrep.simx_opmode_oneshot)
         vrep.simxSynchronousTrigger(self.simulID)                    
         print "my SimulID is  ", self.simulID 
     else:
         sys.exit("Failed to connect to VREP simulation. Bailing out")

    def braiten1b(self):
        "slowly move forward and print normal vector readings"
        intens = 100
        ambientIntensRatio = 0.2
        attVect = [0,0,pi *4]

        for step in xrange(self.noSteps):
            rightInput = vrep.simxReadProximitySensor(self.simulID, self.rightEye, vrep.simx_opmode_oneshot_wait)
            vrep.simxSynchronousTrigger(self.simulID)
            leftInput = vrep.simxReadProximitySensor(self.simulID, self.leftEye, vrep.simx_opmode_oneshot_wait)
            vrep.simxSynchronousTrigger(self.simulID)
            centerInput = vrep.simxReadProximitySensor(self.simulID, self.KJcenterEye, vrep.simx_opmode_oneshot_wait)
            vrep.simxSynchronousTrigger(self.simulID)
            angle = degrees(self.angleBetVecs([0,0,1], centerInput[2]))
            lightReading = self.irradAtSensor(intens, ambientIntensRatio, centerInput[2], attVect)
            print "Center-->err:%s - Detct'd: %s\tAngle:%.3f\tIrrad:%.3f\tNorm: %.3f\tVector:%s\t" % (centerInput[0],
                                                                                                      centerInput[3],
                                                                                                      angle,
                                                                                                      lightReading,
                                                                                                      norm(centerInput[2]),
                                                                                                      centerInput[2])
            eCode = vrep.simxSetJointTargetVelocity(self.simulID, self.rightMotor, 1/lightReading, vrep.simx_opmode_oneshot_wait)
            eCode = vrep.simxSetJointTargetVelocity(self.simulID, self.leftMotor,  1/lightReading, vrep.simx_opmode_oneshot_wait)
            vrep.simxSynchronousTrigger(self.simulID)
            sleep(0)