legoEv3/ev3dev2/__pycache__/motor.cpython-35.pyc
[^4 @ s d d l Z e j d d f k r- e d d d l Z d d l Z d d l m Z d d l m Z m Z
m Z d d l m
Z
d d l m Z m Z m Z e e Z d Z e Z e d
k r d d l m Z m Z m Z m Z ne d k rd d l m Z m Z m Z m Z n e d
k rKd d l m Z m Z m Z m Z n e d k r|d d l m Z m Z m Z m Z nr e d k rd d l m Z m Z m Z m Z nA e d k rd d l m Z m Z m Z m Z n e d e Gd d d Z! Gd d d e! Z" Gd d d e! Z# Gd d d e! Z$ Gd d d e! Z% Gd d d e! Z& Gd d d e! Z' Gd d! d! e Z( e( j) d" d# Z* Gd$ d% d% e( Z+ Gd& d' d' e( Z, Gd( d) d) e( Z- Gd* d+ d+ e( Z. Gd, d- d- e Z/ Gd. d/ d/ e Z0 Gd0 d1 d1 e1 Z2 Gd2 d3 d3 e2 Z3 Gd4 d5 d5 e3 Z4 Gd6 d7 d7 e3 Z5 d S)8 N z"Must be using Python 3.4 or higher) getLogger)atan2degreessqrt)abspath)get_current_platformDevicelist_device_namesd Zev3)OUTPUT_AOUTPUT_BOUTPUT_COUTPUT_DZevbZpistormsZbrickpiZbrickpi3ZfakezUnsupported platform '%s'c @ s e Z d Z d Z d S)
SpeedValuez
A base class for other unit types. Don't use this directly; instead, see
:class:`SpeedPercent`, :class:`SpeedRPS`, :class:`SpeedRPM`,
:class:`SpeedDPS`, and :class:`SpeedDPM`.
N)__name__
__module__ __qualname____doc__ r r //usr/lib/python3/dist-packages/ev3dev2/motor.pyr F s r c @ s: e Z d Z d Z d d Z d d Z d d Z d S) SpeedPercentzC
Speed as a percentage of the motor's maximum rated speed.
c C s> d | k o d k n s1 t d j | | | _ d S)Nr zE{} is an invalid percentage, must be between -100 and 100 (inclusive)i)AssertionErrorformatpercent)selfr r r r __init__S s zSpeedPercent.__init__c C s t | j d S)N%)strr )r r r r __str__Y s zSpeedPercent.__str__c C s | j d | j S)z@
Return this SpeedPercent in native motor units
r )r max_speed)r motorr r r to_native_units\ s z SpeedPercent.to_native_unitsN)r r r r r r r# r r r r r N s r c @ s: e Z d Z d Z d d Z d d Z d d Z d S) SpeedNativeUnitsz+
Speed in tacho counts per second.
c C s
| | _ d S)N)
native_counts)r r% r r r r h s zSpeedNativeUnits.__init__c C s t | j d S)Nz counts/sec)r r% )r r r r r k s zSpeedNativeUnits.__str__c C s | j S)z:
Return this SpeedNativeUnits as a number
)r% )r r" r r r r# n s z SpeedNativeUnits.to_native_unitsN)r r r r r r r# r r r r r$ c s r$ c @ s: e Z d Z d Z d d Z d d Z d d Z d S) SpeedRPSz(
Speed in rotations-per-second.
c C s
| | _ d S)N)rotations_per_second)r r' r r r r y s zSpeedRPS.__init__c C s t | j d S)Nz rot/sec)r r' )r r r r r | s zSpeedRPS.__str__c C sN t | j | j k s9 t d j | | j | j | j | j | j S)zf
Return the native speed measurement required to achieve desired rotations-per-second
z@invalid rotations-per-second: {} max RPS is {}, {} was requested)absr' max_rpsr r r! )r r" r r r r# s 9zSpeedRPS.to_native_unitsN)r r r r r r r# r r r r r& t s r& c @ s: e Z d Z d Z d d Z d d Z d d Z d S) SpeedRPMz(
Speed in rotations-per-minute.
c C s
| | _ d S)N)rotations_per_minute)r r+ r r r r s zSpeedRPM.__init__c C s t | j d S)Nz rot/min)r r+ )r r r r r s zSpeedRPM.__str__c C sN t | j | j k s9 t d j | | j | j | j | j | j S)zf
Return the native speed measurement required to achieve desired rotations-per-minute
z@invalid rotations-per-minute: {} max RPM is {}, {} was requested)r( r+ max_rpmr r r! )r r" r r r r# s 9zSpeedRPM.to_native_unitsN)r r r r r r r# r r r r r* s r* c @ s: e Z d Z d Z d d Z d d Z d d Z d S) SpeedDPSz&
Speed in degrees-per-second.
c C s
| | _ d S)N)degrees_per_second)r r. r r r r s zSpeedDPS.__init__c C s t | j d S)Nz deg/sec)r r. )r r r r r s zSpeedDPS.__str__c C sN t | j | j k s9 t d j | | j | j | j | j | j S)zd
Return the native speed measurement required to achieve desired degrees-per-second
z>invalid degrees-per-second: {} max DPS is {}, {} was requested)r( r. max_dpsr r r! )r r" r r r r# s 9zSpeedDPS.to_native_unitsN)r r r r r r r# r r r r r- s r- c @ s: e Z d Z d Z d d Z d d Z d d Z d S) SpeedDPMz&
Speed in degrees-per-minute.
c C s
| | _ d S)N)degrees_per_minute)r r1 r r r r s zSpeedDPM.__init__c C s t | j d S)Nz deg/min)r r1 )r r r r r s zSpeedDPM.__str__c C sN t | j | j k s9 t d j | | j | j | j | j | j S)zd
Return the native speed measurement required to achieve desired degrees-per-minute
z>invalid degrees-per-minute: {} max DPM is {}, {} was requested)r( r1 max_dpmr r r! )r r" r r r r# s 9zSpeedDPM.to_native_unitsN)r r r r r r r# r r r r r0 s r0 c s e Z d Z d Z d Z d Z d d d d d d d
d d d
d d d d d d d d d d d d d d d d d d d d! d" d# g Z d$ Z d% Z d& Z d' Z
d( Z d) Z d* Z
d+ Z d, Z d+ Z d, Z d- Z d. Z d/ Z d0 Z d1 Z d2 Z d3 Z d4 Z d5 e d6 f d7 d8 Z e d9 d: Z e d; d< Z e j d= d< Z e d> d? Z e d@ dA Z e dB dC Z! e dD dE Z" e dF dG Z# e dH dI Z$ e$ j dJ dI Z$ e dK dL Z% e dM dN Z& e& j dO dN Z& e dP dQ Z' e' j dR dQ Z' e dS dT Z( e( j dU dT Z( e dV dW Z) e) j dX dW Z) e dY dZ Z* e* j d[ dZ Z* e d\ d] Z+ e+ j d^ d] Z+ e d_ d` Z, e da db Z- e dc dd Z. e. j de dd Z. e df dg Z/ e/ j dh dg Z/ e di dj Z0 e0 j dk dj Z0 e dl dm Z1 e1 j dn dm Z1 e do dp Z2 e2 j dq dp Z2 e dr ds Z3 e3 j dt ds Z3 e du dv Z4 e dw dx Z5 e5 j dy dx Z5 e dz d{ Z6 e d| d} Z7 e7 j d~ d} Z7 d d Z8 d d Z9 d d Z: d d Z; d d Z< d d Z= d d Z> e d d Z? e d d Z@ e d d ZA e d d ZB e d d ZC d5 d d ZD d5 d d ZE d5 d d ZF d5 d d ZG d5 d d ZH d d ZI d d ZJ d d d d ZK d d d d ZL d d d d ZM d d d d ZN d d6 d d ZO d d d ZP e d d ZQ e d d ZR S)Motora
The motor class provides a uniform interface for using motors with
positional and directional feedback such as the EV3 and NXT motors.
This feedback allows for precise control of the motors. This is the
most common type of motor, so we just call it `motor`.
z tacho-motor*_address_command _commands_count_per_rot _count_per_m _driver_name _duty_cycle_duty_cycle_sp_full_travel_count _polarity _position _position_p _position_i _position_d _position_sp
_max_speed_speed _speed_sp _ramp_up_sp
_ramp_down_sp_speed_p_speed_i_speed_d_state _stop_action
_stop_actions_time_sp_pollr) r, r/ r2 z run-foreverzrun-to-abs-poszrun-to-rel-posz run-timedz
run-directstopresetnormalinversedrunningZrampingZholdingZ
overloadedZstalledcoastbrakeZholdNFc s | d k r | | d <t t | j | j | | | d | _ d | _ d | _ d | _ d | _ d | _ d | _
d | _ d | _ d | _
d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ t | j! | j" | _# | j# d | _$ | j# d | _% | j$ d | _& d S)Naddress< ih )'superr3 r SYSTEM_CLASS_NAMEr5 r6 r7 r8 r9 r: r; r< r= r> r? r@ rA rB rC rD rE rF rG rH rI rJ rK rL rM rN rO rP floatr!
count_per_rotr) r, r/ r2 )r rX name_pattern
name_exactkwargs) __class__r r r 8 sF
" zMotor.__init__c C s" | j | j d \ | _ } | S)zO
Returns the name of the port that this motor is connected to.
rX )get_attr_stringr5 )r valuer r r rX _ s z
Motor.addressc C s t d d S)zp
Sends a command to the motor controller. See `commands` for a list of
possible values.
z!command is a write-only property!N) Exception)r r r r commandg s z
Motor.commandc C s | j | j d | | _ d S)Nre )set_attr_stringr6 )r rc r r r re o s c C s" | j | j d \ | _ } | S)a
Returns a list of commands that are supported by the motor
controller. Possible values are `run-forever`, `run-to-abs-pos`, `run-to-rel-pos`,
`run-timed`, `run-direct`, `stop` and `reset`. Not all commands may be supported.
- `run-forever` will cause the motor to run until another command is sent.
- `run-to-abs-pos` will run to an absolute position specified by `position_sp`
and then stop using the action specified in `stop_action`.
- `run-to-rel-pos` will run to a position relative to the current `position` value.
The new position will be current `position` + `position_sp`. When the new
position is reached, the motor will stop using the action specified by `stop_action`.
- `run-timed` will run the motor for the amount of time specified in `time_sp`
and then stop the motor using the action specified by `stop_action`.
- `run-direct` will run the motor at the duty cycle specified by `duty_cycle_sp`.
Unlike other run commands, changing `duty_cycle_sp` while running *will*
take effect immediately.
- `stop` will stop any of the run commands before they are complete using the
action specified by `stop_action`.
- `reset` will reset all of the motor parameter attributes to their default value.
This will also have the effect of stopping the motor.
commands) get_attr_setr7 )r rc r r r rg s s zMotor.commandsc C s" | j | j d \ | _ } | S)a
Returns the number of tacho counts in one rotation of the motor. Tacho counts
are used by the position and speed attributes, so you can use this value
to convert rotations or degrees to tacho counts. (rotation motors only)
r] ) get_attr_intr8 )r rc r r r r] s zMotor.count_per_rotc C s" | j | j d \ | _ } | S)z
Returns the number of tacho counts in one meter of travel of the motor. Tacho
counts are used by the position and speed attributes, so you can use this
value to convert from distance to tacho counts. (linear motors only)
count_per_m)ri r9 )r rc r r r rj s zMotor.count_per_mc C s" | j | j d \ | _ } | S)zW
Returns the name of the driver that provides this tacho motor device.
driver_name)rb r: )r rc r r r rk s zMotor.driver_namec C s" | j | j d \ | _ } | S)zq
Returns the current duty cycle of the motor. Units are percent. Values
are -100 to 100.
duty_cycle)ri r; )r rc r r r rl s zMotor.duty_cyclec C s" | j | j d \ | _ } | S)z
Writing sets the duty cycle setpoint. Reading returns the current value.
Units are in percent. Valid values are -100 to 100. A negative value causes
the motor to rotate in reverse.
duty_cycle_sp)ri r< )r rc r r r rm s zMotor.duty_cycle_spc C s | j | j d | | _ d S)Nrm ) set_attr_intr< )r rc r r r rm s c C s" | j | j d \ | _ } | S)z
Returns the number of tacho counts in the full travel of the motor. When
combined with the `count_per_m` atribute, you can use this value to
calculate the maximum travel distance of the motor. (linear motors only)
full_travel_count)ri r= )r rc r r r ro s zMotor.full_travel_countc C s" | j | j d \ | _ } | S)a-
Sets the polarity of the motor. With `normal` polarity, a positive duty
cycle will cause the motor to rotate clockwise. With `inversed` polarity,
a positive duty cycle will cause the motor to rotate counter-clockwise.
Valid values are `normal` and `inversed`.
polarity)rb r> )r rc r r r rp s zMotor.polarityc C s | j | j d | | _ d S)Nrp )rf r> )r rc r r r rp s c C s" | j | j d \ | _ } | S)a%
Returns the current position of the motor in pulses of the rotary
encoder. When the motor rotates clockwise, the position will increase.
Likewise, rotating counter-clockwise causes the position to decrease.
Writing will set the position to that value.
position)ri r? )r rc r r r rq s zMotor.positionc C s | j | j d | | _ d S)Nrq )rn r? )r rc r r r rq s c C s" | j | j d \ | _ } | S)zA
The proportional constant for the position PID.
z hold_pid/Kp)ri r@ )r rc r r r
position_p s zMotor.position_pc C s | j | j d | | _ d S)Nz hold_pid/Kp)rn r@ )r rc r r r rr s c C s" | j | j d \ | _ } | S)z=
The integral constant for the position PID.
z hold_pid/Ki)ri rA )r rc r r r
position_i s zMotor.position_ic C s | j | j d | | _ d S)Nz hold_pid/Ki)rn rA )r rc r r r rs s c C s" | j | j d \ | _ } | S)z?
The derivative constant for the position PID.
z hold_pid/Kd)ri rB )r rc r r r
position_d s zMotor.position_dc C s | j | j d | | _ d S)Nz hold_pid/Kd)rn rB )r rc r r r rt s c C s" | j | j d \ | _ } | S)a-
Writing specifies the target position for the `run-to-abs-pos` and `run-to-rel-pos`
commands. Reading returns the current value. Units are in tacho counts. You
can use the value returned by `count_per_rot` to convert tacho counts to/from
rotations or degrees.
position_sp)ri rC )r rc r r r ru s zMotor.position_spc C s | j | j d | | _ d S)Nru )rn rC )r rc r r r ru s c C s" | j | j d \ | _ } | S)z
Returns the maximum value that is accepted by the `speed_sp` attribute. This
may be slightly different than the maximum speed that a particular motor can
reach - it's the maximum theoretical speed.
r! )ri rD )r rc r r r r! s zMotor.max_speedc C s" | j | j d \ | _ } | S)z
Returns the current motor speed in tacho counts per second. Note, this is
not necessarily degrees (although it is for LEGO motors). Use the `count_per_rot`
attribute to convert this value to RPM or deg/sec.
speed)ri rE )r rc r r r rv % s z Motor.speedc C s" | j | j d \ | _ } | S)a
Writing sets the target speed in tacho counts per second used for all `run-*`
commands except `run-direct`. Reading returns the current value. A negative
value causes the motor to rotate in reverse with the exception of `run-to-*-pos`
commands where the sign is ignored. Use the `count_per_rot` attribute to convert
RPM or deg/sec to tacho counts per second. Use the `count_per_m` attribute to
convert m/s to tacho counts per second.
speed_sp)ri rF )r rc r r r rw / s
zMotor.speed_spc C s | j | j d | | _ d S)Nrw )rn rF )r rc r r r rw < s c C s" | j | j d \ | _ } | S)a
Writing sets the ramp up setpoint. Reading returns the current value. Units
are in milliseconds and must be positive. When set to a non-zero value, the
motor speed will increase from 0 to 100% of `max_speed` over the span of this
setpoint. The actual ramp time is the ratio of the difference between the
`speed_sp` and the current `speed` and max_speed multiplied by `ramp_up_sp`.
ramp_up_sp)ri rG )r rc r r r rx @ s zMotor.ramp_up_spc C s | j | j d | | _ d S)Nrx )rn rG )r rc r r r rx L s c C s" | j | j d \ | _ } | S)a
Writing sets the ramp down setpoint. Reading returns the current value. Units
are in milliseconds and must be positive. When set to a non-zero value, the
motor speed will decrease from 0 to 100% of `max_speed` over the span of this
setpoint. The actual ramp time is the ratio of the difference between the
`speed_sp` and the current `speed` and max_speed multiplied by `ramp_down_sp`.
ramp_down_sp)ri rH )r rc r r r ry P s zMotor.ramp_down_spc C s | j | j d | | _ d S)Nry )rn rH )r rc r r r ry \ s c C s" | j | j d \ | _ } | S)zI
The proportional constant for the speed regulation PID.
z speed_pid/Kp)ri rI )r rc r r r speed_p` s z
Motor.speed_pc C s | j | j d | | _ d S)Nz speed_pid/Kp)rn rI )r rc r r r rz h s c C s" | j | j d \ | _ } | S)zE
The integral constant for the speed regulation PID.
z speed_pid/Ki)ri rJ )r rc r r r speed_il s z
Motor.speed_ic C s | j | j d | | _ d S)Nz speed_pid/Ki)rn rJ )r rc r r r r{ t s c C s" | j | j d \ | _ } | S)zG
The derivative constant for the speed regulation PID.
z speed_pid/Kd)ri rK )r rc r r r speed_dx s z
Motor.speed_dc C s | j | j d | | _ d S)Nz speed_pid/Kd)rn rK )r rc r r r r| s c C s" | j | j d \ | _ } | S)z
Reading returns a list of state flags. Possible flags are
`running`, `ramping`, `holding`, `overloaded` and `stalled`.
state)rh rL )r rc r r r r} s z Motor.statec C s" | j | j d \ | _ } | S)a2
Reading returns the current stop action. Writing sets the stop action.
The value determines the motors behavior when `command` is set to `stop`.
Also, it determines the motors behavior when a run command completes. See
`stop_actions` for a list of possible values.
stop_action)rb rM )r rc r r r r~ s zMotor.stop_actionc C s | j | j d | | _ d S)Nr~ )rf rM )r rc r r r r~ s c C s" | j | j d \ | _ } | S)a(
Returns a list of stop actions supported by the motor controller.
Possible values are `coast`, `brake` and `hold`. `coast` means that power will
be removed from the motor and it will freely coast to a stop. `brake` means
that power will be removed from the motor and a passive electrical load will
be placed on the motor. This is usually done by shorting the motor terminals
together. This load will absorb the energy from the rotation of the motors and
cause the motor to stop more quickly than coasting. `hold` does not remove
power from the motor. Instead it actively tries to hold the motor at the current
position. If an external force tries to turn the motor, the motor will 'push
back' to maintain its position.
stop_actions)rh rN )r rc r r r r s zMotor.stop_actionsc C s" | j | j d \ | _ } | S)z
Writing specifies the amount of time the motor will run when using the
`run-timed` command. Reading returns the current value. Units are in
milliseconds.
time_sp)ri rO )r rc r r r r s z
Motor.time_spc C s | j | j d | | _ d S)Nr )rn rO )r rc r r r r s c K s5 x" | D] } t | | | | q W| j | _ d S)z5Run the motor until another command is sent.
N)setattrCOMMAND_RUN_FOREVERre )r r` keyr r r run_forever s
zMotor.run_foreverc K s5 x" | D] } t | | | | q W| j | _ d S)zRun to an absolute position specified by `position_sp` and then
stop using the action specified in `stop_action`.
N)r COMMAND_RUN_TO_ABS_POSre )r r` r r r r run_to_abs_pos s
zMotor.run_to_abs_posc K s5 x" | D] } t | | | | q W| j | _ d S)zRun to a position relative to the current `position` value.
The new position will be current `position` + `position_sp`.
When the new position is reached, the motor will stop using
the action specified by `stop_action`.
N)r COMMAND_RUN_TO_REL_POSre )r r` r r r r run_to_rel_pos s
zMotor.run_to_rel_posc K s5 x" | D] } t | | | | q W| j | _ d S)zRun the motor for the amount of time specified in `time_sp`
and then stop the motor using the action specified by `stop_action`.
N)r COMMAND_RUN_TIMEDre )r r` r r r r run_timed s
zMotor.run_timedc K s5 x" | D] } t | | | | q W| j | _ d S)zRun the motor at the duty cycle specified by `duty_cycle_sp`.
Unlike other run commands, changing `duty_cycle_sp` while running *will*
take effect immediately.
N)r COMMAND_RUN_DIRECTre )r r` r r r r
run_direct s
zMotor.run_directc K s5 x" | D] } t | | | | q W| j | _ d S)zsStop any of the run commands before they are complete using the
action specified by `stop_action`.
N)r COMMAND_STOPre )r r` r r r r rQ s
z
Motor.stopc K s5 x" | D] } t | | | | q W| j | _ d S)zReset all of the motor parameter attributes to their default value.
This will also have the effect of stopping the motor.
N)r
COMMAND_RESETre )r r` r r r r rR s
z Motor.resetc C s | j | j k S)z*Power is being sent to the motor.
)
STATE_RUNNINGr} )r r r r
is_running s zMotor.is_runningc C s | j | j k S)zYThe motor is ramping up or down and has not yet reached a constant output level.
)
STATE_RAMPINGr} )r r r r
is_ramping s zMotor.is_rampingc C s | j | j k S)zRThe motor is not turning, but rather attempting to hold a fixed position.
)
STATE_HOLDINGr} )r r r r
is_holding s zMotor.is_holdingc C s | j | j k S)z?The motor is turning, but cannot reach its `speed_sp`.
)STATE_OVERLOADEDr} )r r r r
is_overloaded s zMotor.is_overloadedc C s | j | j k S)z4The motor is not turning when it should be.
)
STATE_STALLEDr} )r r r r
is_stalled
s zMotor.is_stalledc C s t j } | j d k rd | j d k r< | j d | _ t j | _ | j j | j t j xc | | j rz d S| j j | d k r d n | | d k rg t j | | d k rg d Sqg Wd S)aH
Blocks until ``cond(self.state)`` is ``True``. The condition is
checked when there is an I/O event related to the ``state`` attribute.
Exits early when ``timeout`` (in milliseconds) is reached.
Returns ``True`` if the condition is met, and ``False`` if the timeout
is reached.
Nr} Ti F) timerP rL Z_attribute_file_openselectZpollregisterZPOLLPRIr} )r condtimeoutZticr r r wait s
"&z
Motor.waitc s j f d d | S)a
Blocks until ``running`` is not in ``self.state`` or ``stalled`` is in
``self.state``. The condition is checked when there is an I/O event
related to the ``state`` attribute. Exits early when ``timeout``
(in milliseconds) is reached.
Returns ``True`` if the condition is met, and ``False`` if the timeout
is reached.
Example::
m.wait_until_not_moving()
c s j | k p j | k S)N)r r )r} )r r r <lambda>< s z-Motor.wait_until_not_moving.<locals>.<lambda>)r )r r r )r r wait_until_not_moving. s zMotor.wait_until_not_movingc s | j f d d | S)a{
Blocks until ``s`` is in ``self.state``. The condition is checked when
there is an I/O event related to the ``state`` attribute. Exits early
when ``timeout`` (in milliseconds) is reached.
Returns ``True`` if the condition is met, and ``False`` if the timeout
is reached.
Example::
m.wait_until('stalled')
c s
| k S)Nr )r} )sr r r K s z"Motor.wait_until.<locals>.<lambda>)r )r r r r )r r
wait_until> s
zMotor.wait_untilc s | j f d d | S)a
Blocks until ``s`` is not in ``self.state``. The condition is checked
when there is an I/O event related to the ``state`` attribute. Exits
early when ``timeout`` (in milliseconds) is reached.
Returns ``True`` if the condition is met, and ``False`` if the timeout
is reached.
Example::
m.wait_while('running')
c s
| k S)Nr )r} )r r r r Z s z"Motor.wait_while.<locals>.<lambda>)r )r r r r )r r
wait_whileM s
zMotor.wait_whilec C sr t | t se d | k o& d k n sY t d j | d k rF d n | d | t | } | j | S)Nr zM{}{} is an invalid speed percentage, must be between -100 and 100 (inclusive) z: i)
isinstancer r r r r# )r rv Zlabelr r r _speed_native_units\ s
+ zMotor._speed_native_unitsc C sj | d k r | n | } t | } t t | | j d } t t | } | | _ | | _ d S)Nr ih )r( introundr] ru rw )r r rv Zposition_deltarw r r r &_set_rel_position_degrees_and_speed_spf s z,Motor._set_rel_position_degrees_and_speed_spc C s% | r | j | _ n | j | _ d S)N)STOP_ACTION_HOLDr~ STOP_ACTION_COAST)r rW r r r
_set_brakep s zMotor._set_brakeTc C s | d k s | d k r3 t d j | | | | j | } | j | d | | j | | j | r | j d d t | j d S)z
Rotate the motor at ``speed`` for ``rotations``
``speed`` can be a percentage or a :class:`ev3dev2.motor.SpeedValue`
object, enabling use of other units.
Nz+Either speed ({}) or rotations ({}) is Noneih rU r )
ValueErrorr r r r r r WAIT_RUNNING_TIMEOUTr )r rv rotationsrW blockrw r r r on_for_rotationsv s
zMotor.on_for_rotationsc C s | d k s | d k r3 t d j | | | | j | } | j | | | j | | j | r | j d d t | j d S)z
Rotate the motor at ``speed`` for ``degrees``
``speed`` can be a percentage or a :class:`ev3dev2.motor.SpeedValue`
object, enabling use of other units.
Nz)Either speed ({}) or degrees ({}) is NonerU r ) r r r r r r r r r )r rv r rW r rw r r r on_for_degrees s
zMotor.on_for_degreesc C s | j | } | s? t j d j | | | j | d St t | | _ | | _ | j | | j | r | j
d d t | j d S)z
Rotate the motor at ``speed`` to ``position``
``speed`` can be a percentage or a :class:`ev3dev2.motor.SpeedValue`
object, enabling use of other units.
z/({}) speed is invalid ({}), motor will not moveNrU r )
r logwarningr r r r rw ru r r r r )r rv rq rW r r r r on_to_position s
zMotor.on_to_positionc C s | j | } | s | rJ t j d j | | | | j | d St t | | _ t | d | _ | j | | j | r | j
d d t | j d S)z
Rotate the motor at ``speed`` for ``seconds``
``speed`` can be a percentage or a :class:`ev3dev2.motor.SpeedValue`
object, enabling use of other units.
zF({}) Either speed ({}) or seconds ({}) is invalid, motor will not moveNi rU r )
r r r r r r r rw r r r r r )r rv secondsrW r r r r on_for_seconds s
zMotor.on_for_secondsc C s | j | } | s? t j d j | | | j | d St t | | _ | j | | j | r | j d d t
| j d S)a%
Rotate the motor at ``speed`` for forever
``speed`` can be a percentage or a :class:`ev3dev2.motor.SpeedValue`
object, enabling use of other units.
Note that `block` is False by default, this is different from the
other `on_for_XYZ` methods.
z/({}) speed is invalid ({}), motor will not moveNrU r ) r r r r r r r rw r r r r )r rv rW r r r r on s
zMotor.onc C s | j | | j d S)N)r rQ )r rW r r r off s
z Motor.offc C s t | j | j S)N)r\ rq r] )r r r r r s zMotor.rotationsc C s | j d S)Nih )r )r r r r r s z
Motor.degrees)Sr r r r r[ SYSTEM_DEVICE_NAME_CONVENTION __slots__r r r r r r r ZENCODER_POLARITY_NORMALZENCODER_POLARITY_INVERSEDPOLARITY_NORMALPOLARITY_INVERSEDr r r r r r STOP_ACTION_BRAKEr r propertyrX re setterrg r] rj rk rl rm ro rp rq rr rs rt ru r! rv rw rx ry rz r{ r| r} r~ r r r r r r r rQ rR r r r r r r r r r r r r r r r r r r r r r r )ra r r3 s '
r3 c K s7 t t j d t j } d d t | | | D S)a
This is a generator function that enumerates all tacho motors that match
the provided arguments.
Parameters:
name_pattern: pattern that device name should match.
For example, 'motor*'. Default value: '*'.
keyword arguments: used for matching the corresponding device
attributes. For example, driver_name='lego-ev3-l-motor', or
address=['outB', 'outC']. When argument value
is a list, then a match against any entry of the list is
enough.
/c s s$ | ] } t d | d d Vq d S)r^ r_ TN)r3 ).0namer r r <genexpr> s z list_motors.<locals>.<genexpr>)r r
ZDEVICE_ROOT_PATHr3 r[ r )r^ r` Z
class_pathr r r list_motors s r c sF e Z d Z d Z e j Z d Z g Z d e d f d d Z S)
LargeMotorz
EV3/NXT large servo motor.
Same as :class:`Motor`, except it will only successfully initialize if it finds a "large" motor.
r4 NFc s/ t t | j | | | d d d g | d S)Nrk zlego-ev3-l-motorzlego-nxt-motor)rZ r r )r rX r^ r_ r` )ra r r r s zLargeMotor.__init__) r r r r r3 r[ r r r r r )ra r r s
r c sF e Z d Z d Z e j Z d Z g Z d e d f d d Z S) MediumMotorz
EV3 medium servo motor.
Same as :class:`Motor`, except it will only successfully initialize if it finds a "medium" motor.
r4 NFc s, t t | j | | | d d g | d S)Nrk zlego-ev3-m-motor)rZ r r )r rX r^ r_ r` )ra r r r s zMediumMotor.__init__) r r r r r3 r[ r r r r r )ra r r s
r c sF e Z d Z d Z e j Z d Z g Z d e d f d d Z S)ActuonixL1250Motorz
Actuonix L12 50 linear servo motor.
Same as :class:`Motor`, except it will only successfully initialize if it finds an Actuonix L12 50 linear servo motor
zlinear*NFc s, t t | j | | | d d g | d S)Nrk zact-l12-ev3-50)rZ r r )r rX r^ r_ r` )ra r r r 1 s zActuonixL1250Motor.__init__) r r r r r3 r[ r r r r r )ra r r % s
r c sF e Z d Z d Z e j Z d Z g Z d e d f d d Z S)ActuonixL12100Motorz
Actuonix L12 100 linear servo motor.
Same as :class:`Motor`, except it will only successfully initialize if it finds an Actuonix L12 100 linear servo motor
zlinear*NFc s, t t | j | | | d d g | d S)Nrk zact-l12-ev3-100)rZ r r )r rX r^ r_ r` )ra r r r B s z ActuonixL12100Motor.__init__) r r r r r3 r[ r r r r r )ra r r 6 s
r c
sG e Z d Z d Z d Z d Z d d d d d d d
d d d
d d d g
Z d e d f d d Z e d d Z e d d Z
e
j d d Z
e d d Z e d d Z
e d d Z e d d! Z e j d" d! Z e d# d$ Z e j d% d$ Z e d& d' Z e j d( d' Z e d) d* Z e j d+ d* Z e d, d- Z e d. d/ Z e j d0 d/ Z e d1 d2 Z e d3 d4 Z e j d5 d4 Z d6 Z d7 Z d8 Z d9 Z d: Z d; Z d< Z d= Z d> d? Z d@ dA Z dB dC Z! dD dE Z" S)FDcMotorz
The DC motor class provides a uniform interface for using regular DC motors
with no fancy controls or feedback. This includes LEGO MINDSTORMS RCX motors
and LEGO Power Functions motors.
zdc-motorzmotor*r5 r6 r7 r: r; r< r> rH rG rL rM rN rO NFc s | d k r | | d <t t | j | j | | | d | _ d | _ d | _ d | _ d | _ d | _ d | _
d | _ d | _ d | _
d | _ d | _ d | _ d S)NrX )rZ r r r[ r5 r6 r7 r: r; r< r> rH rG rL rM rN rO )r rX r^ r_ r` )ra r r r a s
" zDcMotor.__init__c C s" | j | j d \ | _ } | S)zO
Returns the name of the port that this motor is connected to.
rX )rb r5 )r rc r r r rX u s zDcMotor.addressc C s t d d S)z
Sets the command for the motor. Possible values are `run-forever`, `run-timed` and
`stop`. Not all commands may be supported, so be sure to check the contents
of the `commands` attribute.
z!command is a write-only property!N)rd )r r r r re } s zDcMotor.commandc C s | j | j d | | _ d S)Nre )rf r6 )r rc r r r re s c C s" | j | j d \ | _ } | S)zW
Returns a list of commands supported by the motor
controller.
rg )rh r7 )r rc r r r rg s zDcMotor.commandsc C s" | j | j d \ | _ } | S)z
Returns the name of the motor driver that loaded this device. See the list
of [supported devices] for a list of drivers.
rk )rb r: )r rc r r r rk s zDcMotor.driver_namec C s" | j | j d \ | _ } | S)z
Shows the current duty cycle of the PWM signal sent to the motor. Values
are -100 to 100 (-100% to 100%).
rl )ri r; )r rc r r r rl s zDcMotor.duty_cyclec C s" | j | j d \ | _ } | S)z
Writing sets the duty cycle setpoint of the PWM signal sent to the motor.
Valid values are -100 to 100 (-100% to 100%). Reading returns the current
setpoint.
rm )ri r< )r rc r r r rm s zDcMotor.duty_cycle_spc C s | j | j d | | _ d S)Nrm )rn r< )r rc r r r rm s c C s" | j | j d \ | _ } | S)z[
Sets the polarity of the motor. Valid values are `normal` and `inversed`.
rp )rb r> )r rc r r r rp s zDcMotor.polarityc C s | j | j d | | _ d S)Nrp )rf r> )r rc r r r rp s c C s" | j | j d \ | _ } | S)z
Sets the time in milliseconds that it take the motor to ramp down from 100%
to 0%. Valid values are 0 to 10000 (10 seconds). Default is 0.
ry )ri rH )r rc r r r ry s zDcMotor.ramp_down_spc C s | j | j d | | _ d S)Nry )rn rH )r rc r r r ry s c C s" | j | j d \ | _ } | S)z
Sets the time in milliseconds that it take the motor to up ramp from 0% to
100%. Valid values are 0 to 10000 (10 seconds). Default is 0.
rx )ri rG )r rc r r r rx s zDcMotor.ramp_up_spc C s | j | j d | | _ d S)Nrx )rn rG )r rc r r r rx s c C s" | j | j d \ | _ } | S)a
Gets a list of flags indicating the motor status. Possible
flags are `running` and `ramping`. `running` indicates that the motor is
powered. `ramping` indicates that the motor has not yet reached the
`duty_cycle_sp`.
r} )rh rL )r rc r r r r} s z
DcMotor.statec C s t d d S)z
Sets the stop action that will be used when the motor stops. Read
`stop_actions` to get the list of valid values.
z%stop_action is a write-only property!N)rd )r r r r r~ s zDcMotor.stop_actionc C s | j | j d | | _ d S)Nr~ )rf rM )r rc r r r r~ s c C s" | j | j d \ | _ } | S)z\
Gets a list of stop actions. Valid values are `coast`
and `brake`.
r )rh rN )r rc r r r r s zDcMotor.stop_actionsc C s" | j | j d \ | _ } | S)z
Writing specifies the amount of time the motor will run when using the
`run-timed` command. Reading returns the current value. Units are in
milliseconds.
r )ri rO )r rc r r r r s zDcMotor.time_spc C s | j | j d | | _ d S)Nr )rn rO )r rc r r r r s z run-foreverz run-timedz
run-directrQ rS rT rV rW c K s5 x" | D] } t | | | | q W| j | _ d S)z5Run the motor until another command is sent.
N)r r re )r r` r r r r r ( s
zDcMotor.run_foreverc K s5 x" | D] } t | | | | q W| j | _ d S)zRun the motor for the amount of time specified in `time_sp`
and then stop the motor using the action specified by `stop_action`.
N)r r re )r r` r r r r r / s
zDcMotor.run_timedc K s5 x" | D] } t | | | | q W| j | _ d S)zRun the motor at the duty cycle specified by `duty_cycle_sp`.
Unlike other run commands, changing `duty_cycle_sp` while running *will*
take effect immediately.
N)r r re )r r` r r r r r 7 s
zDcMotor.run_directc K s5 x" | D] } t | | | | q W| j | _ d S)zsStop any of the run commands before they are complete using the
action specified by `stop_action`.
N)r r re )r r` r r r r rQ @ s
z DcMotor.stop)#r r r r r[ r r r r rX re r rg rk rl rm rp ry rx r} r~ r r r r r r r r r r r r r rQ r r )ra r r G sb
r c
s e Z d Z d Z d Z d Z d d d d d d d
d d d
g
Z d e d f d d Z e d d Z e d d Z
e
j d d Z
e d d Z e d d Z
e
j d d Z
e d d Z e j d d Z e d d Z e j d! d Z e d" d# Z e j d$ d# Z e d% d& Z e j d' d& Z e d( d) Z e j d* d) Z e d+ d, Z d- Z d. Z d/ Z d0 Z d1 d2 Z d3 d4 Z S)5
ServoMotorzc
The servo motor class provides a uniform interface for using hobby type
servo motors.
z servo-motorzmotor*r5 r6 r:
_max_pulse_sp
_mid_pulse_sp
_min_pulse_spr> rC _rate_sprL NFc s | d k r | | d <t t | j | j | | | d | _ d | _ d | _ d | _ d | _ d | _ d | _
d | _ d | _ d | _
d S)NrX )rZ r r r[ r5 r6 r: r r r r> rC r rL )r rX r^ r_ r` )ra r r r _ s
" zServoMotor.__init__c C s" | j | j d \ | _ } | S)zO
Returns the name of the port that this motor is connected to.
rX )rb r5 )r rc r r r rX p s zServoMotor.addressc C s t d d S)a
Sets the command for the servo. Valid values are `run` and `float`. Setting
to `run` will cause the servo to be driven to the position_sp set in the
`position_sp` attribute. Setting to `float` will remove power from the motor.
z!command is a write-only property!N)rd )r r r r re x s zServoMotor.commandc C s | j | j d | | _ d S)Nre )rf r6 )r rc r r r re s c C s" | j | j d \ | _ } | S)z
Returns the name of the motor driver that loaded this device. See the list
of [supported devices] for a list of drivers.
rk )rb r: )r rc r r r rk s zServoMotor.driver_namec C s" | j | j d \ | _ } | S)a9
Used to set the pulse size in milliseconds for the signal that tells the
servo to drive to the maximum (clockwise) position_sp. Default value is 2400.
Valid values are 2300 to 2700. You must write to the position_sp attribute for
changes to this attribute to take effect.
max_pulse_sp)ri r )r rc r r r r s zServoMotor.max_pulse_spc C s | j | j d | | _ d S)Nr )rn r )r rc r r r r s c C s" | j | j d \ | _ } | S)a
Used to set the pulse size in milliseconds for the signal that tells the
servo to drive to the mid position_sp. Default value is 1500. Valid
values are 1300 to 1700. For example, on a 180 degree servo, this would be
90 degrees. On continuous rotation servo, this is the 'neutral' position_sp
where the motor does not turn. You must write to the position_sp attribute for
changes to this attribute to take effect.
mid_pulse_sp)ri r )r rc r r r r s
zServoMotor.mid_pulse_spc C s | j | j d | | _ d S)Nr )rn r )r rc r r r r s c C s" | j | j d \ | _ } | S)a?
Used to set the pulse size in milliseconds for the signal that tells the
servo to drive to the miniumum (counter-clockwise) position_sp. Default value
is 600. Valid values are 300 to 700. You must write to the position_sp
attribute for changes to this attribute to take effect.
min_pulse_sp)ri r )r rc r r r r s zServoMotor.min_pulse_spc C s | j | j d | | _ d S)Nr )rn r )r rc r r r r s c C s" | j | j d \ | _ } | S)a
Sets the polarity of the servo. Valid values are `normal` and `inversed`.
Setting the value to `inversed` will cause the position_sp value to be
inversed. i.e `-100` will correspond to `max_pulse_sp`, and `100` will
correspond to `min_pulse_sp`.
rp )rb r> )r rc r r r rp s zServoMotor.polarityc C s | j | j d | | _ d S)Nrp )rf r> )r rc r r r rp s c C s" | j | j d \ | _ } | S)aX
Reading returns the current position_sp of the servo. Writing instructs the
servo to move to the specified position_sp. Units are percent. Valid values
are -100 to 100 (-100% to 100%) where `-100` corresponds to `min_pulse_sp`,
`0` corresponds to `mid_pulse_sp` and `100` corresponds to `max_pulse_sp`.
ru )ri rC )r rc r r r ru s zServoMotor.position_spc C s | j | j d | | _ d S)Nru )rn rC )r rc r r r ru s c C s" | j | j d \ | _ } | S)a
Sets the rate_sp at which the servo travels from 0 to 100.0% (half of the full
range of the servo). Units are in milliseconds. Example: Setting the rate_sp
to 1000 means that it will take a 180 degree servo 2 second to move from 0
to 180 degrees. Note: Some servo controllers may not support this in which
case reading and writing will fail with `-EOPNOTSUPP`. In continuous rotation
servos, this value will affect the rate_sp at which the speed ramps up or down.
rate_sp)ri r )r rc r r r r s
zServoMotor.rate_spc C s | j | j d | | _ d S)Nr )rn r )r rc r r r r s c C s" | j | j d \ | _ } | S)z
Returns a list of flags indicating the state of the servo.
Possible values are:
* `running`: Indicates that the motor is powered.
r} )rh rL )r rc r r r r} s zServoMotor.staterunr\ rS rT c K s5 x" | D] } t | | | | q W| j | _ d S)zHDrive servo to the position set in the `position_sp` attribute.
N)r COMMAND_RUNre )r r` r r r r r s
zServoMotor.runc K s5 x" | D] } t | | | | q W| j | _ d S)z%Remove power from the motor.
N)r
COMMAND_FLOATre )r r` r r r r r\ s
zServoMotor.float)r r r r r[ r r r r rX re r rk r r r rp ru r r} r r r r r r\ r r )ra r r I sJ
r c @ sf e Z d Z d d d Z d d Z d d Z d d d Z d
d Z d d
Z d d Z d d Z
d d Z d d Z d d d Z
d d d Z d d Z e d d d Z e d d d Z e d d d! Z e d d" d# Z e d$ d% Z d d d& d' Z d d d( d) Z d d d* d+ Z d d d, d- Z d S).MotorSetNc C sP i | _ x7 t | j D]# } | | } | | | j | <q W| | _ d S)z
motor_specs is a dictionary such as
{
OUTPUT_A : LargeMotor,
OUTPUT_C : LargeMotor,
}
N)motorssortedkeysdesc)r motor_specsr Z
motor_port motor_classr r r r s
zMotorSet.__init__c C s | j r | j S| j j Sd S)N)r ra r )r r r r r $ s zMotorSet.__str__c K s | j d | j j } xq | D]i } x` | D]X } | d k r/ y t | | | | Wq/ t k
r } z | WYd d } ~ Xq/ Xq/ Wq" Wd S)Nr )getr valuesr AttributeError)r r` r r" r er r r set_args+ s
zMotorSet.set_argsc C s| t j t j f } | | k s= t d | d j | f | d k rO | n | j j } x | D] } | | _ qe Wd S)Nz,%s is an invalid polarity choice, must be %sz, )r r r r joinr r rp )r rp r Z
valid_choicesr" r r r set_polarity7 s !
zMotorSet.set_polarityc K s | j d | j j } x? | D]7 } x. | D]& } | d k r/ t | | | | q/ Wq" Wx | D] } | d | _ qd Wd S)Nr rg re )r rg )r r r r re )r r` r r" r r r r _run_commandA s
zMotorSet._run_commandc K s t j | d <| j | d S)Nre )r r r )r r` r r r r N s
zMotorSet.run_foreverc K s t j | d <| j | d S)Nre )r r r )r r` r r r r R s
zMotorSet.run_to_abs_posc K s t j | d <| j | d S)Nre )r r r )r r` r r r r V s
zMotorSet.run_to_rel_posc K s t j | d <| j | d S)Nre )r r r )r r` r r r r Z s
zMotorSet.run_timedc K s t j | d <| j | d S)Nre )r r r )r r` r r r r ^ s
zMotorSet.run_directc C s@ | d k r | n | j j } x | D] } | j q( Wd S)N)r r rR )r r r" r r r rR b s !
zMotorSet.resetc C s@ | d k r | n | j j } x | D] } | j q( Wd S)N)r r rQ )r r r" r r r rQ h s !
z
MotorSet.stopc C sI | d k r | n | j j } x! | D] } | | j k r( d Sq( Wd S)NFT)r r r} )r r r} r" r r r _is_staten s
!
zMotorSet._is_statec C s | j | t j S)N)r r r )r r r r r r w s zMotorSet.is_runningc C s | j | t j S)N)r r r )r r r r r r { s zMotorSet.is_rampingc C s | j | t j S)N)r r r )r r r r r r s zMotorSet.is_holdingc C s | j | t j S)N)r r r )r r r r r r s zMotorSet.is_overloadedc C s | j t t j S)N)r r r r )r r r r r s zMotorSet.is_stalledc C sF | d k r | n | j j } x | D] } | j | | q( Wd S)N)r r r )r r r r r" r r r r s !
z
MotorSet.waitc C sC | d k r | n | j j } x | D] } | j | q( Wd S)N)r r r )r r r r" r r r r s !
z MotorSet.wait_until_not_movingc C sF | d k r | n | j j } x | D] } | j | | q( Wd S)N)r r r )r r r r r" r r r r s !
zMotorSet.wait_untilc C sF | d k r | n | j j } x | D] } | j | | q( Wd S)N)r r r )r r r r r" r r r r s !
zMotorSet.wait_while)r r r r r r r r r r r r r rR rQ r r r r r r r r r r r r r r r r s4
r c @ s e Z d Z d Z d e d d Z d d Z d d Z d d d
d Z d d d d
Z d d d d Z
d d Z d d d Z d S)MoveTanka'
Controls a pair of motors simultaneously, via individual speed setpoints for each motor.
Example:
.. code:: python
tank_drive = MoveTank(OUTPUT_A, OUTPUT_B)
# drive in a turn for 10 rotations of the outer motor
tank_drive.on_for_rotations(50, 75, 10)
Nc C sX | | | | i } t j | | | | j | | _ | j | | _ | j j | _ d S)N)r r r
left_motor right_motorr! )r Zleft_motor_portZright_motor_portr r r r r r r s zMoveTank.__init__c C sJ | j j d d t | j j d d t | j j | j j d S)NrU r )r r r r r )r r r r _block s
zMoveTank._blockc C s4 | j j | d } | j j | d } | | f S)N
left_speed right_speed)r r r )r r r r r r _unpack_speeds_to_native_units s z'MoveTank._unpack_speeds_to_native_unitsTc C s$ t j | | | | d | | d S)a
Rotate the motors at 'left_speed & right_speed' for 'rotations'. Speeds
can be percentages or any SpeedValue implementation.
If the left speed is not equal to the right speed (i.e., the robot will
turn), the motor on the outside of the turn will rotate for the full
``rotations`` while the motor on the inside will have its requested
distance calculated according to the expected turn.
ih N)r r )r r r r rW r r r r r s
zMoveTank.on_for_rotationsc
C s | j | | \ } } | d k s< | d k rK | d k rK | } | } nO t | t | k r | } t | | | } n t | | | } | } | j j | | | j j | | j j | | | j j | | j j | j j | r
| j d S)a
Rotate the motors at 'left_speed & right_speed' for 'degrees'. Speeds
can be percentages or any SpeedValue implementation.
If the left speed is not equal to the right speed (i.e., the robot will
turn), the motor on the outside of the turn will rotate for the full
``degrees`` while the motor on the inside will have its requested
distance calculated according to the expected turn.
r N)r r( r r r r r r )
r r r r rW r left_speed_native_unitsright_speed_native_unitsZ left_degreesZ
right_degreesr r r r s"
$
zMoveTank.on_for_degreesc C s | j | | \ } } t t | | j _ t | d | j _ | j j | t t | | j _ t | d | j _ | j j | | j j | j j | r | j d S)z
Rotate the motors at 'left_speed & right_speed' for 'seconds'. Speeds
can be percentages or any SpeedValue implementation.
i N)
r r r r rw r r r r r )r r r r rW r r r r r r r s
zMoveTank.on_for_secondsc C sf | j | | \ } } t t | | j _ t t | | j _ | j j | j j d S)z
Start rotating the motors according to ``left_speed`` and ``right_speed`` forever.
Speeds can be percentages or any SpeedValue implementation.
N)r r r r rw r r )r r r r r r r r r s
z MoveTank.onc C s> | j j | | j j | | j j | j j d S)zd
Stop both motors immediately. Configure both to brake if ``brake`` is
set.
N)r r r rQ )r rW r r r r # s
z MoveTank.off)
r r r r r r r r r r r r r r r r r r s ( r c @ sd e Z d Z d Z d d d d Z d d d d Z d d d d Z d d
Z d d Z d
S) MoveSteeringa
Controls a pair of motors simultaneously, via a single "steering" value.
steering [-100, 100]:
* -100 means turn left on the spot (right motor at 100% forward, left motor at 100% backward),
* 0 means drive in a straight line, and
* 100 means turn right on the spot (left motor at 100% forward, right motor at 100% backward).
"steering" can be any number between -100 and 100.
Example:
.. code:: python
steering_drive = MoveSteering(OUTPUT_A, OUTPUT_B)
# drive in a turn for 10 rotations of the outer motor
steering_drive.on_for_rotations(-20, SpeedPercent(75), 10)
Tc C sD | j | | \ } } t j | t | t | | | | d S)z
Rotate the motors according to the provided ``steering``.
The distance each motor will travel follows the rules of :meth:`MoveTank.on_for_rotations`.
N)get_speed_steeringr r r$ )r steeringrv r rW r r r r r r r A s z MoveSteering.on_for_rotationsc C sD | j | | \ } } t j | t | t | | | | d S)z
Rotate the motors according to the provided ``steering``.
The distance each motor will travel follows the rules of :meth:`MoveTank.on_for_degrees`.
N)r r r r$ )r r rv r rW r r r r r r r J s zMoveSteering.on_for_degreesc C sD | j | | \ } } t j | t | t | | | | d S)z[
Rotate the motors according to the provided ``steering`` for ``seconds``.
N)r r r r$ )r r rv r rW r r r r r r r S s zMoveSteering.on_for_secondsc C s; | j | | \ } } t j | t | t | d S)z[
Start rotating the motors according to the provided ``steering`` forever.
N)r r r r$ )r r rv r r r r r r Z s zMoveSteering.onc C s | d k r | d k s- t d j | | j j | } | } | } d t t | d } | d k r~ | | 9} n
| | 9} | | f S)a
Calculate the speed_sp for each motor in a pair to achieve the specified
steering. Note that calling this function alone will not make the
motors move, it only calculates the speed. A run_* function must be called
afterwards to make the motors move.
steering [-100, 100]:
* -100 means turn left on the spot (right motor at 100% forward, left motor at 100% backward),
* 0 means drive in a straight line, and
* 100 means turn right on the spot (left motor at 100% forward, right motor at 100% backward).
speed:
The speed that should be applied to the outmost motor (the one
rotating faster). The speed of the other motor will be computed
automatically.
r zC{} is an invalid steering, must be between -100 and 100 (inclusive)2 r i)r r r r r( r\ )r r rv r r Z speed_factorr r r r a s
z MoveSteering.get_speed_steeringN) r r r r r r r r r r r r r r . s r c @ s: e Z d Z d Z d d d d Z e d d Z d S) MoveJoystickzH
Used to control a pair of motors via a single joystick vector.
g Y@c C s | r | r t j d St | | | | } t t | | } | d k r_ | d 7} | | k rq | } t j | \ } } | | | } | | | }
t j | t | d | j j
| t |
d | j j
| d S)a
Convert x,y joystick coordinates to left/right motor speed percentages
and move the motors.
This will use a classic "arcade drive" algorithm: a full-forward joystick
goes straight forward and likewise for full-backward. Pushing the joystick
all the way to one side will make it turn on the spot in that direction.
Positions in the middle will control how fast the vehicle moves and how
sharply it turns.
"x", "y":
The X and Y coordinates of the joystick's position, with
(0,0) representing the center position. X is horizontal and Y is vertical.
max_speed (default 100%):
A percentage or other SpeedValue, controlling the maximum motor speed.
radius (default 100):
The radius of the joystick, controlling the range of the input (x, y) values.
e.g. if "x" and "y" can be between -1 and 1, radius should be set to "1".
Nr ih r ) r r r math_degreesr r angle_to_speed_percentager r$ r r r ) r xyr! ZradiusZ
vector_lengthangleZinit_left_speed_percentageZinit_right_speed_percentageleft_speed_percentageright_speed_percentager r r r s
zMoveJoystick.onc C s d | k o d k n r3 d } d | d } ndd | k oJ d k n rl d } | d d } | } n+d | k o d k n r | d d } d | } d } nd | k o d k n r | d d } d | } d } nd | k o d k n rq| d d } d | } | d k rA| d d
} d | } q| d k rVd } q| d d
} d | } n&d | k od k n r| d d } d | } d } n d | k od k n rd } | d d }
d |
} n d | k od
k n r| d k r2| d d
} d | d } n5 | d k rGd } n | d k rg| d d
} | } | d d }
d |
} n t d j | | d | d f S)a
The following graphic illustrates the **motor power outputs** for the
left and right motors based on where the joystick is pointing, of the
form ``(left power, right power)``::
(1, 1)
. . . . . . .
. | .
. | .
(0, 1) . | . (1, 0)
. | .
. | .
. | .
. | .
. | .
. | x-axis .
(-1, 1) .---------------------------------------. (1, -1)
. | .
. | .
. | .
. | y-axis .
. | .
(0, -1) . | . (-1, 0)
. | .
. | .
. . . . . . .
(-1, -1)
The joystick is a circle within a circle where the (x, y) coordinates
of the joystick form an angle with the x-axis. Our job is to translate
this angle into the percentage of power that should be sent to each motor.
For instance if the joystick is moved all the way to the top of the circle
we want both motors to move forward with 100% power...that is represented
above by (1, 1). If the joystick is moved all the way to the right side of
the circle we want to rotate clockwise so we move the left motor forward 100%
and the right motor backwards 100%...so (1, -1). If the joystick is at
45 degrees then we move apply (1, 0) to move the left motor forward 100% and
the right motor stays still.
The 8 points shown above are pretty easy. For the points in between those 8
we do some math to figure out what the percentages should be. Take 11.25 degrees
for example. We look at how the motors transition from 0 degrees to 45 degrees:
- the left motor is 1 so that is easy
- the right motor moves from -1 to 0
We determine how far we are between 0 and 45 degrees (11.25 is 25% of 45) so we
know that the right motor should be 25% of the way from -1 to 0...so -0.75 is the
percentage for the right motor at 11.25 degrees.
r - g F@Z g Pi@g 6@i i; ih g u@zNYou created a circle with more than 360 degrees ({})...that is quite the trickr r r r r r r r r r )rd r )r r r Zpercentage_from_45_to_90Zpercentage_from_90_to_135Zpercentage_from_135_to_180Zpercentage_from_180_to_225Zpercentage_from_180_to_202Zpercentage_from_202_to_225Zpercentage_from_225_to_270Zpercentage_from_270_to_315Zpercentage_from_315_to_337Zpercentage_from_337_to_360Zpercentage_from_315_to_360r r r r s\ 5
z&MoveJoystick.angle_to_speed_percentageN)r r r r r staticmethodr r r r r r s =r )6sys version_info SystemErrorr r Zloggingr Zmathr r r r os.pathr Zev3dev2r r
r r r r platformZev3dev2._platform.ev3r
r r r Zev3dev2._platform.evbZev3dev2._platform.pistormsZev3dev2._platform.brickpiZev3dev2._platform.brickpi3Zev3dev2._platform.fakerd r r r$ r& r* r- r0 r3 r r r r r r r r objectr r r r r r r r <module> s^ % % % % % % 3 X