class MotorSpeed(Configurable):
l_value = traitlets.Float()
r_value = traitlets.Float()
def __init__(self, astar, *args, **kwargs):
super(MotorSpeed, self).__init__(*args, **kwargs) # initializes traitlets
self._astar = astar
atexit.register(self._release)
@traitlets.observe('l_value')
def _observe_value_left(self, change):
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
logger = logging.getLogger()
logging.info("Updating l_value: " + str(change['new']) + " using existing r_value: " + str(self.r_value))
self._write_value(change['new'], self.r_value)
@traitlets.observe('r_value')
def _observe_value_right(self, change):
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
logger = logging.getLogger()
logging.info("Updating r_value: " + str(change['new']) + " using existing l_value: " + str(self.l_value))
self._write_value(self.l_value, change['new'])
def _write_value(self, left_speed, right_speed):
self._astar.motors(int(min(left_speed, 1) * 400), int(min(right_speed, 1) * 400))
def _release(self):
"""Stops motor by releasing control"""
self._write_value(0, 0)
class Motor(Configurable):
value = traitlets.Float()
# config
alpha = traitlets.Float(default_value=1.0).tag(config=True)
beta = traitlets.Float(default_value=0.0).tag(config=True)
def __init__(self, driver, channel, *args, **kwargs):
super(Motor, self).__init__(*args, **kwargs) # initializes traitlets
self._driver = driver
atexit.register(self._release)
self.channel = channel
@traitlets.observe('value')
def _observe_value(self, change):
self._write_value(change['new'])
def _write_value(self, value):
"""Sets motor value between [-1, 1]"""
speed = int(255 * (self.alpha * value + self.beta))
# Set Motor Controls: .set_drive( motor number, direction, speed)
# Motor Number: A = 0, B = 1
# Direction: FWD = 0, BACK = 1
# Speed: (-255) - 255 (neg. values reverse direction of motor)
self._motor = self._driver.set_drive(self.channel, 0, speed)
self._driver.enable()
def _release(self):
"""Stops motor by releasing control"""
self._motor.disable()
class Motor(Configurable):
value = traitlets.Float()
# config
alpha = traitlets.Float(default_value=1.0).tag(config=True)
beta = traitlets.Float(default_value=0.0).tag(config=True)
def __init__(self, driver, channel, *args, **kwargs):
super(Motor, self).__init__(*args, **kwargs) # initializes traitlets
self._driver = driver
self._channel = channel
atexit.register(self._release)
@traitlets.observe('value')
def _observe_value(self, change):
self._write_value(change['new'])
def _write_value(self, value):
# value: -1 ~ +1
speed = int(100.0 * (self.alpha * value + self.beta))
self._driver.move(self._channel, speed)
def _release(self):
self._driver.reset()
class Racecar(traitlets.HasTraits):
steering = traitlets.Float()
throttle = traitlets.Float()
direction = traitlets.Int()
@traitlets.default('direction')
def _default_direction(self):
return 1
@traitlets.validate('steering')
def _clip_steering(self, proposal):
if proposal['value'] > 1.0:
return 1.0
elif proposal['value'] < -1.0:
return -1.0
else:
return proposal['value']
@traitlets.validate('throttle')
def _clip_throttle(self, proposal):
if proposal['value'] > 1.0:
return 1.0
elif proposal['value'] < -1.0:
return -1.0
else:
return proposal['value']
@traitlets.validate('direction')
def _clip_direction(self, proposal):
if proposal['value'] > 0:
return 1
elif proposal['value'] < 0:
return -1
else:
return 0
class Scatter(widgets.DOMWidget):
_view_name = Unicode('ScatterView').tag(sync=True)
_view_module = Unicode('ipyvolume').tag(sync=True)
_model_name = Unicode('ScatterModel').tag(sync=True)
_model_module = Unicode('ipyvolume').tag(sync=True)
x = Array(default_value=None).tag(sync=True, **create_array_binary_serialization('x'))
y = Array(default_value=None).tag(sync=True, **create_array_binary_serialization('y'))
z = Array(default_value=None).tag(sync=True, **create_array_binary_serialization('z'))
vx = Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('vx'))
vy = Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('vy'))
vz = Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('vz'))
selected = Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('selection', update_from_js=True))
sequence_index = Integer(default_value=0).tag(sync=True)
size = traitlets.Union([traitlets.Float().tag(sync=True),
Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('size'))],
default_value=5).tag(sync=True)
size_selected = traitlets.Union([traitlets.Float().tag(sync=True),
Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('size_selected'))],
default_value=7).tag(sync=True)
color = traitlets.Union([Unicode().tag(sync=True),
Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('color'))],
default_value="red").tag(sync=True)
color_selected = traitlets.Union([Unicode().tag(sync=True),
Array(default_value=None,allow_none=True).tag(sync=True, **create_array_binary_serialization('color_selected'))],
default_value="green").tag(sync=True)
geo = traitlets.Unicode('diamond').tag(sync=True)
class ColorMaps(ipywidgets.Widget):
"""Colormapping widget used to collect available colormaps """
_model_name = traitlets.Unicode('CMapModel').tag(sync=True)
_model_module = traitlets.Unicode('@data-exp-lab/yt-widgets').tag(sync=True)
_model_module_version = traitlets.Unicode(EXTENSION_VERSION).tag(sync=True)
cmaps = traitlets.Dict({}).tag(sync=True, config=True)
map_name = traitlets.Unicode('autumn').tag(sync=True, config=True)
is_log = traitlets.Bool(False).tag(sync=True, config=True)
min_val = traitlets.Float().tag(sync=True, config=True)
max_val = traitlets.Float().tag(sync=True, config=True)
generation = traitlets.Int(0).tag(sync=True, config=True)
def __init__(self, *args, **kwargs):
self.cmaps = self.get_mpl_cmaps()
super(ColorMaps, self).__init__()
def get_mpl_cmaps(self):
""" Adds available colormaps from matplotlib."""
colormaps = {}
import matplotlib.cm as mplcm
cmap_list = mplcm.cmap_d.keys()
for colormap in cmap_list:
cmap = mplcm.get_cmap(colormap)
vals = (cmap(np.mgrid[0.0:1.0:256j])*255).astype("uint8")
# right now let's just flatten the arrays. Later we can
# serialize each cmap on its own.
table = vals.flatten().tolist()
colormaps[colormap] = table
return colormaps
class SpaceDim(tr.HasTraits):
minval = tr.Float()
maxval = tr.Float()
num = tr.Int()
vals = tr.Any()
def __init__(self, minval, maxval, num):
super().__init__()
self.minval = minval
self.maxval = maxval
self.num = num
self.init_logic()
self.update()
# Deal only with num for simplicity
def spacing_from_num(self):
self.spacing = (self.maxval - self.minval) / self.num
def assign_linspace(self):
self.vals = np.arange(self.minval, self.maxval, self.spacing)
def update(self, *args):
self.spacing_from_num()
self.assign_linspace()
def init_logic(self):
self.observe(self.update, names=['minval', 'maxval', 'num'])
class AngleDim(tr.HasTraits):
num = tr.Int()
minval = tr.Float()
maxval = tr.Float()
vals = tr.Any()
def __init__(self, minval, maxval, num):
super().__init__()
self.minval = minval
self.maxval = maxval
self.num = num
self.update()
self.init_logic()
def assign_legendre(self):
self.vals = self.affine_transform(vals=leggauss(self.num)[0],
oldmin=-1,
oldmax=1,
newmin=self.minval,
newmax=self.maxval)
#def angular_integral(self):
# pass
def affine_transform(self, vals, oldmin, oldmax, newmin, newmax):
return newmin + (newmin - newmax) / (oldmin - oldmax) * (vals - oldmin)
def update(self, *args):
self.assign_legendre()
def init_logic(self):
self.observe(self.update, names='num')
class Motor(Configurable):
value = traitlets.Float()
# config
alpha = traitlets.Float(default_value=1.0).tag(config=True)
beta = traitlets.Float(default_value=0.0).tag(config=True)
def __init__(self, driver, channel, *args, **kwargs):
super(Motor, self).__init__(*args, **kwargs) # initializes traitlets
self._driver = driver
self._motor = self._driver.getMotor(channel)
atexit.register(self._release)
@traitlets.observe('value')
def _observe_value(self, change):
self._write_value(change['new'])
def _write_value(self, value):
"""Sets motor value between [-1, 1]"""
# ジョイスティック等の値ブレ対策
if abs(value) <= 0.05:
value = 0.0
#モータの目標速度(mm/s)に変換。※最高1300mm/s
mapped_value = int(1300.0 * (self.alpha * value + self.beta))
speed = min(max(mapped_value, -1300), 1300)
self._motor.setSpeed(speed)
def _release(self):
"""Stops motor by releasing control"""
self._motor.setSpeed(0)
class NvidiaRacecar(Racecar):
#set offsets for my car
#after changing values, re-run setup.py
i2c_address = traitlets.Integer(default_value=0x40)
steering_gain = traitlets.Float(default_value=1)
steering_offset = traitlets.Float(default_value=0.15)
steering_channel = traitlets.Integer(default_value=0)
throttle_gain = traitlets.Float(default_value=1)
throttle_channel = traitlets.Integer(default_value=1)
throttle_offset = traitlets.Float(default_value=0.13)
def __init__(self, *args, **kwargs):
super(NvidiaRacecar, self).__init__(*args, **kwargs)
self.kit = ServoKit(channels=16, address=self.i2c_address)
self.steering_motor = self.kit.continuous_servo[self.steering_channel]
self.throttle_motor = self.kit.continuous_servo[self.throttle_channel]
self.steering_motor.throttle = self.steering_offset
self.throttle_motor.throttle = self.throttle_offset
@traitlets.observe('steering')
def _on_steering(self, change):
self.steering_motor.throttle = change[
'new'] * self.steering_gain + self.steering_offset
@traitlets.observe('throttle')
def _on_throttle(self, change):
self.throttle_motor.throttle = change[
'new'] * self.throttle_gain + self.throttle_offset
class TimeCode(ipywidgets.HTML):
"""Nicely-formatted timecode text display
"""
_view_name = traitlets.Unicode('TimeCodeView').tag(sync=True)
_view_module = traitlets.Unicode(__npm_module_name__).tag(sync=True)
_view_module_version = traitlets.Unicode('^' + __npm_module_version__).tag(sync=True)
_model_name = traitlets.Unicode('TimeCodeModel').tag(sync=True)
_model_module = traitlets.Unicode(__npm_module_name__).tag(sync=True)
_model_module_version = traitlets.Unicode('^' + __npm_module_version__).tag(sync=True)
# Public information
timecode = traitlets.Float().tag(sync=True)
timebase = traitlets.Float().tag(sync=True)
def __init__(self, timebase=1/30):
"""Create new widget instance
"""
super().__init__()
self.timebase = timebase
self.layout.border = '1px solid grey'
self.layout.justify_content = 'center'
self.layout.align_items = 'center'
self.layout.align_self = 'center'
self.layout.width = 'fit-content'
class Motor(Configurable):
value = traitlets.Float()
# config
alpha = traitlets.Float(default_value=1.0).tag(config=True)
beta = traitlets.Float(default_value=0.0).tag(config=True)
def __init__(self, driver, channel, *args, **kwargs):
super(Motor, self).__init__(*args, **kwargs) # initializes traitlets
self._motor = "J" + str(channel)
atexit.register(self._release)
@traitlets.observe('value')
def _observe_value(self, change):
self._write_value(change['new'])
def _write_value(self, value):
"""Sets motor value between [-3, 3] rad/s"""
mapped_value = float(3 * (self.alpha * value + self.beta))
subprocess.call(["motor_util", "-n", self._motor, "set", "--mode", "4", "--velocity", str(mapped_value)])
def _release(self):
"""Stops motor by releasing control"""
subprocess.call(["motor_util", "-n", self._motor, "set", "--mode", "0"])
class Motor(Configurable):
value = traitlets.Float()
# config
alpha = traitlets.Float(default_value=1.0).tag(config=True)
beta = traitlets.Float(default_value=0.0).tag(config=True)
def __init__(self, driver, channel, *args, **kwargs):
super(Motor, self).__init__(*args, **kwargs) # initializes traitlets
self._driver = driver
self._motor = self._driver.getMotor(channel)
atexit.register(self._release)
@traitlets.observe('value')
def _observe_value(self, change):
self._write_value(change['new'])
def _write_value(self, value):
"""Sets motor value between [-1, 1]"""
mapped_value = int(255.0 * (self.alpha * value + self.beta))
speed = min(max(abs(mapped_value), 0), 255)
self._motor.setSpeed(speed)
if mapped_value < 0:
self._motor.run(Adafruit_MotorHAT.FORWARD)
else:
self._motor.run(Adafruit_MotorHAT.BACKWARD)
def _release(self):
"""Stops motor by releasing control"""
self._motor.run(Adafruit_MotorHAT.RELEASE)
class Motor2(Configurable):
value = traitlets.Float()
# config
alpha = traitlets.Float(default_value=1.0).tag(config=True)
beta = traitlets.Float(default_value=0.0).tag(config=True)
def __init__(self, channel, *args, **kwargs):
super(Motor2, self).__init__(*args, **kwargs) # initializes traitlets
self.channel = channel
atexit.register(self._release)
@traitlets.observe('value')
def _observe_value(self, change):
self._write_value(change['new'])
def _write_value(self, value):
"""Sets motor value between [-1, 1]"""
mapped_value = int(255.0 * (self.alpha * value + self.beta))
speed = min(max(abs(mapped_value), 0), 255)
if mapped_value < 0:
mapped_value = 0
else:
mapped_value = 1
if self.channel >= 1 and self.channel <= 2:
bus.write_i2c_block_data(addr, self.channel, [mapped_value, speed])
def _release(self):
"""Stops motor by releasing control"""
if self.channel >= 1 and self.channel <= 2:
bus.write_i2c_block_data(addr, self.channel, [0, 0])
class Motor(Configurable):
value = traitlets.Float()
# config
alpha = traitlets.Float(default_value=1.0).tag(config=True)
beta = traitlets.Float(default_value=0.0).tag(config=True)
def __init__(self, driver, channel, *args, **kwargs):
super(Motor, self).__init__(*args, **kwargs) # initializes traitlets
self._motor = driver
self._channel = channel
atexit.register(self._release)
@traitlets.observe('value')
def _observe_value(self, change):
self._write_value(change['new'])
def _write_value(self, value):
"""Sets motor value between [-1, 1]"""
mapped_value = int(255.0 * (self.alpha * value + self.beta))
if mapped_value < 0: # 306=パルス幅1.5ms(stop),204=パルス幅1.0ms(forward),408=パルス幅2.0ms(backward)
self._motor.set_pwm(self._channel, round(306 - 102 * abs(value)))
else:
self._motor.set_pwm(self._channel, round(306 + 102 * abs(value)))
def _release(self):
"""Stops motor by releasing control"""
self._motor.set_pwm(0, 306)
self._motor.set_pwm(1, 306)
class PerspectiveCamera(Camera):
focal_length = tl.Float(50)
sensor_width = tl.Float(36)
@property
def field_of_view(self):
return 2 * np.arctan(self.sensor_width / 2. / self.focal_length)
class Padding(LayoutOptionWidget):
"""The padding to be left to a parent element’s border when placing child
elements. This can also serve as an output option of a layout algorithm if
node size calculation is setup appropriately.
https://www.eclipse.org/elk/reference/options/org-eclipse-elk-padding.html
"""
identifier = "org.eclipse.elk.padding"
metadata_provider = "core.options.CoreOptions"
applies_to = ["parents", "nodes"]
top = T.Float(min_value=0, default_value=12)
bottom = T.Float(min_value=0, default_value=12)
left = T.Float(min_value=0, default_value=12)
right = T.Float(min_value=0, default_value=12)
_traits = ["top", "bottom", "left", "right"]
def _ui(self) -> List[W.Widget]:
sliders = []
for trait in self._traits:
slider = W.FloatSlider(description=f"{trait.title()} Padding")
T.link((self, trait), (slider, "value"))
sliders.append(slider)
return sliders
@T.observe("top", "bottom", "left", "right")
def _update_value(self, change: T.Bunch = None):
padding = ",".join([f"{t}={getattr(self, t)}" for t in self._traits])
self.value = f"[{padding}]"
class Robot(SingletonConfigurable):
left_motor = traitlets.Instance(Motor)
right_motor = traitlets.Instance(Motor)
brush_motor = traitlets.Instance(Motor) #
# config
i2c_bus = traitlets.Integer(default_value=1).tag(config=True)
left_motor_channel = traitlets.Integer(default_value=1).tag(config=True)
left_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
right_motor_channel = traitlets.Integer(default_value=2).tag(config=True)
right_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
brush_motor_channel = traitlets.Integer(default_value=3).tag(
config=True) #
brush_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True) #
def __init__(self, *args, **kwargs):
super(Robot, self).__init__(*args, **kwargs)
self.motor_driver = Adafruit_MotorHAT(i2c_bus=self.i2c_bus)
self.left_motor = Motor(self.motor_driver,
channel=self.left_motor_channel,
alpha=self.left_motor_alpha)
self.right_motor = Motor(self.motor_driver,
channel=self.right_motor_channel,
alpha=self.right_motor_alpha)
self.brush_motor = Motor(self.motor_driver,
channel=self.brush_motor_channel,
alpha=self.brush_motor_alpha) #
def set_motors(self, left_speed, right_speed):
self.left_motor.value = left_speed
self.right_motor.value = right_speed
def forward(self, speed=1.0, duration=None):
self.left_motor.value = speed
self.right_motor.value = speed
def backward(self, speed=1.0):
self.left_motor.value = -speed
self.right_motor.value = -speed
def left(self, speed=1.0):
self.left_motor.value = -speed
self.right_motor.value = speed
def right(self, speed=1.0):
self.left_motor.value = speed
self.right_motor.value = -speed
def stop(self):
self.left_motor.value = 0
self.right_motor.value = 0
def brush(self, speed=1.0):
self.brush_motor.value = speed
class GeoJsonDataSource(DataSource):
"""
GeoJsonDataSource
Parameters
----------
sourceUri : str
Overrides the url to use for resolving relative links.
describe : GeoJsonDataSource~describe, default GeoJsonDataSource.defaultDescribeProperty
A function which returns a Property object (or just a string), which converts the properties into an html description.
markerSize : int, default GeoJsonDataSource.markerSize
The default size of the map pin created for each point, in pixels.
markerSymbol : str, default GeoJsonDataSource.markerSymbol
The default symbol of the map pin created for each point.
markerColor : Color, default GeoJsonDataSource.markerColor
The default color of the map pin created for each point.
stroke : Color, default GeoJsonDataSource.stroke
The default color of polylines and polygon outlines.
strokeWidth : int, GeoJsonDataSource.strokeWidth
The default width of polylines and polygon outlines.
fill : Color, default GeoJsonDataSource.fill
The default color for polygon interiors.
"""
_props = [
'describe', 'markerSize', 'markerSymbol', 'markerColor', 'stroke',
'strokeWidth', 'fill'
]
markerSize = traitlets.Float(allow_none=True)
markerSymbol = traitlets.Unicode(allow_none=True)
markerColor = MaybeTrait(klass=cesiumpy.color.Color, allow_none=True)
stroke = MaybeTrait(klass=cesiumpy.color.Color, allow_none=True)
strokeWidth = traitlets.Float(allow_none=True)
fill = MaybeTrait(klass=cesiumpy.color.Color, allow_none=True)
def __init__(self,
sourceUri,
describe=None,
markerSize=None,
markerSymbol=None,
markerColor=None,
stroke=None,
strokeWidth=None,
fill=None):
super(GeoJsonDataSource, self).__init__(sourceUri=sourceUri)
self.describe = com.notimplemented(describe)
self.markerSize = markerSize
self.markerSymbol = markerSymbol
self.markerColor = markerColor
self.stroke = stroke
self.strokeWidth = strokeWidth
self.fill = fill
class Robot(SingletonConfigurable):
pwm_driver = traitlets.Instance(PCA9685)
left_motor = traitlets.Instance(Motor)
right_motor = traitlets.Instance(Motor)
# config
left_motor_channel = traitlets.Integer(default_value=0).tag(config=True)
left_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
right_motor_channel = traitlets.Integer(default_value=1).tag(config=True)
right_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
def __init__(self, *args, **kwargs):
super(Robot, self).__init__(*args, **kwargs)
# Create a i2c bus interface, a simple PCA9685 class instance and set the pwn frequency.
# You can optionally provide a finer tuned reference clock speed to improve the accuracy of the
# timing pulses. This calibration will be specific to each board and its environment. See the
# calibration.py example in the PCA9685 driver.
# pca = PCA9685(i2c, reference_clock_speed=25630710)
_i2c = busio.I2C(SCL, SDA)
_pwm_driver = PCA9685(_i2c)
_pwm_driver.frequency = 50
self.left_motor = Motor(_pwm_driver,
channel=self.left_motor_channel,
alpha=self.left_motor_alpha,
beta=0.05)
self.right_motor = Motor(_pwm_driver,
channel=self.right_motor_channel,
alpha=self.right_motor_alpha,
beta=0.05)
def set_motors(self, left_speed, right_speed):
self.left_motor.value = left_speed
self.right_motor.value = right_speed
def forward(self, speed=1.0, duration=None):
self.left_motor.value = speed
self.right_motor.value = -speed
def backward(self, speed=1.0):
self.left_motor.value = -speed
self.right_motor.value = speed
def left(self, speed=1.0):
self.left_motor.value = -speed
self.right_motor.value = -speed
def right(self, speed=1.0):
self.left_motor.value = speed
self.right_motor.value = speed
def stop(self):
self.left_motor.value = 0.0
self.right_motor.value = 0.0
class Frond(tr.HasTraits):
fs = tr.Float()
fr = tr.Float()
ft = tr.Float()
def __init__(self):
super().__init__()
self.fs = .5
self.fr = 2
self.ft = .0015
class TransferFunctionWidgetJs3(TransferFunction):
_model_name = Unicode('TransferFunctionWidgetJs3Model').tag(sync=True)
_model_module = Unicode('ipyvolume').tag(sync=True)
level1 = traitlets.Float(0.1).tag(sync=True)
level2 = traitlets.Float(0.5).tag(sync=True)
level3 = traitlets.Float(0.8).tag(sync=True)
opacity1 = traitlets.Float(0.01).tag(sync=True)
opacity2 = traitlets.Float(0.05).tag(sync=True)
opacity3 = traitlets.Float(0.1).tag(sync=True)
width1 = traitlets.Float(0.1).tag(sync=True)
width2 = traitlets.Float(0.1).tag(sync=True)
width3 = traitlets.Float(0.1).tag(sync=True)
def control(self, max_opacity=0.2):
import ipywidgets
l1 = ipywidgets.FloatSlider(min=0, max=1, step=0.001, value=self.level1)
l2 = ipywidgets.FloatSlider(min=0, max=1, step=0.001, value=self.level2)
l3 = ipywidgets.FloatSlider(min=0, max=1, step=0.001, value=self.level3)
o1 = ipywidgets.FloatSlider(min=0, max=max_opacity, step=0.001, value=self.opacity1)
o2 = ipywidgets.FloatSlider(min=0, max=max_opacity, step=0.001, value=self.opacity2)
o3 = ipywidgets.FloatSlider(min=0, max=max_opacity, step=0.001, value=self.opacity2)
ipywidgets.jslink((self, 'level1'), (l1, 'value'))
ipywidgets.jslink((self, 'level2'), (l2, 'value'))
ipywidgets.jslink((self, 'level3'), (l3, 'value'))
ipywidgets.jslink((self, 'opacity1'), (o1, 'value'))
ipywidgets.jslink((self, 'opacity2'), (o2, 'value'))
ipywidgets.jslink((self, 'opacity3'), (o3, 'value'))
return ipywidgets.VBox(
[ipywidgets.HBox([ipywidgets.Label(value="levels:"), l1, l2, l3]),
ipywidgets.HBox([ipywidgets.Label(value="opacities:"), o1, o2, o3])]
)
class JetbotRacecar(Racecar):
steering_gain = traitlets.Float(default_value=-0.65)
steering_offset = traitlets.Float(default_value=0)
throttle_gain = traitlets.Float(default_value=0.8)
i2c_bus = traitlets.Integer(default_value=1).tag(config=True)
left_motor_channel = traitlets.Integer(default_value=1).tag(config=True)
right_motor_channel = traitlets.Integer(default_value=2).tag(config=True)
def __init__(self, *args, **kwargs):
super(JetbotRacecar, self).__init__(*args, **kwargs)
self.motor_driver = Adafruit_MotorHAT(i2c_bus=self.i2c_bus)
self.left_motor = DcMotor(self.motor_driver,
channel=self.left_motor_channel)
self.right_motor = DcMotor(self.motor_driver,
channel=self.right_motor_channel)
def _move_car(self):
"""Moves car with 2 wheels (left, right)"""
value_y = self.steering * self.steering_gain + self.steering_offset
value_x = self.throttle * self.throttle_gain
# convert steering and throttle to left/right thrust values
theta = np.arctan2(value_y, value_x)
radial_x = abs(value_x) * np.cos(theta)
radial_y = abs(value_y) * np.sin(theta)
radius = np.sqrt(pow(radial_x, 2) + pow(radial_y, 2)) * 100.
theta_radial_degrees = degrees(np.arctan2(radial_y, radial_x))
left_thrust, right_thrust = throttle_angle_to_thrust(
radius, theta_radial_degrees)
# set motors values
self.left_motor.value = float(left_thrust / 100.)
self.right_motor.value = float(right_thrust / 100.)
@traitlets.observe('steering')
def _on_steering(self, change):
self._move_car()
@traitlets.observe('throttle')
def _on_throttle(self, change):
self._move_car()
@traitlets.observe('throttle_gain')
def _on_throttle_gain(self, change):
self._move_car()
@traitlets.observe('steering_gain')
def _on_steering_gain(self, change):
self._move_car()
@traitlets.observe('steering_offset')
def _on_steering_offset(self, change):
self._move_car()
class ImageryProvider(_CesiumProvider):
_props = [
'url', 'fileExtension', 'rectangle', 'tillingScheme', 'ellipsoid',
'tileWidth', 'tileHeight', 'tileDiscardPolicy', 'minimumLevel',
'maximumLevel', 'credit', 'proxy', 'subdomains'
]
url = traitlets.Unicode(allow_none=True)
fileExtension = traitlets.Unicode(allow_none=True)
rectangle = MaybeTrait(klass=cartesian.Rectangle, allow_none=True)
tileWidth = traitlets.Float(allow_none=True)
tileHeight = traitlets.Float(allow_none=True)
minimumLevel = traitlets.Float(allow_none=True)
maximumLevel = traitlets.Float(allow_none=True)
credit = traitlets.Unicode(allow_none=True)
def __init__(self,
url=None,
fileExtension=None,
rectangle=None,
tillingScheme=None,
ellipsoid=None,
tileWidth=None,
tileHeight=None,
tileDiscardPolicy=None,
minimumLevel=None,
maximumLevel=None,
credit=None,
proxy=None,
subdomains=None):
self.url = url
self.fileExtension = fileExtension
self.rectangle = rectangle
self.tillingScheme = com.notimplemented(tillingScheme)
self.ellipsoid = com.notimplemented(ellipsoid)
self.tileWidth = tileWidth
self.tileHeight = tileHeight
self.tileDiscardPolicy = com.notimplemented(tileDiscardPolicy)
self.minimumLevel = minimumLevel
self.maximumLevel = maximumLevel
self.credit = credit
self.proxy = com.notimplemented(proxy)
self.subdomains = com.notimplemented(subdomains)
class KpointSettings(ipw.VBox):
# The default of `kpoints_distance` must be linked to the `protocol`
kpoints_distance_default = traitlets.Float(default_value=0.15)
kpoints_distance = traitlets.Float(allow_none=True)
degauss = traitlets.Float(allow_none=True)
kpoints_distance_description = ipw.HTML("""<p>
The k-points mesh density is set by the chosen <b>protocol</b>.
Untick the box to override the default.
</p>""")
def __init__(self, **kwargs):
self._set_kpoints_distance_automatically = ipw.Checkbox(
description="Use default k-points distance.",
indent=False,
value=True,
)
self._kpoints_distance = ipw.FloatText(
value=self.kpoints_distance_default,
step=0.05,
description="K-points distance:",
disabled=False,
style={"description_width": "initial"},
)
ipw.dlink(
(self._set_kpoints_distance_automatically, "value"),
(self._kpoints_distance, "disabled"),
)
self._kpoints_distance.observe(self.set_kpoints_distance_trait,
"value")
self._set_kpoints_distance_automatically.observe(
self.set_kpoints_distance_trait, "value")
self.set_kpoints_distance_trait()
super().__init__(
children=[
self.kpoints_distance_description,
ipw.HBox([
self._set_kpoints_distance_automatically,
self._kpoints_distance
]),
],
layout=ipw.Layout(justify_content="space-between"),
**kwargs,
)
def set_kpoints_distance_trait(self, _=None):
self.kpoints_distance = (self.kpoints_distance_default if
self._set_kpoints_distance_automatically.value
else self._kpoints_distance.value)
class Bones(traitlets.HasTraits):
fwdspd = traitlets.Float(default_value=0.0)
angspd = traitlets.Float(default_value=0.0)
cmd_vel_msg = Twist()
def __init__(self, *args, **kwargs):
super(Bones, self).__init__(*args, **kwargs)
self.time_last_twist = time.clock()
self.last_rot_spd = 0.0
self.last_fwd_spd = 0.0
def fwd_cb(self, change):
self.cmd_vel_msg.linear.x = change.new
def ang_cb(self, change):
self.cmd_vel_msg.angular.z = change.new
## Twist publishes the cmd_vel_msg, which is a ROS Twist message type.
## the rate is throttled to prevent banging the arduino with too much commmunication.
def twist(self):
pub_cmd_vel.publish(self.cmd_vel_msg)
def forward(self, speed):
self.cmd_vel_msg.linear.x = speed
self.cmd_vel_msg.angular.z = 0
pub_cmd_vel.publish(self.cmd_vel_msg)
def backward(self, speed):
self.cmd_vel_msg.linear.x = -speed
self.cmd_vel_msg.angular.z = 0
pub_cmd_vel.publish(self.cmd_vel_msg)
def left(self, speed):
self.cmd_vel_msg.linear.x = 0
self.cmd_vel_msg.angular.z = speed
pub_cmd_vel.publish(self.cmd_vel_msg)
def right(self, speed):
self.cmd_vel_msg.linear.x = 0
self.cmd_vel_msg.angular.z = -speed
pub_cmd_vel.publish(self.cmd_vel_msg)
def stop(self):
self.fwdspd = 0.0
self.angspd = 0.0
self.cmd_vel_msg.linear.x = 0
self.cmd_vel_msg.angular.z = 0
pub_cmd_vel.publish(self.cmd_vel_msg)
class Bones(HasTraits):
fwdspd = traitlets.Float(default_value=0.0)
angspd = traitlets.Float(default_value=0.0)
cmd_vel_msg = Twist()
def __init__(self, *args, **kwargs):
super(Bones, self).__init__(*args, **kwargs)
@observe('fwdspd')
def _observe_value(self, change):
self.forward(change.new)
@observe('angspd')
def _observe_value(self, change):
self.left(change.new)
def fwd_cb(self, change):
self.forward(change.new)
def ang_cb(self, change):
self.left(change.new)
def forward(self, speed):
self.cmd_vel_msg.linear.x = speed
self.cmd_vel_msg.angular.z = 0
pub_cmd_vel.publish(self.cmd_vel_msg)
def backward(self, speed):
self.cmd_vel_msg.linear.x = -speed
self.cmd_vel_msg.angular.z = 0
pub_cmd_vel.publish(self.cmd_vel_msg)
def left(self, speed):
self.cmd_vel_msg.linear.x = 0
self.cmd_vel_msg.angular.z = speed
pub_cmd_vel.publish(self.cmd_vel_msg)
def right(self, speed):
self.cmd_vel_msg.linear.x = 0
self.cmd_vel_msg.angular.z = -speed
pub_cmd_vel.publish(self.cmd_vel_msg)
def stop(self):
self.fwdspd = 0.0
self.angspd = 0.0
self.cmd_vel_msg.linear.x = 0
self.cmd_vel_msg.angular.z = 0
pub_cmd_vel.publish(self.cmd_vel_msg)
class Robot(SingletonConfigurable):
left_motor = traitlets.Instance(Motor)
right_motor = traitlets.Instance(Motor)
# config
left_motor_channel = traitlets.Integer(default_value=1).tag(config=True)
left_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
right_motor_channel = traitlets.Integer(default_value=2).tag(config=True)
right_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
def __init__(self, *args, **kwargs):
super(Robot, self).__init__(*args, **kwargs)
self.motor_driver = None # for compatibility with jetbot
self.left_motor = Motor(self.motor_driver,
channel=self.left_motor_channel,
alpha=self.left_motor_alpha)
self.right_motor = Motor(self.motor_driver,
channel=self.right_motor_channel,
alpha=self.right_motor_alpha)
def set_motors(self, left_speed, right_speed):
self.left_motor.value = left_speed
self.right_motor.value = right_speed
def forward(self, speed=1.0):
self.left_motor.value = speed
self.right_motor.value = speed
def backward(self, speed=1.0):
self.left_motor.value = -speed
self.right_motor.value = -speed
def left(self, speed=1.0):
self.left_motor.value = -speed
self.right_motor.value = speed
def right(self, speed=1.0):
self.left_motor.value = speed
self.right_motor.value = -speed
def stop(self):
self.left_motor.value = 0
self.right_motor.value = 0
def free(self):
self.left_motor.release()
self.right_motor.release()
class Scatter(widgets.DOMWidget):
_view_name = Unicode('ScatterView').tag(sync=True)
_view_module = Unicode('ipyvolume').tag(sync=True)
_model_name = Unicode('ScatterModel').tag(sync=True)
_model_module = Unicode('ipyvolume').tag(sync=True)
_view_module_version = Unicode(semver_range_frontend).tag(sync=True)
_model_module_version = Unicode(semver_range_frontend).tag(sync=True)
x = Array(default_value=None).tag(sync=True,
**array_sequence_serialization)
y = Array(default_value=None).tag(sync=True,
**array_sequence_serialization)
z = Array(default_value=None).tag(sync=True,
**array_sequence_serialization)
vx = Array(default_value=None,
allow_none=True).tag(sync=True, **array_sequence_serialization)
vy = Array(default_value=None,
allow_none=True).tag(sync=True, **array_sequence_serialization)
vz = Array(default_value=None,
allow_none=True).tag(sync=True, **array_sequence_serialization)
selected = Array(default_value=None,
allow_none=True).tag(sync=True,
**array_sequence_serialization)
sequence_index = Integer(default_value=0).tag(sync=True)
size = traitlets.Union([
Array(default_value=None, allow_none=True).tag(
sync=True, **array_sequence_serialization),
traitlets.Float().tag(sync=True)
],
default_value=5).tag(sync=True)
size_selected = traitlets.Union([
Array(default_value=None, allow_none=True).tag(
sync=True, **array_sequence_serialization),
traitlets.Float().tag(sync=True)
],
default_value=7).tag(sync=True)
color = Array(default_value="red",
allow_none=True).tag(sync=True, **color_serialization)
color_selected = traitlets.Union([
Array(default_value=None, allow_none=True).tag(sync=True,
**color_serialization),
Unicode().tag(sync=True)
],
default_value="green").tag(sync=True)
geo = traitlets.Unicode('diamond').tag(sync=True)
connected = traitlets.CBool(default_value=False).tag(sync=True)
visible = traitlets.CBool(default_value=True).tag(sync=True)
visible_lines = traitlets.CBool(default_value=False).tag(sync=True)
visible_markers = traitlets.CBool(default_value=True).tag(sync=True)
class Robot(SingletonConfigurable):
left_motor = traitlets.Instance(Motor)
right_motor = traitlets.Instance(Motor)
# config
#i2c_bus = traitlets.Integer(default_value=1).tag(config=True)
left_motor_channel = traitlets.Integer(default_value=1).tag(config=True)
left_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
right_motor_channel = traitlets.Integer(default_value=2).tag(config=True)
right_motor_alpha = traitlets.Float(default_value=1.0).tag(config=True)
def __init__(self, *args, **kwargs):
super(Robot, self).__init__(*args, **kwargs)
self.motor_driver = qwiic_scmd.QwiicScmd()
self.left_motor = Motor(self.motor_driver,
channel=self.left_motor_channel,
alpha=self.left_motor_alpha)
self.right_motor = Motor(self.motor_driver,
channel=self.right_motor_channel,
alpha=self.right_motor_alpha)
self.motor_driver.enable()
def set_motors(self, left_speed, right_speed):
self.left_motor.value = left_speed
self.right_motor.value = right_speed
self.motor_driver.enable()
# Set Motor Controls: .set_drive( motor number, direction, speed)
# Motor Number: A = 0, B = 1
# Direction: FWD = 0, BACK = 1
# Speed: (-255) - 255 (neg. values reverse direction of motor)
def forward(self, speed=1.0, duration=None):
self.set_motors(speed, speed)
def backward(self, speed=1.0):
self.set_motors(-speed, -speed)
def left(self, speed=1.0):
self.set_motors(-speed, speed)
def right(self, speed=1.0):
self.set_motors(speed, -speed)
def stop(self):
self.motor_driver.disable()
