Stops the motor and returns the new target and position, which are equal
334018
def stop(self):
        """"""

        self._target = self.position

        self.log.info('Stopping movement after user request.')

        return self.target, self.position
565062
def stop_actions(self):
        
        self._stop_actions, value = self.get_attr_set(self._stop_actions, 'stop_actions')
        return value
782280
def postinit(self, target=None, value=None):
        
        self.target = target
        self.value = value
694232
def right(self, speed=1):
        
        self.left_motor.forward(speed)
        self.right_motor.backward(speed)
241730
def set_target(self, new_target):
        
        try:
            self.device.target = new_target
            return 'T={}'.format(new_target)
        except RuntimeError:
            return 'err: not idle'
        except ValueError:
            return 'err: not 0<=T<=250'
658413
def stop(self):
        
        if self.is_alive():
            self._can_run = False
            self._stop_event.set()
            self._profiler.total_time += time() - self._start_time
            self._start_time = None
326599
def reset(self):
        
        self._x = self._start_x
        self._y = self._start_y
1365807
def stop(self, precision=0):
        
        self._stop = time.perf_counter()
        return self.add_interval(precision)
367133
def branch(self, target):
        
        br = instructions.Branch(self.block, "br", [target])
        self._set_terminator(br)
        return br
432107
def right_brake(self):
        """"""
        self.board.digital_write(R_CTRL_1, 1)
        self.board.digital_write(R_CTRL_2, 1)
        self.board.analog_write(PWM_R, 0)
666561
def stop(self):
        
        if not self._timer.isActive():
            return

        self._elapsed += self._delta
        self._timer.stop()
21183
def shutdown(self):
        """"""
        self.stop_balance.set()  # Stop balance thread
        self.motor_left.stop()
        self.motor_right.stop()
        self.gyro_file.close()
        self.touch_file.close()
        self.encoder_left_file.close()
        self.encoder_right_file.close()
        self.dc_left_file.close()
        self.dc_right_file.close()
1129394
def get_intended_direction(self):
        
        x = 0
        y = 0
        if self.target_x == self.current_x and self.target_y == self.current_y:
            return y,x  # target already acquired
        if self.target_y > self.current_y:
            y = 1
        elif self.target_y < self.current_y:
            y = -1
        if self.target_x > self.current_x:
            x = 1
        elif self.target_x < self.current_x:
            x = -1
        return y,x
1233634
function() {
  if (!watching) return;

  hooks.on('action', function(event, name) {
    if (event == 'stopped' || event == 'failed')
      remove('start', name);
  });

  hooks.on('trigger', function(event, name) {
    if (event == 'stopped')
      remove('watch', name);
  });
}
211388
def end_effector(self):
        
        angles = self.convert_to_ik_angles(self.joints_position)
        return self.forward_kinematics(angles)[:3, 3]
945672
function(target) {
    this.stop();

    let self = this,
        o = self.opts,
        el = self.el = createEl(null, {
            className: o.className
        });

    css(el, {
        position: o.position,
        width: 0,
        zIndex: o.zIndex,
        left: o.left,
        top: o.top
    });

    if (target) {
        target.insertBefore(el, target.firstChild || null);
    }

    el.setAttribute('role', 'progressbar');
    self.lines(el, self.opts);

    if (!useCssAnimations) {
    // No CSS animation support, use setTimeout() instead
        let i = 0,
            start = (o.lines - 1) * (1 - o.direction) / 2,
            alpha,
            fps = o.fps,
            f = fps / o.speed,
            ostep = (1 - o.opacity) / (f * o.trail / 100),
            astep = f / o.lines;
        (function anim() {
            i++;
            for (let j = 0; j < o.lines; j++) {
                alpha = Math.max(1 - (i + (o.lines - j) * astep) % f * ostep, o.opacity);

                self.opacity(el, j * o.direction + start, alpha, o);
            }
            self.timeout = self.el && setTimeout(anim, ~~(1000 / fps));
        })();
    }
    return self;
}
380177
public void reset() {
    mGestureInProgress = false;
    mPointerCount = 0;
    for (int i = 0; i < MAX_POINTERS; i++) {
      mId[i] = MotionEvent.INVALID_POINTER_ID;
    }
  }