def __init__(self, config):
self.config = config
self.power = False
self._lamps = [Lamp(pins.PIN_LAMP_LEFT), Lamp(pins.PIN_LAMP_RIGHT)]
self.keyboard_status = 'unknown'
self.moving_steps = 0
self.pir_seen_at = 0
self.porch_pir_seen_at = 0
self.music_process = None
self.speech_process = None
self.user_status = 'unknown'
self.temperature = None
self.camera = picamera.PiCamera()
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(pins.PIN_PIR, GPIO.IN)
GPIO.setup(pins.PIN_PORCH_PIR, GPIO.IN)
GPIO.setup(pins.PIN_RETRACTED, GPIO.IN)
GPIO.setup(pins.PIN_TEMPERATURE, GPIO.IN)
GPIO.setup(pins.PIN_EXTENDED, GPIO.IN)
GPIO.setup(pins.PIN_PSU, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(pins.PIN_SPEAKER, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(pins.PIN_RETRACT, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(pins.PIN_EXTEND, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(pins.PIN_PORCH_LAMP, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(pins.PIN_LAMP_LEFT, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(pins.PIN_LAMP_RIGHT, GPIO.OUT, initial=GPIO.LOW)
def __init__(self):
self.active_event = None
self.lamp_timeout = 10
self.double_timeout = 0.3
self.inactive_events = {
Spotify.NAME: Spotify(),
Kodi.NAME: Kodi(),
WatchTv.NAME: WatchTv(),
WatchPlay.NAME: WatchPlay()
}
self.input_keys = {
"up": Kodi,
"down": WatchTv,
"left": Spotify,
"right": WatchPlay
}
self.lamp_keys = {
"up": "ceiling",
"left": "bed",
"right": "sofa",
"down": "all"
}
self.lamp_group = LampGroup({
"sofa": Lamp(100, 1),
"ceiling": Lamp(100, 2),
"bed": Lamp(100, 3),
})
self.remotes = [Remote()]
self.active_modkey = None
def __render_object_layer(self, surface, layer):
# dereference heavily used references for speed
# draw_rect = pygame.draw.rect
draw_lines = pygame.draw.lines
surface_blit = surface.blit
# rect_color = (255, 0, 0)
poly_color = (0, 255, 0)
for obj in layer:
if hasattr(obj, 'points'):
draw_lines(surface, poly_color, obj.closed, obj.points, 3)
elif obj.image:
surface_blit(obj.image, (obj.x, obj.y))
elif obj.name == 'platform':
# draw_rect(surface, rect_color, (obj.x, obj.y, obj.width, obj.height), 3)
self.__platform_rects.append(
pygame.Rect(obj.x, obj.y, obj.width, obj.height))
elif obj.name == 'lamp':
lamp = Lamp(pygame.Rect(obj.x, obj.y, obj.width, obj.height),
obj.order)
self.__lamps.append(lamp)
def setSnows(self):
maxminsnows = 50
sc = [
random.randint(0, 14) + maxminsnows,
random.randint(0, 14) + maxminsnows,
random.randint(0, 14) + maxminsnows
]
for i in range(len(sc)):
snows = []
items = []
for j in range(sc[i]):
imgfn = ":/images/snow" + str(i + 1) + ".png"
x = random.randint(8, self.width() - 8)
y = random.randint(10, self.height())
a = 1
hl = self.height() - self.snowalphach_len
if y > hl:
a = 1 - (y - hl) / self.snowalphach_len
lamp = Lamp(self.scn, imgfn, x, y, a)
if not self.snowing:
lamp.item.hide()
snows.append(lamp)
items.append(lamp.item)
group = self.scn.createItemGroup(items)
if i < 2:
group.setZValue(4)
else:
group.setZValue(0)
self.snows.append(snows)
self.snowgroups.append(items)
def load_rooms_data_from_json(file, vis):
with open('data/default.json', 'r') as f:
data_dict = json.load(f)
rooms = {}
for r in data_dict['plan']:
rm = data_dict['plan'][r]
room = Room(r, rm['width'], rm['height'], vis)
for elm in rm['elements']:
if elm['type'] == 'lamp':
lamp = Lamp(elm['id'], elm['position']['x'],
elm['position']['y'], 'on', vis, r)
room.addElement(lamp)
elif elm['type'] == 'window':
window = Window(elm['id'], elm['position']['x'],
elm['position']['y'], 'close', vis, r)
room.addElement(window)
elif elm['type'] == 'motion_sensor':
motion_sensor = MotionSensor(elm['id'], elm['position']['x'],
elm['position']['y'], 'off', vis,
r)
room.addElement(motion_sensor)
rooms[room.getName()] = room
return rooms
def test_serialize() :
lamp1 = Lamp(1)
lamp2 = Lamp(2)
lamp1.mode = LampMode.on
lamp2.mode = LampMode.off
with open('lamps.db', 'w') as file :
file.write(lamp1.serialize())
file.write(lamp2.serialize())
lamps = []
with open('lamps.db', 'r') as file :
eof = False
while not eof:
lamp = Lamp.deserialize(file.readline())
if lamp is None:
eof = True
else:
lamps.append(lamp)
lamp1b = lamps[0]
lamp2b = lamps[1]
print str(lamp1b.mode) + " supposed to be on."
print str(lamp2b.mode) + " supposed to be off."
def illum_map_elevation(elevation):
""" Illumination map for specific elevation. """
lamp = Lamp(light, Point3D(0.0, 0.0, LAMP_HEIGHT), LAMP_AZIMUT_DEG,
elevation)
plot_illuminance_map(lamp.illuminance,
x_distances,
y_distances,
color_levels=np.linspace(0, 500, 25),
title=f"Illumination [lux] (elev={elevation})")
def init_controller():
lamp = Lamp(pin=25)
while True:
try:
joy = xbox.Joystick()
lamp.on()
return joy
except Exception as e:
print(e)
lamp.on()
time.sleep(0.5)
lamp.off()
time.sleep(0.5)
def __init__(self, width, height):
self.width = width
self.height = height
self.win = pygame.display.set_mode([self.width, self.height],
flags=pygame.RESIZABLE)
self.bg = pygame.image.load(os.path.join("game_assets", "bg.png"))
self.pos = []
self.lamps = []
self.stock = Lamp(25, self.height - 25, 1)
self.press = False
self.connected = []
pygame.font.init()
self.myfont = pygame.font.SysFont('Comic Sans MS', 30)
self.draw_line = False
self.mouse_pos = []
self.charge_lamp = ""
self.index_charge = 0
self.lock = False
self.charge = []
self.positions = []
self.connected_lamps = []
def run():
#OBJETO LAMPARA
lamp = Lamp(is_turned_on=False)
ventilador_con_lampara = VentiladorConLampara(vent_status=True,
lamp_status=True)
while True:
command = str(
input('''
¿Qué deseas hacer?
[p]render
[a]pagar
[s]alir
'''))
if command == 'p':
lamp.turn_on()
ventilador_con_lampara.encender_ventilador(True)
ventilador_con_lampara.turn_on()
elif command == 'a':
lamp.turn_off()
ventilador_con_lampara.encender_ventilador(False)
ventilador_con_lampara.turn_off()
else:
break
def run():
#lamp1 = lamp.Lamp(is_turned_on=False)
lamp1 = Lamp(is_turned_on=False)
while True:
command = input('''
What so you want to do?
[1] Turn ON
[0] Turn OFF
[3] Exit
''')
if command == '1':
lamp1.turn_on()
lamp1._display_image()
elif command == '0':
lamp1.turn_off()
else:
break
def main():
lamp = Lamp()
while 1:
# Open the buffer and wait for somebody to send data
fd = open(fifoPath)
#(rlist, wlist, xlist) = select.select([fd], [], [])
#print rlist
for cmd in fd.readlines():
# Process the command (strip off excess whitespace)
cmd = cmd.strip()
if (cmd == "turn-on"):
lamp.set_on(True)
elif (cmd == "turn-off"):
lamp.set_on(False)
elif (cmd == "toggle"):
lamp.set_on(not lamp.state)
def run():
lamp = Lamp(is_turned_on=False)
while True:
command = input(
"Digite 1 para prender, 2 para apagar y 3 para salir: ")
if command == "1":
lamp.turn_on()
elif command == "2":
lamp.turn_off()
else:
break
def run():
lamp = Lamp(isTurnOn=False)
while True:
command = int(input("What is your action?\t\n1. Turn On\t\n2. Turn off\t\n3. Exit\n"))
if command == 1:
lamp.turnOn()
elif command == 2:
lamp.turnOff()
elif command == 3:
break
else:
print("The command is not found")
def __init__(self, width, height):
self.width = width
self.height = height
self.win = pygame.display.set_mode([self.width, self.height],
flags=pygame.RESIZABLE)
self.bg = pygame.image.load(os.path.join("game_assets", "bg.png"))
self.pos = LEVEL1["pos"]
self.lamps = []
self.connected = LEVEL1["connected"]
i = 0
for dot in self.pos:
self.lamps.append(Lamp(dot[0], dot[1], LEVEL1["charge"][i]))
i += 1
count = 0
for lampa in self.lamps:
for i in range(len(self.connected[count])):
lampa.connected.append(self.lamps[self.connected[count][i]])
count += 1
pygame.font.init()
self.myfont = pygame.font.SysFont('Comic Sans MS', 30)
def main():
lamp = Lamp()
while 1:
# Open the buffer and wait for somebody to send data
fd = open(fifoPath)
#(rlist, wlist, xlist) = select.select([fd], [], [])
#print rlist
for cmd in fd.readlines():
# Process the command (strip off excess whitespace)
cmd = cmd.strip()
if (cmd == "turn-on"):
lamp.set_on(True)
elif (cmd == "turn-off"):
lamp.set_on(False)
elif (cmd == "toggle"):
lamp.set_on(not lamp.state)
def run():
lamp = Lamp(is_turned_on=False)
while True:
command = str(input('''
¿Qué deseas hacer?
[p]render
[a]pagar
[s]alir
'''))
if command == 'p':
lamp.turn_on()
elif command == 'a':
lamp.turn_off()
else:
break
def run():
# intanciar la clase
lamp = Lamp(is_turned_on=False)
while True:
command = input('''
¿Qué deseas hacer?
[p]render
[a]pagar
[s]alir
''')
if command == 'p':
lamp.turn_on()
elif command == 'a':
lamp.turn_off()
else:
sys.exit()
def run():
lamp = Lamp(is_turned_on=False)
while True:
command = input("""
¿Que deseas hacer?
[p]render
[a]pagar
[s]salir
""")
if command == 'p':
lamp.turn_on()
elif command == 'a':
lamp.turn_off()
else:
break
def run():
lamp = Lamp(is_turned_on=False)
while True:
command = str(
input('''
What do you want to do?
[o]On
[f]Off
[e]Exit
'''))
if command == 'o':
lamp.turn_on()
elif command == 'f':
lamp.turn_off()
else:
quit()
def run():
lamp = Lamp(_is_turn_on=False)
while True:
command = str(
input('''
choose an option
1. turn on
2. to turn off
3. exit
'''))
if command == '1':
lamp.turn_on()
elif command == '2':
lamp.turn_off()
else:
break
def run():
lamp = Lamp(is_turned_on=False)
#lamp = Lamp(True) No se utiliza por convención, ya que no indica a que variable se está asignando.
while True:
command = str(input('''
¿Qué deseas hacer?
[p]render
[a]pagar
[s]alir
'''))
if command == 'p':
lamp.turn_on()
elif command == 'a':
lamp.turn_off()
else:
break
def run():
lamp = Lamp(is_turned_on=True) #inicializar una clase
while True:
command = str(
input('''
¿Que deseas hacer?
[p]render
[a]pagar
[s]alir
'''))
if command == 'p':
lamp.turn_on()
elif command == 'a':
lamp.turn_off()
else:
break
def run():
lamp = Lamp(is_turned_on=False)
while (True):
command = str(
raw_input('''
Input one of the following commands:
turn o[n]
turn of[f]
[e]xit
'''))
if command == 'n':
lamp.turn_on()
elif command == 'f':
lamp.turn_off()
elif command == 'e':
return
else:
print('Can\'t understand your input')
def menu():
lamp = Lamp(is_turned_on=False)
while True:
command = str(
input('''
¿Qué deseas hacer?
[p]render
[a]pagar
[s]alir
'''))
if command == 'p':
lamp.turn_on()
elif command == 'a':
lamp.turn_off()
elif command == 's':
print('Adios :b')
break
else:
print('Opcion nula')
def run():
lamp = Lamp(is_turned_on=False)
while True:
menu = str(
input("""
😁Bienvenido que deseas hacer?😎
1.- Encender la lampara
2.- Apagar la lampara
3.- Salir
Escribe tu opcion aqui: """))
if menu == '1':
lamp.turn_on()
elif menu == '2':
lamp.turn_off()
elif menu == '3':
print("Haz salido del sistema")
return False
else:
print("Eligue una opcion correcta!")
def main():
lamp = Lamp(is_turned_on=False)
while True:
command = str(
input('''
What do dou wanna do?
[ON] Turn on
[OFF] Turn off
[E] Exit
Enter your selection: ''')).upper()
if command == 'ON':
lamp.turn_on()
elif command == 'OFF':
lamp.turn_off()
elif command == 'E':
break
else:
print('\n INVALID OPTION! \n')
def run():
lamp = Lamp(is_turned_on=True)
while True:
command = str(
input('''
¿Qué deseas hacer?
[p]render
[a]pagar
[s]alir
'''))
if command == 'p':
lamp.turn_on()
elif command == 'a':
lamp.turn_off()
elif command == 's':
break
else:
print('\nIngresa un comando válido!')
time.sleep(1)
os.system('cls')
import os
from lamp import Lamp
if __name__ == '__main__':
lamp = Lamp(False)
while True:
opt = int(
input('''
Choose an option:
0. Turn off
1. Turn on
2. Exit
'''))
if opt == 0:
lamp.turn_off()
elif opt == 1:
lamp.turn_on()
elif opt == 2:
break
else:
os.system('clear')
print('Invalid option')
screen = pygame.display.set_mode((1200, 800))
pygame.display.set_caption("Pixar ball!")
ballcollect.add(ball)
while True:
print(len(ballcollect))
key_check(event, screen, ball, lamp)
update_screen(screen, ball, lamp)
ballcollect = pygame.sprite.Group()
#Assign sprite a value
ball = Ball()
#Assign sprite a value
lamp = Lamp()
def keydown_check(event, screen, ball, lamp):
"""Respond to key presses"""
if event.key == pygame.K_RIGHT:
lamp.moving_right = True
elif event.key == pygame.K_LEFT:
lamp.moving_left = True
elif event.key == pygame.K_q:
sys.exit
def keyup_check(event, screen, ball, lamp):
"""Respond to key releases"""
if event.key == pygame.K_RIGHT:
def test_lamp() :
tz = tzlocal.get_localzone()
place = Place(nkpCoord())
place.findSunTimes()
scheme = murklanScheme(place)
lamp = Lamp(1)
lamp.update(datetime.time(12, 10, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be OFF. Press enter to continue.")
lamp.update(datetime.time(5, 50, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be OFF. Press enter to continue.")
lamp.update(datetime.time(6, 30, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be ON. Press enter to continue.")
lamp.update(datetime.time(8, 30, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be ON. Press enter to continue.")
lamp.update(datetime.time(9, 10, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be OFF. Press enter to continue.")
lamp.update(datetime.time(18, 40, 5, 0, tz), scheme[1]) # after sunset but within offset
test_wait("Lamp expected to be OFF. Press enter to continue.")
lamp.update(datetime.time(18, 59, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be ON. Press enter to continue.")
lamp.update(datetime.time(22, 29, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be ON. Press enter to continue.")
lamp.update(datetime.time(22, 30, 5, 0, tz), scheme[1])
test_wait("Lamp expected to be OFF. Press enter to continue.")
def _create_permanent_segments(self, el_pix):
perms = []
# PROG
el = Lamp(self, el_pix, 66, 0, 64, 19, True)
el.move(393, 37)
perms.append(el)
# VERB
el = Lamp(self, el_pix, 66, 41, 64, 20, True)
el.move(286, 106)
perms.append(el)
# NOUN
el = Lamp(self, el_pix, 66, 20, 64, 20, True)
el.move(393, 106)
perms.append(el)
for i in range(3):
el = Lamp(self, el_pix, 0, 63, 142, 5, True)
el.move(305, 170 + i * 55)
perms.append(el)
class DSKY(QMainWindow):
def __init__(self, parent):
super().__init__(parent)
self.setWindowTitle('mDSKY')
try:
self._el_serial = serial.Serial('/dev/dsky_el', 57600)
self._el_serial.write(b'R\nR\n')
except:
self._el_serial = None
try:
self._il_serial = serial.Serial('/dev/dsky_il', 57600)
except:
self._il_serial = None
self._setup_ui()
self._packet = [0, 0, 0, 0]
self._packet_idx = 0
self._socket = QTcpSocket(self)
self._socket.readyRead.connect(self._read_data)
self._socket.disconnected.connect(self._connect_to_magc)
self._connect_to_magc()
self._last_el_cmd = b''
self._last_il_cmd = b''
self._timer = QTimer()
self._timer.timeout.connect(self._update_display)
self._timer.start(10)
def _connect_to_magc(self):
self._socket.connectToHost('localhost', 19681)
connected = self._socket.waitForConnected(RECONNECT_MS)
if not connected:
QTimer.singleShot(RECONNECT_MS, self._connect_to_magc)
def _read_data(self):
data = self._socket.read(STATE_SIZE * 10)
while data:
(out0, vnflash, restart, oper_err, key_rel, temp, upl_act,
comp_act, stby) = struct.unpack_from(STATE_FMT, data, 0)
data = data[STATE_SIZE:]
self._update_segments(out0)
self._verb[0].set_on(not vnflash)
self._verb[1].set_on(not vnflash)
self._noun[0].set_on(not vnflash)
self._noun[1].set_on(not vnflash)
self._key_rel.set_on(key_rel)
self._opr_err.set_on(oper_err)
self._upl_act.set_on(upl_act)
self._com_act.set_on(comp_act)
self._restart.set_on(restart)
self._temp.set_on(temp)
self._stby.set_on(stby)
def _update_segments(self, out0):
relay = (out0 >> 11) & 0x0F
relay_value = out0 & 0o3777
if relay == 1:
self._sign3.set_minus_bit((relay_value >> 10) & 0o1)
self._reg3[3].set_relay_bits((relay_value >> 5) & 0o37)
self._reg3[4].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 2:
self._sign3.set_plus_bit((relay_value >> 10) & 0o1)
self._reg3[1].set_relay_bits((relay_value >> 5) & 0o37)
self._reg3[2].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 3:
self._reg2[4].set_relay_bits((relay_value >> 5) & 0o37)
self._reg3[0].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 4:
self._sign2.set_minus_bit((relay_value >> 10) & 0o1)
self._reg2[2].set_relay_bits((relay_value >> 5) & 0o37)
self._reg2[3].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 5:
self._sign2.set_plus_bit((relay_value >> 10) & 0o1)
self._reg2[0].set_relay_bits((relay_value >> 5) & 0o37)
self._reg2[1].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 6:
self._sign1.set_minus_bit((relay_value >> 10) & 0o1)
self._reg1[3].set_relay_bits((relay_value >> 5) & 0o37)
self._reg1[4].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 7:
self._sign1.set_plus_bit((relay_value >> 10) & 0o1)
self._reg1[1].set_relay_bits((relay_value >> 5) & 0o37)
self._reg1[2].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 8:
self._reg1[0].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 9:
self._noun[0].set_relay_bits((relay_value >> 5) & 0o37)
self._noun[1].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 10:
self._verb[0].set_relay_bits((relay_value >> 5) & 0o37)
self._verb[1].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 11:
self._prog[0].set_relay_bits((relay_value >> 5) & 0o37)
self._prog[1].set_relay_bits((relay_value >> 0) & 0o37)
elif relay == 12:
self._prio_disp.set_on((relay_value >> 0) & 0o1)
self._no_dap.set_on((relay_value >> 1) & 0o1)
self._vel.set_on((relay_value >> 2) & 0o1)
self._no_att.set_on((relay_value >> 3) & 0o1)
self._alt.set_on((relay_value >> 4) & 0o1)
self._gimbal_lock.set_on((relay_value >> 5) & 0o1)
self._tracker.set_on((relay_value >> 7) & 0o1)
self._prog_alarm.set_on((relay_value >> 8) & 0o1)
def _setup_ui(self):
self.setObjectName('#DSKY')
self.setWindowFlags(Qt.Window)
self.setFixedSize(500, 580)
self.setStyleSheet(
'DSKY{background-image: url(:/resources/dsky.png);}')
self.setWindowTitle('mDSKY')
el_pix = QPixmap(':/resources/el.png')
lamp_pix = QPixmap(':/resources/lamps.png')
self._com_act = Lamp(self, el_pix, 0, 1, 65, 61, False)
self._com_act.move(285, 36)
self._perms = self._create_permanent_segments(el_pix)
self._prog = self._create_mode(el_pix, 394, 60)
self._verb = self._create_mode(el_pix, 287, 129)
self._noun = self._create_mode(el_pix, 394, 129)
self._sign1, self._reg1 = self._create_reg(el_pix, 287, 184)
self._sign2, self._reg2 = self._create_reg(el_pix, 287, 239)
self._sign3, self._reg3 = self._create_reg(el_pix, 287, 294)
self._but_verb = self._create_button(8, 404, 0b10001) # VERB
self._but_noun = self._create_button(8, 474, 0b11111) # NOUN
self._but_plus = self._create_button(78, 369, 0b11010) # +
self._but_minus = self._create_button(78, 439, 0b11011) # -
self._but_0 = self._create_button(78, 509, 0b10000) # 0
self._but_7 = self._create_button(148, 369, 0b00111) # 7
self._but_4 = self._create_button(148, 439, 0b00100) # 4
self._but_1 = self._create_button(148, 509, 0b00001) # 1
self._but_8 = self._create_button(218, 369, 0b01000) # 8
self._but_5 = self._create_button(218, 439, 0b00101) # 5
self._but_2 = self._create_button(218, 509, 0b00010) # 2
self._but_9 = self._create_button(288, 369, 0b01001) # 9
self._but_6 = self._create_button(288, 439, 0b00110) # 6
self._but_3 = self._create_button(288, 509, 0b00011) # 3
self._but_clr = self._create_button(359, 369, 0b11110) # CLR
self._but_pro = self._create_button(359, 439, 0b100000) # PRO
self._but_key_rel = self._create_button(359, 509, 0b11001) # KEY REL
self._but_enter = self._create_button(429, 404, 0b11100) # ENTER
self._but_reset = self._create_button(429, 474, 0b10010) # RESET
self._upl_act = Lamp(self, lamp_pix, 0, 0, 78, 37, False)
self._upl_act.move(45, 34)
self._no_att = Lamp(self, lamp_pix, 0, 38, 78, 37, False)
self._no_att.move(45, 77)
self._stby = Lamp(self, lamp_pix, 0, 76, 78, 37, False)
self._stby.move(45, 120)
self._key_rel = Lamp(self, lamp_pix, 0, 114, 78, 37, False)
self._key_rel.move(45, 163)
self._opr_err = Lamp(self, lamp_pix, 0, 152, 78, 37, False)
self._opr_err.move(45, 206)
self._prio_disp = Lamp(self, lamp_pix, 0, 190, 78, 37, False)
self._prio_disp.move(45, 249)
self._no_dap = Lamp(self, lamp_pix, 0, 228, 78, 37, False)
self._no_dap.move(45, 292)
self._temp = Lamp(self, lamp_pix, 79, 0, 78, 37, False)
self._temp.move(134, 34)
self._gimbal_lock = Lamp(self, lamp_pix, 79, 38, 78, 37, False)
self._gimbal_lock.move(134, 77)
self._prog_alarm = Lamp(self, lamp_pix, 79, 76, 78, 37, False)
self._prog_alarm.move(134, 120)
self._restart = Lamp(self, lamp_pix, 79, 114, 78, 37, False)
self._restart.move(134, 163)
self._tracker = Lamp(self, lamp_pix, 79, 152, 78, 37, False)
self._tracker.move(134, 206)
self._alt = Lamp(self, lamp_pix, 79, 190, 78, 37, False)
self._alt.move(134, 249)
self._vel = Lamp(self, lamp_pix, 79, 228, 78, 37, False)
self._vel.move(134, 292)
self._il_lamps = [
self._upl_act, self._no_att, self._stby, self._key_rel,
self._opr_err, self._prio_disp, self._no_dap, self._temp,
self._gimbal_lock, self._prog_alarm, self._restart, self._tracker,
self._alt, self._vel
]
self.show()
def _create_reg(self, el_pix, col, row):
digits = []
sign = Sign(self, el_pix)
sign.move(col, row + 6)
for i in range(5):
ss = SevenSegment(self, el_pix)
ss.move(col + 18 + 30 * i, row)
digits.append(ss)
return sign, digits
def _create_mode(self, el_pix, col, row):
digits = []
for i in range(2):
ss = SevenSegment(self, el_pix)
ss.move(col + 30 * i, row)
digits.append(ss)
return digits
def _create_permanent_segments(self, el_pix):
perms = []
# PROG
el = Lamp(self, el_pix, 66, 0, 64, 19, True)
el.move(393, 37)
perms.append(el)
# VERB
el = Lamp(self, el_pix, 66, 41, 64, 20, True)
el.move(286, 106)
perms.append(el)
# NOUN
el = Lamp(self, el_pix, 66, 20, 64, 20, True)
el.move(393, 106)
perms.append(el)
for i in range(3):
el = Lamp(self, el_pix, 0, 63, 142, 5, True)
el.move(305, 170 + i * 55)
perms.append(el)
def _create_button(self, x, y, keycode):
b = Button(self)
b.setFixedSize(63, 63)
b.move(x, y)
b.setStyleSheet('QPushButton{background-color: rgba(0,0,0,0);}')
b.setFocusPolicy(Qt.FocusPolicy.NoFocus)
b.setAutoRepeat(False)
if keycode == 0b100000:
key_on = keycode | 0b1
key_off = keycode
else:
key_on = keycode
key_off = 0
b.pressed.connect(lambda: self._send_key(key_on))
b.released.connect(lambda: self._send_key(key_off))
return b
def _send_key(self, k):
self._socket.write(QByteArray(struct.pack('<B', k)))
def _update_display(self):
reg1 = b''.join([ss.value for ss in self._reg1])
reg2 = b''.join([ss.value for ss in self._reg2])
reg3 = b''.join([ss.value for ss in self._reg3])
verb = b''.join([ss.value for ss in self._verb])
noun = b''.join([ss.value for ss in self._noun])
prog = b''.join([ss.value for ss in self._prog])
el_cmd = b'DA%s%s%s%s%s%s%s%s%s%s\n' % (
self._sign1.value, reg1, self._sign2.value, reg2,
self._sign3.value, reg3, verb, noun, self._com_act.value, prog)
if el_cmd != self._last_el_cmd:
if self._el_serial is not None:
self._el_serial.write(el_cmd)
self._el_serial.readline()
self._last_el_cmd = el_cmd
il_values = 0
for i in range(len(self._il_lamps)):
if self._il_lamps[i].value == b'1':
il_values |= 1 << i
il_cmd = b'M%04X\n' % il_values
if il_cmd != self._last_il_cmd:
if self._il_serial is not None:
self._il_serial.write(il_cmd)
self._il_serial.readline()
self._last_il_cmd = il_cmd
def paintEvent(self, event):
opt = QStyleOption()
opt.init(self)
p = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, p, self)
def keyPressEvent(self, event):
if event.isAutoRepeat():
return
key = event.key()
self._set_key_down(key, True)
def keyReleaseEvent(self, event):
if event.isAutoRepeat():
return
key = event.key()
self._set_key_down(key, False)
def _set_key_down(self, key, down):
but = None
if key == Qt.Key.Key_V:
but = self._but_verb
elif key == Qt.Key.Key_N:
but = self._but_noun
elif key == Qt.Key.Key_V:
but = self._but_verb
elif key == Qt.Key.Key_Plus or key == Qt.Key.Key_Equal:
but = self._but_plus
elif key == Qt.Key.Key_Minus:
but = self._but_minus
elif key == Qt.Key.Key_0:
but = self._but_0
elif key == Qt.Key.Key_1:
but = self._but_1
elif key == Qt.Key.Key_2:
but = self._but_2
elif key == Qt.Key.Key_3:
but = self._but_3
elif key == Qt.Key.Key_4:
but = self._but_4
elif key == Qt.Key.Key_5:
but = self._but_5
elif key == Qt.Key.Key_6:
but = self._but_6
elif key == Qt.Key.Key_7:
but = self._but_7
elif key == Qt.Key.Key_8:
but = self._but_8
elif key == Qt.Key.Key_9:
but = self._but_9
elif key == Qt.Key.Key_C:
but = self._but_clr
elif key == Qt.Key.Key_P:
but = self._but_pro
elif key == Qt.Key.Key_K:
but = self._but_key_rel
elif key == Qt.Key.Key_E:
but = self._but_enter
elif key == Qt.Key.Key_R:
but = self._but_reset
if but is None:
return
if down:
but.press()
else:
but.release()
