def __init__(self, spi_liststore_lock):
gtk.gdk.threads_init() # init the gdk threads
threading.Thread.__init__(self)
self.spi_liststore_lock = spi_liststore_lock
# a bit of spaghetti set up
emulator_parts.pfio = pfio
emulator_parts.rpi_emulator = self
self.spi_visualiser_section = emulator_parts.SpiVisualiserFrame(self)
global pfio_connect
try:
pfio.init()
pfio_connect = True
except pfio.InitError:
print "Could not connect to the SPI module (check privileges). Starting emulator assuming that the PiFace is not connected."
pfio_connect = False
emulator_parts.pfio = None
self.emu_window = gtk.Window()
self.emu_window.connect("delete-event", gtk.main_quit)
self.emu_window.set_title(WINDOW_TITLE)
# emu screen
self.emu_screen = emulator_parts.EmulatorScreen(EMU_WIDTH, EMU_HEIGHT, EMU_SPEED)
self.emu_screen.show()
# board connected msg
if pfio_connect:
msg = "Pi Face detected!"
else:
msg = "Pi Face not detected"
self.board_con_msg = gtk.Label(msg)
self.board_con_msg.show()
if pfio_connect:
# keep inputs updated
self.update_input_check = gtk.CheckButton("Keep inputs updated")
self.update_input_check.show()
self.update_interval = gtk.Entry(5)
self.update_interval.set_width_chars(5)
self.update_interval.set_text("500")
self.update_interval.show()
update_interval_label = gtk.Label("ms interval")
update_interval_label.show()
self.update_input_check.connect("clicked", self.update_inputs)
update_inputs_containter = gtk.HBox(False)
update_inputs_containter.pack_start(self.update_input_check)
update_inputs_containter.pack_start(self.update_interval, False, False)
update_inputs_containter.pack_start(update_interval_label, False, False)
update_inputs_containter.show()
# spi visualiser checkbox
self.spi_vis_check = gtk.CheckButton("SPI Visualiser")
self.spi_vis_check.connect("clicked", self.toggle_spi_visualiser)
self.spi_vis_check.show()
# enable pullups checkbox
self.en_pull_check = gtk.CheckButton("Enable pullups")
self.en_pull_check.set_active(True)
self.en_pull_check.connect("clicked", self.toggle_en_pullups)
self.en_pull_check.show()
# output override section
self.output_override_section = \
emulator_parts.OutputOverrideSection(self.emu_screen.output_pins)
self.output_override_section.show()
# spi visualiser
if pfio_connect:
#spi_visualiser_section = emulator_parts.SpiVisualiserFrame()
self.spi_visualiser_section.set_size_request(50, 200)
self.spi_visualiser_section.set_border_width(DEFAULT_SPACING)
#self.spi_visualiser_section.show()
self.spi_visualiser_section.hide()
# vertically pack together the emu_screen and the board connected msg
container0 = gtk.VBox(homogeneous=False, spacing=DEFAULT_SPACING)
container0.pack_start(self.emu_screen)
container0.pack_start(self.board_con_msg)
if pfio_connect:
container0.pack_start(update_inputs_containter)
container0.pack_start(self.spi_vis_check)
container0.pack_start(self.en_pull_check)
container0.show()
# horizontally pack together the emu screen+msg and the button overide
container1 = gtk.HBox(homogeneous=True, spacing=DEFAULT_SPACING)
container1.pack_start(container0)
container1.pack_start(self.output_override_section)
container1.set_border_width(DEFAULT_SPACING)
container1.show()
top_containter = container1
if pfio_connect:
# now, verticaly pack that container and the spi visualiser
container2 = gtk.VBox(homogeneous=True, spacing=DEFAULT_SPACING)
container2.pack_start(child=container1, expand=False, fill=False, padding=0)
container2.pack_start(self.spi_visualiser_section)
container2.show()
top_containter = container2
self.emu_window.add(top_containter)
self.emu_window.present()
self.input_updater = None
def init_pfio(self, widget, data=None):
pfio.init()
def init_pfio(self, widget, data=None):
pfio.init()
def start_pfio_server(callback=None, verbose=False, port=DEFAULT_PORT):
"""Starts listening for pfio packets over the network"""
pfio.init()
try:
# this returns the loopback ip on the RPi :-(
#hostname = socket.gethostname()
###################################################
# this is pretty hacky, if anyone can find a better
# solution, then please change this!
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80)) # try to connect to google's dns
hostname = s.getsockname()[0] # get this device's hostname
s.close()
# blergh, nasty stuff
###################################################
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((hostname, port))
except socket.error as e:
print "There was an error setting up the server socket!"
print e
return
else:
if verbose:
print "Listening at %s on port %d" % (hostname, port)
while True:
# get the packet
packet, sender = sock.recvfrom(BUFFER_SIZE)
if verbose:
print "Recieved packet from", sender
# make it something sensible
packet = PfionPacket().from_network(packet)
if packet.command == WRITE_OUT_CMD:
pfio.write_output(packet.bit_pattern)
p = PfionPacket(WRITE_OUT_ACK)
sock.sendto(p.for_network(), sender)
elif packet.command == READ_OUT_CMD:
output_bitp = pfio.read_output()
p = PfionPacket(READ_OUT_ACK)
p.bit_pattern = output_bitp
sock.sendto(p.for_network(), sender)
elif packet.command == READ_IN_CMD:
input_bitp = pfio.read_input()
p = PfionPacket(READ_IN_ACK)
p.bit_pattern = input_bitp
sock.sendto(p.for_network(), sender)
elif packet.command == DIGITAL_WRITE_CMD:
pfio.digital_write(packet.pin_number, packet.pin_value)
p = PfionPacket(DIGITAL_WRITE_ACK)
sock.sendto(p.for_network(), sender)
elif packet.command == DIGITAL_READ_CMD:
pin_value = pfio.digital_read(packet.pin_number)
p = PfionPacket(DIGITAL_READ_ACK)
p.pin_number = packet.pin_number
p.pin_value = pin_value
sock.sendto(p.for_network(), sender)
elif callback != None:
callback(packet, sender)
elif verbose:
print "Unkown packet command (%d). Ignoring." % packet.command
def start_pfio_server(callback=None, verbose=False, port=DEFAULT_PORT):
"""Starts listening for pfio packets over the network"""
pfio.init()
try:
# this returns the loopback ip on the RPi :-(
#hostname = socket.gethostname()
###################################################
# this is pretty hacky, if anyone can find a better
# solution, then please change this!
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80)) # try to connect to google's dns
hostname = s.getsockname()[0] # get this device's hostname
s.close()
# blergh, nasty stuff
###################################################
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((hostname, port))
except socket.error as e:
print "There was an error setting up the server socket!"
print e
return
else:
if verbose:
print "Listening at %s on port %d" % (hostname, port)
while True:
# get the packet
packet, sender = sock.recvfrom(BUFFER_SIZE)
if verbose:
print "Recieved packet from", sender
# make it something sensible
packet = PfionPacket().from_network(packet)
if packet.command == WRITE_OUT_CMD:
pfio.write_output(packet.bit_pattern)
p = PfionPacket(WRITE_OUT_ACK)
sock.sendto(p.for_network(), sender)
elif packet.command == READ_OUT_CMD:
output_bitp = pfio.read_output()
p = PfionPacket(READ_OUT_ACK)
p.bit_pattern = output_bitp
sock.sendto(p.for_network(), sender)
elif packet.command == READ_IN_CMD:
input_bitp = pfio.read_input()
p = PfionPacket(READ_IN_ACK)
p.bit_pattern = input_bitp
sock.sendto(p.for_network(), sender)
elif packet.command == DIGITAL_WRITE_CMD:
pfio.digital_write(packet.pin_number, packet.pin_value)
p = PfionPacket(DIGITAL_WRITE_ACK)
sock.sendto(p.for_network(), sender)
elif packet.command == DIGITAL_READ_CMD:
pin_value = pfio.digital_read(packet.pin_number)
p = PfionPacket(DIGITAL_READ_ACK)
p.pin_number = packet.pin_number
p.pin_value = pin_value
sock.sendto(p.for_network(), sender)
elif callback != None:
callback(packet, sender)
elif verbose:
print "Unkown packet command (%d). Ignoring." % packet.command
