def __init__(self):
self.pose_dat = defaultdict(deque)
self.pose_dat_lock = threading.Lock()
self.serial_buffer = ""
self.serial_buffer_lock = threading.Lock()
self.rr_lock = threading.Lock()
self.serial_lock = threading.Lock()
def factory():
def settings_factory():
return [0, 0]
settings_dict = defaultdict(settings_factory)
distances_dict = defaultdict(list)
return (settings_dict, distances_dict)
self.history_dict = defaultdict(factory)
self.rr = RoboRealmInterface()
self.rr.connect()
self.serial_port = SerialInterface()
self.serial_port.open("COM16")
self.rr_thread = threading.Thread(target=self.rr_monitor)
self.rr_lock.acquire()
self.rr_thread.start()
self.serial_thread = threading.Thread(target=self.serial_monitor)
self.serial_lock.acquire()
self.serial_thread.start()
def __init__(self):
self.serial_port = SerialInterface()
self.serial_port.open("COM16")
self.serial_buffer = ""
self.serial_buffer_lock = threading.Lock()
self.serial_lock = threading.Lock()
self.serial_thread = threading.Thread(target=self.serial_monitor)
self.serial_lock.acquire()
self.serial_thread.start()
def __init__(self):
super(DebugerGui, self).__init__()
self.setupUi(self)
self.m_clear1.clicked.connect(self.m_result1.clear)
self.m_clear2.clicked.connect(self.m_result2.clear)
self.m_send.clicked.connect(self.send_start)
self.m_stop.clicked.connect(self.send_stop)
self.interface = SerialInterface()
self.interface.received.connect(self.show_received)
self.m_interval.setValidator(QIntValidator(0, 10000))
self.m_interval.returnPressed.connect(self.send_start)
self.count1 = -1
self.count2 = -1
def __init__(self, view=None):
"""
:param view:AppFrame
:return:Controller
"""
self.view = view
self.serial = SerialInterface(view=self.view)
self.data = []
self.initiatives = []
self.members = []
self.http = HttpInterface()
self.conf = None
def __init__(self):
super(ControllerGui, self).__init__()
self.setupUi(self)
self.m_clear.clicked.connect(self.clear_plot)
self.m_send.clicked.connect(self.send_start)
self.m_stop.clicked.connect(self.send_stop)
self.interface = SerialInterface()
self.interface.received.connect(self.show_received)
self.m_interval.setValidator(QIntValidator(0, 10000))
self.m_interval.returnPressed.connect(self.send_start)
brush = QBrush(QColor(255, 255, 255))
box = QVBoxLayout(self.m_list)
self.temperature_plot = PlotWidget(self)
self.temperature_plot.setBackgroundBrush(brush)
self.temperature_plot.setFixedHeight(300)
box.addWidget(self.temperature_plot)
self.temperature_curves = {}
self.humidity_plot = PlotWidget(self)
self.humidity_plot.setBackgroundBrush(brush)
self.humidity_plot.setFixedHeight(300)
box.addWidget(self.humidity_plot)
self.humidity_curves = {}
self.illumination_plot = PlotWidget(self)
self.illumination_plot.setBackgroundBrush(brush)
self.illumination_plot.setFixedHeight(300)
box.addWidget(self.illumination_plot)
self.illumination_curves = {}
box.addItem(QSpacerItem(40, 20, QSizePolicy.Maximum, QSizePolicy.Expanding))
self.m_list.setLayout(box)
box = QVBoxLayout(self.m_devices)
box.addItem(QSpacerItem(40, 20, QSizePolicy.Maximum, QSizePolicy.Expanding))
self.m_devices.setLayout(box)
self.file = open('result.txt', 'w')
cv2.imwrite(
'snapshot_{0:%Y%m%d_%H%M%S}.jpg'.format(datetime.datetime.now()),
img)
# キャプチャ終了
cap.release()
return result
##############
# メイン関数 #
##############
if __name__ == '__main__':
# bluetooth通信用COMポートを開通する
si = SerialInterface()
si.open(port, baud, None)
# 要求待ち受けのループ
while True:
try:
# クライアントから要求パケットを受信する（受信するまでブロックすることに注意）
command, parameter = si.read()
print("(command, parameter) = ", (command, parameter))
# parameterを解読し色判定対象のピクセル座標のリストを作る
points, errmsg = decodePacket(command, parameter)
# 色判定結果から応答パケットを作る
if points is not None:
# 座標色応答
class MainApp:
hdmiActive = True
shutdownRequested = False
shutdownShellCmd = ""
lastStateUpdate = 0
inetMgr = InternetManager()
audioMgr = AudioManager()
usbManager = UsbManager()
mpdClient = MopidyClient()
serialIf = SerialInterface()
def __init__(self):
pass
def requestShutdown(self, shellCmd):
self.shutdownRequested = True
self.shutdownShellCmd = shellCmd
def handleShutdownRequest(self, signal, frame):
self.requestShutdown("")
def run(self):
signal.signal(signal.SIGINT, self.handleShutdownRequest)
signal.signal(signal.SIGTERM, self.handleShutdownRequest)
self.usbManager.start()
self.inetMgr.start()
self.audioMgr.start()
while not self.shutdownRequested:
start = time.time()
self.loop()
end = time.time()
delta = end - start
time.sleep(max(0, 0.3 - delta))
self.mpdClient.saveStateFile()
self.mpdClient.stop()
self.audioMgr.stop()
self.inetMgr.stop()
self.usbManager.stop()
if self.shutdownShellCmd != "":
call(self.shutdownShellCmd, shell=True)
def shutdownHdmi(self):
if self.inetMgr.isOnline() and self.hdmiActive:
self.hdmiActive = False
call("/usr/bin/tvservice -o", shell=True)
def loop(self):
try:
messages = self.serialIf.read()
for msg in messages:
#print(str(msg))
for (k, v) in msg.items():
if k == "volume":
self.audioMgr.setAudioVolume(v)
elif k == "playlist":
self.mpdClient.loadPlaylist(v)
elif k == "stop":
self.mpdClient.stop()
elif k == "togglePlayPause":
self.mpdClient.togglePlayPause()
elif k == "skipPrevious":
self.mpdClient.skipToPreviousTrack(v)
elif k == "skipNext":
self.mpdClient.skipToNextTrack(v)
elif k == "skipToStart":
self.mpdClient.skipToStart()
elif k == "skipTo":
self.mpdClient.skipToTrack(v)
elif k == "seek":
self.mpdClient.seek(v)
elif k == "shutdown":
self.requestShutdown("sudo shutdown 0")
elif k == "reboot":
self.requestShutdown("sudo reboot 0")
elif k == "wifiSsid":
self.inetMgr.setWifiSsid(v)
elif k == "wifiKey":
self.inetMgr.setWifiKey(v)
elif k == "spotifyUser":
self.mpdClient.setSpotifyUser(v)
elif k == "spotifyPassword":
self.mpdClient.setSpotifyPassword(v)
elif k == "spotifyClientId":
self.mpdClient.setSpotifyClientId(v)
elif k == "spotifyClientSecret":
self.mpdClient.setSpotifyClientSecret(v)
except Exception as e:
print(str(e))
if time.time() - self.lastStateUpdate > 0.66:
self.lastStateUpdate = time.time()
try:
dict = {}
dict["online"] = self.inetMgr.isOnline()
dict.update(self.mpdClient.updateStatus())
self.serialIf.write(dict)
self.shutdownHdmi()
except Exception as e:
print(str(e))
self.mpdClient.disconnect()
from SerialInterface import SerialInterface
import time
from Logger import console
def increment(message):
console.log(message)
if message == "This is message number 0":
# console.log("Message correct")
pass
else:
console.log("Message incorrect")
interface = SerialInterface('/dev/tty.usbmodem1421', 115200)
interface.Listen()
interface.OnInput(increment)
message_count = 0
last_time = time.time()
while True:
cur_time = time.time()
if cur_time - last_time > 1:
# print('Recieved %s messages' % (message_count,))
last_time = cur_time
interface.Write('This is message number %s' % (message_count, ))
console.log('Sending message')
fillcolor=stimulus['Color'])
SoundStimuliList[stimulus_name].initLocalizedSound(
center=stimulus['CenterPosition'],
width=stimulus['Modulation']['Width'],
trackLength=VirtualTrackLength,
maxGain=stimulus['BaselineGain'],
minGain=stimulus['Modulation']['CutoffGain'])
SoundStimuliList[stimulus_name].change_gain(
-90.0) # start off turned off
time.sleep(1.0)
from SerialInterface import SerialInterface
Interface = SerialInterface(SerialPort=args.serial_port)
if 'GPIO' in Config:
for gpio_label, gpio_config in Config['GPIO'].items():
Interface.add_gpio(gpio_label, gpio_config)
from RewardZone import ClassicalRewardZone, OperantRewardZone
RewardsList = []
for reward_name, reward in Config['RewardZones']['RewardZoneList'].items():
if (reward['Type'] == 'Classical') | (reward['Type'] == 'Operant'):
if reward['DispensePin'] not in Interface.GPIOs:
raise ValueError('Dispense pin not in defined GPIO list')
if reward['RewardSound'] != 'None':
if reward['RewardSound'] not in Beeps:
# ('BackLeft', time_offset * 4),
]
def toDegreeInt(num):
return int(num * 180 / math.pi)
def getStep(time):
for s in coords[::-1]:
if s[0] < time:
return s
return coords[-1]
inter = SerialInterface('/dev/tty.usbmodem1421', baud=115200)
inter.Listen()
time.sleep(1)
initial_time = time.time()
last_time = initial_time
while time.time() - initial_time < total_time:
cur_time = time.time()
if cur_time - last_time > interval:
last_time = cur_time
diff_ms = (cur_time - initial_time) * 1000
for leg in legs:
leg_time = (diff_ms * time_factor + leg[1]) % stride_duration
step = getStep(leg_time)
def factory():
def settings_factory():
return [0, 0]
settings_dict = defaultdict(settings_factory)
distances_dict = defaultdict(list)
return (settings_dict, distances_dict)
history_dict = defaultdict(factory)
rr = RoboRealmInterface()
rr.connect()
serial_port = SerialInterface()
if not serial_port.open("COM16"):
print('Error opening serial port %s' % "COM16")
def rr_monitor():
HISTORY_LENGTH = 300
while rr_lock.locked():
with pose_dat_lock:
for k, v in rr.get_robot_positions().items():
pose_dat[k].append(v)
if (len(pose_dat[k]) > HISTORY_LENGTH):
pose_dat[k].popleft()
for robot_id in pose_dat.keys():
print('\t{0}: {1}'.format(robot_id, pose_dat[robot_id][-1]))
