class LEDAClient(object):
def __init__(self, host, port, log):
self.host = host
self.port = port
self.log = log
#self.connect()
def connect(self, timeout=10):
self.log.write("Connecting to remote server %s:%i" \
% (self.host,self.port))
self.sock = SimpleSocket(timeout=timeout)
try:
self.sock.connect(self.host, self.port)
except SimpleSocket.timeout_error:
self.log.write("All connections were refused", -2)
self.sock = None
except:
self.log.write("Failed to connect. "+str(sys.exc_info()[1]), -2)
self.sock = None
else:
self.log.write("Connection successful")
def isConnected(self):
return self.sock is not None
def _sendmsg(self, msg, timeout="default"):
if self.sock is None:
self.log.write("send: Not connected (%s:%i)" % (self.host,self.port), -2)
return None
if len(msg) <= 256:
self.log.write("Sending message "+msg, 4)
else:
self.log.write("Sending long message of length %i bytes"%(len(msg)), 4)
try:
self.sock.send(msg)
ret = self.sock.receive(timeout=timeout)
except:
self.log.write("recv: Not connected (%s:%i)" % (self.host,self.port), -2)
self.sock = None
return None
if len(ret) < 256:
self.log.write("Received response "+ret, 4)
else:
self.log.write("Received long response of length %i bytes"%(len(ret)), 4)
return ret
def _sendcmd(self, cmd):
ret = self._sendmsg(cmd)
if ret is None:
return None
if ret == 'ok':
return True
else:
self.log.write("Remote command failed", -2)
raise Exception("Remote command failed")
class LEDARemoteHeadNodeControl(object):
def __init__(self, host, port, log=LEDALogger()):
self.host = host
self.port = port
self.log = log
self.connect()
def connect(self):
self.log.write("Connecting to remote headnode %s:%i" % (self.host, self.port))
# TODO: See comment in leda_headnodecontrol.py
self.sock = SimpleSocket(timeout=10)
try:
self.sock.connect(self.host, self.port)
except SimpleSocket.timeout_error:
self.log.write("All connections were refused", -2)
self.sock = None
except:
self.log.write("Failed to connect. " + str(sys.exc_info()[1]), -2)
self.sock = None
else:
self.log.write("Connection successful")
def isConnected(self):
return self.sock is not None
def _sendmsg(self, msg):
if self.sock is None:
self.log.write("Not connected", -2)
return None
if len(msg) <= 256:
self.log.write("Sending message " + msg, 4)
else:
self.log.write("Sending long message of length %i bytes" % (len(msg)), 4)
try:
self.sock.send(msg)
ret = self.sock.receive()
except:
self.log.write("Not connected", -2)
self.sock = None
return None
else:
if len(ret) <= 256:
self.log.write("Received response " + ret, 4)
else:
self.log.write("Received long response of length %i bytes" % (len(ret)), 4)
return ret
def _sendcmd(self, cmd):
ret = self._sendmsg(cmd)
if ret is None:
return
if ret != "ok":
self.log.write("Remote command failed", -2)
raise Exception("Remote command failed")
def getStatus(self):
self.log.write("Requesting status", 2)
# if self.sock is None:
# self.log.write("Not connected", -2)
# return None
encoded = self._sendmsg("status=1")
if encoded is None:
return None
# print "json.loads('%s')" % encoded
status = json.loads(encoded)
return status
def getADCImages(self):
self.log.write("Requesting ADC images", 2)
encoded = self._sendmsg("adc_images=1")
if encoded is None:
return None
# print "json.loads('%s')" % encoded
encoded_images = json.loads(encoded)
# images = [Image.open(base64.standard_b64decode(im))
# TODO: This isn't great. We return the raw binary data as a string.
images = [[base64.standard_b64decode(adc_im) for adc_im in roach] for roach in encoded_images]
# images = [base64.standard_b64decode(im)
# for im in encoded_images]
return images
def exit(self):
self.log.write("Exiting", 2)
self._sendcmd("exit=1")
def configure(self):
self.log.write("Configuring", 2)
self._sendcmd("configure=1")
def programRoaches(self):
self.log.write("Programming roaches", 2)
self._sendcmd("program_roaches=1")
def createBuffers(self):
self.log.write("Creating buffers", 2)
self._sendcmd("create_buffers=1")
def setTotalPowerRecording(self, ncycles):
self.log.write("Setting total power recording param", 2)
self._sendcmd("total_power=%i" % ncycles)
def startObservation(self, mode="correlator", ra=None, dec=None):
self.log.write("Starting observation", 2)
if ra is not None and dec is not None:
self._sendcmd("start=1&mode=%s&ra=%s&dec=%s" % (mode, ra, dec))
else:
self._sendcmd("start=1&mode=%s" % mode)
def stopObservation(self):
self.log.write("Stopping observation", 2)
self._sendcmd("stop=1")
def killObservation(self):
self.log.write("Killing observation", 2)
self._sendcmd("kill=1")
def clearLogs(self):
self.log.write("Clearing all logs", 2)
self._sendcmd("clear_logs=1")
def getVisMatrixImages(self):
self.log.write("Requesting visibility matrix images", 2)
encoded = self._sendmsg("vismatrix_images=1")
if encoded is None:
return None
encoded_images = json.loads(encoded)
# TODO: This isn't great. We return the raw binary data as a string.
images = [base64.standard_b64decode(encoded_image) for encoded_image in encoded_images]
return images
import socket
import pygame, sys
import time
from SimpleSocket import SimpleSocket
conn = SimpleSocket()
conn.connect("192.168.0.16", 5001)
conn.sock.setblocking(0)
pygame.init()
pygame.display.set_caption('Ev3 Keyboard Control')
size = [400, 400]
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# check if key is pressed
# if you use event.key here it will give you error at runtime
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT \
or event.key == pygame.K_UP:
conn.sendMessage("stop\n")
continue
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
conn.sendMessage("turnleft\n")
class LEDARemoteServerControl(object):
def __init__(self, host, port, log=LEDALogger()):
self.host = host
self.port = port
self.log = log
self.connect()
def connect(self):
self.log.write("Connecting to remote server %s:%i" \
% (self.host,self.port))
#self._nstreams = None
# TODO: This timeout must be long enough to cover long
# operations on the server. This is not a good
# way to do things; would probably be better to
# send an instant response and something like
# an asynchronous "I'll get back to you in N secs".
self.sock = SimpleSocket(timeout=10)
try:
self.sock.connect(self.host, self.port)
except SimpleSocket.timeout_error:
self.log.write("All connections were refused", -2)
self.sock = None
except:
self.log.write("Failed to connect. "+str(sys.exc_info()[1]), -2)
self.sock = None
else:
self.log.write("Connection successful")
def isConnected(self):
return self.sock is not None
def _sendmsg(self, msg):
if self.sock is None:
self.log.write("Not connected", -2)
self.log.write("Reconnecting", 0)
self.connect()
return None
if len(msg) <= 256:
self.log.write("Sending message "+msg, 4)
else:
self.log.write("Sending long message of length %i bytes"%(len(msg)), 4)
try:
self.sock.send(msg)
ret = self.sock.receive()
except:
self.log.write("Not connected", -2)
self.sock = None
self.log.write("Reconnecting", 0)
self.connect()
return None
if len(ret) < 256:
self.log.write("Received response "+ret, 4)
else:
self.log.write("Received long response of length %i bytes"%(len(ret)), 4)
return ret
def _sendcmd(self, cmd):
ret = self._sendmsg(cmd)
if ret is None:
return
if ret != 'ok':
self.log.write("Remote command failed", -2)
raise Exception("Remote command failed")
def getStatus(self):
self.log.write("Requesting server status", 2)
if self.sock is None:
self.log.write("Not connected", -2)
self.log.write("Reconnecting", 0)
self.connect()
return None
encoded = self._sendmsg("status=1")
if encoded is None:
return None
status = json.loads(encoded)
return status
def createBuffers(self):
self.log.write("Creating buffers", 2)
self._sendcmd("create_buffers=1")
def destroyBuffers(self):
self.log.write("Destroying buffers", 2)
self._sendcmd("destroy_buffers=1")
def setTotalPowerRecording(self, ncycles):
self.log.write("Setting total power recording param", 2)
self._sendcmd("total_power=%i" % ncycles)
def armPipeline(self, mode='correlator'):
self.log.write("Arming pipeline in %s mode" % mode, 2)
self._sendcmd("arm=1&mode=%s" % mode)
def startPipeline(self, ra=None, dec=None):
self.log.write("Starting pipeline", 2)
if ra is not None and dec is not None:
self._sendcmd("start=1&ra=%s&dec=%s" % (ra,dec))
else:
self._sendcmd("start=1")
def killPipeline(self):
self.log.write("Killing pipeline", 2)
self._sendcmd("kill=1")
def clearLogs(self):
#self.log.write("Clearing all logs", 2)
self._sendcmd("clear_logs=1")
def getVisMatrixImages(self):
self.log.write("Requesting visibility matrix images", 2)
encoded = self._sendmsg("vismatrix_images=1")
if encoded is None:
return None
encoded_images = json.loads(encoded)
return encoded_images
def exit(self):
self.log.write("Requesting server control script to exit", 2)
self._sendcmd("exit=1")
