def test_run_direct(self):
self.clientSocketMock.send_command.return_value = 1
motor = Motor(OUTPUT_A)
motor.duty_cycle_sp = 30
motor.stop_action = 'coast'
motor.run_direct()
self.assertEqual(len(self.clientSocketMock.mock_calls), 1)
fn_name, args, kwargs = self.clientSocketMock.mock_calls[0]
self.assertEqual(fn_name, 'send_command')
self.assertDictEqual(args[0].serialize(),
{'type': 'RotateCommand', 'address': 'ev3-ports:outA', 'stop_action': 'coast',
'speed': 315, 'distance': 14175.0})
while event:
try:
(tv_sec, tv_usec, ev_type, code, value) = struct.unpack(FORMAT, event)
if ev_type == 3 and code == 3:
right_stick_x = value
if ev_type == 3 and code == 4:
right_stick_y = value
# Scale stick positions to -100,100
forward = scale(right_stick_y, (0, 255), (100, -100))
left = scale(right_stick_x, (0, 255), (100, -100))
# Set motor voltages. If we're steering left, the left motor
# must run backwards so it has a -left component
# It has a forward component for going forward too.
left_motor.run_direct(duty_cycle_sp=clamp(forward - left * 0.3))
right_motor.run_direct(duty_cycle_sp=clamp(forward + left * 0.3))
steer_err = steer_motor.position - left * 0.5
steer_motor.run_direct(duty_cycle_sp=clamp(steer_err * -2))
# Finally, read another event
event = in_file.read(EVENT_SIZE)
except:
in_file.close()
left_motor.stop()
right_motor.stop()
steer_motor.stop()
break
class movimiento:
def __init__(self, motor_izquierdo, motor_derecho, diametro_rueda,
separacion_ruedas):
self._motor_izquierdo = Motor(motor_izquierdo)
self._motor_derecho = Motor(motor_derecho)
self._dos_motores = MoveTank(motor_izquierdo, motor_derecho)
self._radio = diametro_rueda / 2
self._sruedas = separacion_ruedas
def _SpeedRadPS(self, value):
return SpeedRPS(value / (2 * pi))
#Motores separados
@property
def w_motor_derecho(self):
return 2 * pi * (self._motor_derecho.speed /
self._motor_derecho.count_per_rot)
@w_motor_derecho.setter
def w_motor_derecho(self, velocidad):
self._motor_derecho.on(self._SpeedRadPS(velocidad))
@property
def w_motor_izquierdo(self):
return 2 * pi * (self._motor_izquierdo.speed /
self._motor_izquierdo.count_per_rot)
@w_motor_izquierdo.setter
def w_motor_izquierdo(self, velocidad):
self._motor_izquierdo.on(self._SpeedRadPS(velocidad))
@property
def dc_motor_izquierdo(self):
return self._motor_izquierdo.duty_cycle
@dc_motor_izquierdo.setter
def dc_motor_izquierdo(self, ciclo):
self._motor_izquierdo.run_direct(duty_cycle_sp=ciclo)
@property
def dc_motor_derecho(self):
return self._motor_derecho.duty_cycle
@dc_motor_derecho.setter
def dc_motor_derecho(self, ciclo):
self._motor_derecho.run_direct(duty_cycle_sp=ciclo)
#Ambos motores
def correr(self, linear, angular):
self._derecha = ((linear) +
((angular * self._sruedas) / 2)) / self._radio
self._izquierda = ((linear) -
((angular * self._sruedas) / 2)) / self._radio
self._dos_motores.on(self._SpeedRadPS(self._izquierda),
self._SpeedRadPS(self._derecha))
def correr_tiempo(self, linear, angular, seconds, bloqueo):
self._derecha = ((linear) +
((angular * self._sruedas) / 2)) / self._radio
self._izquierda = ((linear) -
((angular * self._sruedas) / 2)) / self._radio
self._dos_motores.on_for_seconds(self._SpeedRadPS(self._izquierda),
self._SpeedRadPS(self._derecha),
seconds,
block=bloqueo)
def parar(self):
self._dos_motores.off()
@property
def velocidad_linear(self):
return (
(self.w_motor_derecho + self.w_motor_izquierdo) / 2) * self._radio
@property
def velocidad_angular(self):
return ((self.w_motor_derecho - self.w_motor_izquierdo) *
self._radio) / self._sruedas
# long int, long int, unsigned short, unsigned short, unsigned int
FORMAT = 'llHHI'
EVENT_SIZE = struct.calcsize(FORMAT)
event = in_file.read(EVENT_SIZE)
while event:
try:
(tv_sec, tv_usec, ev_type, code, value) = struct.unpack(FORMAT, event)
if ev_type == 3 and code == 3:
right_stick_x = value
if ev_type == 3 and code == 4:
right_stick_y = value
# Scale stick positions to -100,100
forward = scale(right_stick_y, (0,255), (100,-100))
left = scale(right_stick_x, (0,255), (100,-100))
# Set motor voltages. If we're steering left, the left motor
# must run backwards so it has a -left component
# It has a forward component for going forward too.
left_motor.run_direct(duty_cycle_sp=clamp(forward - left))
right_motor.run_direct(duty_cycle_sp=clamp(forward + left))
# Finally, read another event
event = in_file.read(EVENT_SIZE)
except:
in_file.close()
left_motor.stop()
right_motor.stop()
break
class motores:
def __init__(self, motor_izquierdo, motor_derecho, radio_rueda,
separacion_ruedas):
self.motor_izquierdo = Motor(motor_izquierdo)
self.motor_derecho = Motor(motor_derecho)
self.dos_motores = MoveTank(motor_izquierdo, motor_derecho)
self.radio = radio_rueda
self.sruedas = separacion_ruedas
def SpeedRadPS(self, value):
return SpeedRPS(value / (2 * pi))
#Motores separados
@property
def w_motor_derecho(self):
return 2 * pi * (self.motor_derecho.speed /
self.motor_derecho.count_per_rot)
@w_motor_derecho.setter
def w_motor_derecho(self, velocidad):
self.motor_derecho.on(self.SpeedRadPS(velocidad))
@property
def w_motor_izquierdo(self):
return 2 * pi * (self.motor_izquierdo.speed /
self.motor_izquierdo.count_per_rot)
@w_motor_izquierdo.setter
def w_motor_izquierdo(self, velocidad):
self.motor_izquierdo.on(self.SpeedRadPS(velocidad))
@property
def dc_motor_izquierdo(self):
return self.motor_izquierdo.duty_cycle
@dc_motor_izquierdo.setter
def dc_motor_izquierdo(self, ciclo):
self.motor_izquierdo.run_direct(duty_cycle_sp=ciclo)
@property
def dc_motor_derecho(self):
return self.motor_derecho.duty_cycle
@dc_motor_derecho.setter
def dc_motor_derecho(self, ciclo):
self.motor_derecho.run_direct(duty_cycle_sp=ciclo)
@property
def posicion_motor_derecho(self):
return self.motor_derecho.position * pi / 180
@property
def posicion_motor_izquierdo(self):
return self.motor_izquierdo.position * pi / 180
#Ambos motores
def correr(self, linear, angular):
derecha = (linear + ((angular * self.sruedas) / 2)) / self.radio
izquierda = (linear - ((angular * self.sruedas) / 2)) / self.radio
self.dos_motores.on(self.SpeedRadPS(izquierda),
self.SpeedRadPS(derecha))
def correr_tiempo(self, linear, angular, tiempo, bloqueo):
derecha = ((linear) + ((angular * self.sruedas) / 2)) / self.radio
izquierda = ((linear) - ((angular * self.sruedas) / 2)) / self.radio
self.dos_motores.on_for_seconds(self.SpeedRadPS(izquierda),
self.SpeedRadPS(derecha),
tiempo,
block=bloqueo)
def parar(self):
self.dos_motores.off()
@property
def velocidad_linear(self):
return (
(self.w_motor_derecho + self.w_motor_izquierdo) / 2) * self.radio
@property
def velocidad_angular(self):
return ((self.w_motor_derecho - self.w_motor_izquierdo) *
self.radio) / self.sruedas