Rotate the motor at ``speed`` for ``degrees``

        ``speed`` can be a percentage or a :class:`ev3dev2.motor.SpeedValue`
        object, enabling use of other units.
4932
def on_for_degrees(self, speed, degrees, brake=True, block=True):
        
        speed_sp = self._speed_native_units(speed)
        self._set_rel_position_degrees_and_speed_sp(degrees, speed_sp)
        self._set_brake(brake)
        self.run_to_rel_pos()

        if block:
            self.wait_until('running', timeout=WAIT_RUNNING_TIMEOUT)
            self.wait_until_not_moving()
516041
def forward(self, speed=1):
        
        if isinstance(self.enable_device, DigitalOutputDevice):
            if speed not in (0, 1):
                raise ValueError(
                    'forward speed must be 0 or 1 with non-PWM Motors')
        self.enable_device.off()
        self.phase_device.off()
        self.enable_device.value = speed
823644
def rotation(ATTITUDE):
    ''''''
    r = Matrix3()
    r.from_euler(ATTITUDE.roll, ATTITUDE.pitch, ATTITUDE.yaw)
    return r
793561
def on(self, steering, speed):
        
        (left_speed, right_speed) = self.get_speed_steering(steering, speed)
        MoveTank.on(self, SpeedNativeUnits(left_speed), SpeedNativeUnits(right_speed))
41670
def rotate_left(self, seconds=None):
        """"""
        self._move(speed=0, steering=STEER_MAX, seconds=seconds)
844427
def flick(self, xspeed, yspeed):
        
        self._actions.append(lambda: self._driver.execute(
            Command.FLICK, {
                'xspeed': int(xspeed),
                'yspeed': int(yspeed)}))
        return self
1370153
def rotateTo(self, angle):
        
        self._transmogrophy(angle, self.percent, self.scaleFromCenter, self.flipH, self.flipV)
545240
def rotate_about(self, p, theta):
        
        result = self.clone()
        result.translate(-p.x, -p.y)
        result.rotate(theta)
        result.translate(p.x, p.y)
        return result
61107
def backward(self, speed=1):
        
        self.left_motor.backward(speed)
        self.right_motor.backward(speed)
645818
def speed(self):
        
        self._speed, value = self.get_attr_int(self._speed, 'speed')
        return value
314733
function rotateTo(degree) {
    var imageData = this.imageData;


    degree = Number(degree);

    if (isNumber(degree) && this.viewed && !this.played && this.options.rotatable) {
      imageData.rotate = degree;
      this.renderImage();
    }

    return this;
  }
273930
def build_rotation(vec3):
        
        if not isinstance(vec3, Vector3):
            raise ValueError("rotAmt must be a Vector3")
        return Matrix4.x_rotate(vec3.x) * Matrix4.y_rotate(vec3.y) * Matrix4.z_rotate(vec3.z)
986458
def drive_rotational_speed_rpm(self):
        """"""
        drv_rot_speed_rpm = set()
        for member in self.get_members():
            if member.rotational_speed_rpm is not None:
                drv_rot_speed_rpm.add(member.rotational_speed_rpm)
        return drv_rot_speed_rpm
1309808
def set_speed(self,speed):
	""""""
	self.speed=speed
	self.send_cmd("SPEED"+str(speed))
158819
public void setValue(Quaternionf rot) {
        mX = rot.x;
        mY = rot.y;
        mZ = rot.z;
        mW = rot.w;
    }
326367
def set_speed(self, value):
        ''' '''
        self._combined_speed = float(value)
        speed_per_min = int(self._combined_speed * SEC_PER_MIN)
        command = GCODES['SET_SPEED'] + str(speed_per_min)
        log.debug("set_speed: {}".format(command))
        self._send_command(command)
1034948
def cmd_gimbal_rate(self, args):
        ''''''
        if len(args) != 3:
            print("usage: gimbal rate ROLL PITCH YAW")
            return
        (roll, pitch, yaw) = (float(args[0]), float(args[1]), float(args[2]))
        self.master.mav.gimbal_control_send(self.target_system,
                                            mavutil.mavlink.MAV_COMP_ID_GIMBAL,
                                            radians(roll),
                                            radians(pitch),
                                            radians(yaw))