def take(self):
self.producer_queue = self.producer_sub.get_queue()
self.producer = self.producer_sub.get_producer()
self.logger.info("Got producer named '%s'" % self.producer.name)
async def loop(self):
while True:
producer_counter = await self.producer_queue.get()
self.logger.info("producer counter: %s" % producer_counter)
await asyncio.sleep(0.5)
class MyOrchestrator(Orchestrator):
def __init__(self, event_loop):
super(MyOrchestrator, self).__init__(event_loop)
producer = ProducerNode()
consumer1 = ConsumerNode1()
consumer2 = ConsumerNode2()
self.add_nodes(producer, consumer1, consumer2)
self.subscribe(producer, consumer1, consumer1.producer_tag)
self.subscribe(producer, consumer2, consumer2.producer_tag)
run(MyOrchestrator)
# log_time = "22_02_17.log"
# data_set_name = "tremor generator only, 6.4Hz"
tb6612_name = "TB6612"
tb6612_directory = os.path.join(log_date, tb6612_name)
# update_rate = 0.0 # go as fast as possible
update_rate = None # run in real time
bno055 = BNO055Playback(log_time, log_date, update_rate=update_rate)
tb6612 = PlaybackNode(log_time, directory=tb6612_directory, message_class=TB6612Message, name=tb6612_name,
update_rate=update_rate)
plotter = Plotter(enabled=True, time_data_window=6.0)
csv_creator_tb6612 = CsvCreator(
os.path.join("data", "%s %s %s-TB6612.csv" % (data_set_name, log_time[:-4], log_date[5:])),
use_tb6612=True, use_bno055=False)
csv_creator_bno055 = CsvCreator(
os.path.join("data", "%s %s %s-BNO055.csv" % (data_set_name, log_time[:-4], log_date[5:])),
use_bno055=True, use_tb6612=False)
self.subscribe(tb6612, plotter, plotter.tb6612_tag)
self.subscribe(bno055, plotter, plotter.bno055_tag)
self.subscribe(tb6612, csv_creator_tb6612, csv_creator_tb6612.tb6612_tag)
self.subscribe(bno055, csv_creator_bno055, csv_creator_bno055.bno055_tag)
run(PlaybackOrchestrator)
from atlasbuggy import Orchestrator, run
from graphical.plotter import Plotter
# from graphical.fft_plotter import Plotter
from arduinos.tb6612 import TB6612
from arduinos.bno055 import BNO055
matplotlib.use('TkAgg') # keeps tkinter happy
from graphical.gui import TkinterGUI
class VisualizerOrchestrator(Orchestrator):
def __init__(self, event_loop):
self.set_default(write=False)
super(VisualizerOrchestrator, self).__init__(event_loop)
self.tb6612 = TB6612()
self.bno055 = BNO055(enabled=True)
self.plotter = Plotter(enabled=True, time_data_window=3.0)
self.gui = TkinterGUI("constants/pid_constants.pkl")
self.subscribe(self.tb6612, self.plotter, self.plotter.tb6612_tag)
self.subscribe(self.bno055, self.plotter, self.plotter.bno055_tag)
self.subscribe(self.bno055, self.plotter,
self.plotter.bno055_motor_tag)
self.subscribe(self.tb6612, self.gui, self.gui.tb6612_tag)
self.subscribe(self.bno055, self.gui, self.gui.bno055_tag)
run(VisualizerOrchestrator)
def main():
run(ConsoleOrchestrator, small_brake_experiment)
def main():
# run(ExperimentOrchestrator, large_brake_experiment) # no extra resistor
run(ExperimentOrchestrator, small_brake_experiment) # with extra resistor
self.set_logger(write=False, level=10)
super(BasicOrchestrator, self).__init__(event_loop)
self.test_node = BasicNode()
self.add_nodes(self.test_node)
async def loop(self):
counter = 0
while True:
self.logger.info("counter: %s" % counter)
await asyncio.sleep(1.0)
counter += 1
class BasicNode(Node):
def __init__(self):
super(BasicNode, self).__init__()
async def loop(self):
counter = 0
while True:
# intentional error:
counter = 1 / counter
self.logger.info("node counter: %s" % counter)
await asyncio.sleep(1.0)
counter += 1
run(BasicOrchestrator)
self.subscribe(self.stereo_sticher, self.viewer,
self.viewer.capture_tag)
# recorder
self.subscribe(self.stereo_sticher, self.recorder,
self.recorder.capture_tag)
# orbslam2
self.subscribe(self.stereo_cam, self.orbslam2,
self.orbslam2.stereo_tag)
# stereo_cam
self.subscribe(self.picamera, self.stereo_cam,
self.stereo_cam.fast_cam_tag)
self.subscribe(self.client, self.stereo_cam,
self.stereo_cam.slow_cam_tag)
async def loop(self):
while True:
await asyncio.sleep(0.25)
if self.orbslam2.initialized:
print("Tracking state: %s" % self.orbslam2.tracking_state)
print(self.orbslam2.orb.get_trajectory_points())
print()
else:
print("Orbslam not ready.")
await asyncio.sleep(0.75)
run(OrbSlamOrchestrator)
self.command_client = CommandClient(client)
self.picamera = PiCamera(enabled=False)
self.add_nodes(self.hardware, self.cli, self.sounds, self.guidance,
self.odometry, self.camera_client, self.command_client,
self.picamera)
self.subscribe(self.sounds, self.cli, self.cli.sounds_tag)
self.subscribe(self.hardware, self.cli, self.cli.hardware_tag)
self.subscribe(self.guidance, self.cli, self.cli.guidance_tag)
self.subscribe(self.command_client, self.cli,
self.cli.command_source_tag)
self.subscribe(self.odometry, self.guidance,
self.guidance.odometry_tag)
self.subscribe(self.hardware, self.guidance,
self.guidance.hardware_tag)
self.subscribe(self.hardware, self.odometry, self.odometry.encoder_tag,
self.hardware.encoder_service)
self.subscribe(self.hardware, self.odometry, self.odometry.bno055_tag,
self.hardware.bno055_service)
# async def loop(self):
# while True:
# print(self.hardware.left_tick, self.hardware.right_tick)
# await asyncio.sleep(0.1)
run(NaborisOrchestrator)
from atlasbuggy import Orchestrator, run
from atlasbuggy.opencv import OpenCVViewer
from naboris.website_client import CameraWebsiteClient
class ClientCamOrchestrator(Orchestrator):
def __init__(self, event_loop):
self.set_default(write=True, level=10)
super(ClientCamOrchestrator, self).__init__(event_loop)
self.client = CameraWebsiteClient(720, 480)
self.viewer = OpenCVViewer(enabled=True)
self.add_nodes(self.client, self.viewer)
self.subscribe(self.client, self.viewer, self.viewer.capture_tag)
run(ClientCamOrchestrator)
await asyncio.sleep(0.0)
continue
odom = await self.odom_queue.get()
self.x.append(odom.x)
self.y.append(odom.y)
self.plotter.plot('Odometry', self.x, self.y)
class Robot(Orchestrator):
def __init__(self, event_loop):
super(Robot, self).__init__(event_loop)
imu_node = None
encoder_node = None
live_plotter = LivePlotter(
title='Odometry Data',
maximized=True
)
odom = Odometry()
odom_plot = OdometryPlot()
self.add_nodes(imu_node, encoder_node, live_plotter, odom, odom_plot)
self.subscribe(imu_node, odom, odom.imu_tag)
self.subscribe(encoder_node, odom, odom.encoder_tag)
self.subscribe(live_plotter, odom_plot, odom_plot.plotter_tag)
self.subscribe(odom, odom_plot, odom_plot.odom_tag)
run(Robot)
while True:
self.logger.info("node counter: %s" % counter)
await asyncio.sleep(0.25)
counter += 4
class MultiNodeOrchestrator(Orchestrator):
def __init__(self, event_loop):
super(MultiNodeOrchestrator, self).__init__(event_loop)
self.node1 = Node1()
self.node2 = Node2()
self.node3 = Node3()
self.add_nodes(self.node1, self.node2, self.node3)
async def loop(self):
counter = 0
while True:
self.logger.info("orchestrator counter: %s" % counter)
await asyncio.sleep(0.5)
counter += 1
if counter > 3:
self.logger.info("counter = 4. Shutting down")
# self.halt() # halting or returning are valid options
return
run(MultiNodeOrchestrator)
from atlasbuggy import Orchestrator, run
from naboris.hardware_interface import HardwareInterface
from naboris.cli import NaborisCLI
from naboris.website_client import WebsiteConnection
from naboris.website_client import CommandClient
log = True
class CommandOrchestrator(Orchestrator):
def __init__(self, event_loop):
self.set_default(write=log, level=20)
super(CommandOrchestrator, self).__init__(event_loop)
self.hardware = HardwareInterface(enabled=False)
self.cli = NaborisCLI(enabled=False)
client = WebsiteConnection("10.76.76.1", user="******", password="******", timeout=10)
self.command_client = CommandClient(client)
self.add_nodes(self.hardware, self.cli, self.command_client)
self.subscribe(self.hardware, self.cli, self.cli.hardware_tag)
self.subscribe(self.command_client, self.cli, self.cli.command_source_tag)
run(CommandOrchestrator)
def main():
run(ExperimentOrchestrator)
plotting_enabled = False
self.viso_plotter_node = VisoPlotterNode(plotting_enabled)
self.plotter = LivePlotter(enabled=plotting_enabled,
title='PLOTS',
size=(800, 800),
ncols=2,
frequency=0)
# image area: 3673.6um, 2738.4um
# pixel size: 1.4um
f_pix = 743.28794629
cu = 239.16868139
cv = 216.06257926
distored_w = 639 # 608
distored_h = 479 # 441
self.pipeline = Viso2MonoPipeline(f_pix, cu, cv, distored_w,
distored_h)
self.add_nodes(self.viso_plotter_node, self.plotter, self.video,
self.viewer, self.pipeline)
self.subscribe(self.pipeline, self.viewer, self.viewer.capture_tag)
self.subscribe(self.video, self.pipeline, self.pipeline.capture_tag)
self.subscribe(self.pipeline, self.viso_plotter_node,
self.viso_plotter_node.viso_tag)
self.subscribe(self.plotter, self.viso_plotter_node,
self.viso_plotter_node.plotter_tag)
run(VisoOrchestrator)
