def __init__(self, server_addr, server_port): self.port = port TCPServer.__init__(self, server_addr, server_port) self.command_map["AUTH"] = self.command_handler #users: #{ username: password } self.users = {}
def __init__(self, server_addr, server_port): TCPServer.__init__(self, server_addr, server_port) self.command_map["FSCOMMAND"] = self.command_handler self.command_map["PING"] = self.ping self.command_map["GET_FILE"] = self.send_file self.command_map["SEND_FILE"] = self.receive_file self.listen()
def __init__(self, server_addr, server_port): TCPServer.__init__(self, server_addr, server_port) self.command_map["DSCOMMAND"] = self.command_handler self.command_map["CREATE_FILE"] = self.create_file self.command_map["DELETE_FILE"] = self.delete_file self.command_map["DIR_LIST"] = self.get_directory_listing self.command_map["GET_FILE"] = self.get_file self.command_map["CLOSE_FILE"] = self.get_file self.command_map["NEW_DIR"] = self.new_directory #{ dirpath: {filename: server_details} } self.directories = {} self.directories["/"] = {} #{ serverid: {ip, port} self.servers = {}
class ServerRunner(): serverNotifier = None serverRunning = False server = None serverPort = None class ServerNotifier(): parent = None UNDEFINED = 0 TERMINATE = 1 def __init__(self, parent): self.parent = parent def notify(self, msg): if msg == self.TERMINATE: log.debug('Server terminate notify') self.parent.serverRunning = False def __init__(self, port): log.debug('Creating ServerRunner, port ' + str(port)) self.serverPort = port pass def startServer(self): self.serverNotifier = self.ServerNotifier(self) self.server = TCPServer(self.serverPort, self.serverNotifier) assert self.server.start() == True self.serverRunning = True return True def stopServer(self): assert self.serverRunning == True self.server.stop() waitTime = 0 while self.serverRunning: log.debug('Waiting 0.2s for server shutdown..') time.sleep(0.2) waitTime += 0.2 if waitTime > 4: log.debug('Giving up!') assert False break self.server = None return True
class Gateway: def __init__(self): self.tcpServerCreated = False def run(self): self.TCPServer.run() def setConfig(self, config): print("SETCONFIG") if (self.tcpServerCreated): print("Stopping TCP Server") self.TCPServer.stop() if config['ServerType'].lower() == "vizrt": self.gateway = VizrtGateway(config) elif config['ServerType'].lower() == "channelport": self.gateway = ChannelportGateway(config) self.listenPort = int(config["ListenerPort"]) logging.basicConfig(level=logging.INFO, filename="Graphic_Gateway.log", format="%(asctime)s::%(message)s") self.TCPServer = TCPServer(self.listenPort, self.dataReceived) self.tcpServerCreated = True self.TCPServer.run() def dataReceived(self, receivedData, dataToSend): responseData = "" response = {} try: command = Command(receivedData) if command.type == "CheckStatus": graphicVersion = self.gateway.getVersion() response["GraphicVersion"] = str(graphicVersion) response["GatewayVersion"] = "0.1.0" response["Time"] = str(datetime.datetime.now()) responseData = json.dumps(response) else: try: responseData = self.gateway.executeCommand(command) except Exception as e: logging.error(e) if responseData != "": dataToSend.append(responseData) except Exception as e: logging.error(e) dataToSend.append("{'Response':'JSON parse error'}")
def setConfig(self, config): print("SETCONFIG") if (self.tcpServerCreated): print("Stopping TCP Server") self.TCPServer.stop() if config['ServerType'].lower() == "vizrt": self.gateway = VizrtGateway(config) elif config['ServerType'].lower() == "channelport": self.gateway = ChannelportGateway(config) self.listenPort = int(config["ListenerPort"]) logging.basicConfig(level=logging.INFO, filename="Graphic_Gateway.log", format="%(asctime)s::%(message)s") self.TCPServer = TCPServer(self.listenPort, self.dataReceived) self.tcpServerCreated = True self.TCPServer.run()
def main(ipv4_host, port, player_count, inverted_color, maze, ino, start, end): try: children = [] inos = [] signal.signal(signal.SIGINT, signal.SIG_DFL) Console.disable_quick_edit() for i in ino: inbuff = multiprocessing.Queue() outbuff = multiprocessing.Queue() p = multiprocessing.Process(target=talk2ino, args=(i, inbuff, outbuff), daemon=True) p.start() children.append(p) inos.append((inbuff, outbuff, True)) GameLogic.init(maze, inverted_color, start, end) TCPServer.init(ipv4_host, port, player_count, inos) TCPServer.run_host() TCPServer._wait() while not TCPServer._shutdown: pass except KeyboardInterrupt: print("Closing Server...", flush=True) for p in children: p.join()
def __init__(self, settingsManager: ConfigurationManager, zeroPointManager: ZeroPointManager): self._settingsManager = settingsManager self._zeroPointManager = zeroPointManager self._stopTurnTableEvent = Event() self._jobThreads = ControllerThreads() self._position = Position() def connectionFactory(port: int, name: str) -> LANConnection: return LANConnection(self._settingsManager.turnTableIPAddress, port, name=name, timeout=self._settingsManager.timeout) callbacks = TCPCallbacks( getAzimuth=self.getCurrentPosition, getElevation=self.getCurrentPosition, setAzimuth=self.createGotoPositionJob, setElevation=self.createGotoPositionJob, stop=self.stop, ) self._tcpServer = TCPServer(callbacks=callbacks, settingsManager=self._settingsManager) self._shaftEncoder = ShaftEncoderModel(connectionFactory( self._settingsManager.shaftEncoderPort, "Shaft Encoder Connection"), settingsManager=settingsManager) self._motorController = MotorControllerModel( watchdogConnection=connectionFactory( self._settingsManager.watchdogPort, "Watchdog Connection"), motorControllerConnection=connectionFactory( self._settingsManager.motorControllerPort, "Motor Controller Connection"), settingsManager=settingsManager, ) self._mainView = MainView() self._settingsManagerView = SettingsView(self._settingsManager) self.showMainView()
class TCPServer1Thread(Thread): ownerNotifier = None terminated = False serverListener = None tcpServer = None port = None def __init__ (self, ownerNotifier, serverListener, port): Thread.__init__(self) self.ownerNotifier = ownerNotifier self.serverListener = serverListener self.port = port def cleanup(self): if self.tcpServer.running(): self.tcpServer.stop() self.ownerNotifier.notify(self.ownerNotifier.TERMINATE) def run(self): try: log.debug('TCPServer1Thread.run') self.tcpServer = TCPServer(self.port, self.ownerNotifier) self.tcpServer.start() while not self.terminated: while not self.serverListener.empty(): data = self.serverListener.read() + '\n' self.tcpServer.writeAll(data) time.sleep(0.01) self.cleanup() except: # sys.excepthook does not work in threads import traceback traceback.print_exc() self.terminated = True self.cleanup() def terminate(self): log.debug('TCPServer1Thread.terminate') self.terminated = True
def run(self): try: log.debug('TCPServer1Thread.run') self.tcpServer = TCPServer(self.port, self.ownerNotifier) self.tcpServer.start() while not self.terminated: while not self.serverListener.empty(): data = self.serverListener.read() + '\n' self.tcpServer.writeAll(data) time.sleep(0.01) self.cleanup() except: # sys.excepthook does not work in threads import traceback traceback.print_exc() self.terminated = True self.cleanup()
def __init__(self): Thread.__init__(self) self.name = "WalleServer" self.number = 0 self.azimuth = 0.0 # position sense, azimuth from north self.turning_to_object = False # Are we turning to see an object self.hearing_angle = 0.0 # device hears sound from this angle, device looks to its front # to the azimuth direction self.observation_angle = 0.0 # turn until azimuth is this angle self.leftPower = 0.0 # moving self.rightPower = 0.0 self.number = 0 self.in_axon = Axon() # global queue for senses to put sensations to walle self.out_axon = Axon() # global queue for walle to put sensations to external senses # starting build in capabilities/senses # we have capability to move if MANUAL: self.romeo = ManualRomeo() else: self.romeo = Romeo() # we have hearing (positioning of object using sounds) self.hearing = Hearing(self.in_axon) # starting tcp server as nerve pathway to external senses to connect # we have azimuth sense (our own position detection) self.tcpServer = TCPServer(out_axon=self.in_axon, in_axon=self.out_axon, server_address=(HOST, PORT)) self.running = False self.turnTimer = Timer(WalleServer.ACTION_TIME, self.stopTurn) self.calibrating = False # are we calibrating self.calibrating_angle = 0.0 # calibrate device hears sound from this angle, device looks to its front # self.calibratingTimer = Timer(WalleServer.ACTION_TIME, self.stopCalibrating) print "WalleServer: Calibrate version"
class TurnTableController: def __init__(self, settingsManager: ConfigurationManager, zeroPointManager: ZeroPointManager): self._settingsManager = settingsManager self._zeroPointManager = zeroPointManager self._stopTurnTableEvent = Event() self._jobThreads = ControllerThreads() self._position = Position() def connectionFactory(port: int, name: str) -> LANConnection: return LANConnection(self._settingsManager.turnTableIPAddress, port, name=name, timeout=self._settingsManager.timeout) callbacks = TCPCallbacks( getAzimuth=self.getCurrentPosition, getElevation=self.getCurrentPosition, setAzimuth=self.createGotoPositionJob, setElevation=self.createGotoPositionJob, stop=self.stop, ) self._tcpServer = TCPServer(callbacks=callbacks, settingsManager=self._settingsManager) self._shaftEncoder = ShaftEncoderModel(connectionFactory( self._settingsManager.shaftEncoderPort, "Shaft Encoder Connection"), settingsManager=settingsManager) self._motorController = MotorControllerModel( watchdogConnection=connectionFactory( self._settingsManager.watchdogPort, "Watchdog Connection"), motorControllerConnection=connectionFactory( self._settingsManager.motorControllerPort, "Motor Controller Connection"), settingsManager=settingsManager, ) self._mainView = MainView() self._settingsManagerView = SettingsView(self._settingsManager) self.showMainView() def showMainView(self): self._mainView.stepSizeSpinBox.setRange( self._settingsManager.minimumStepSize, self._settingsManager.maximumStepSize) self._mainView.gotoPositionSpinBox.setRange( self._settingsManager.minimumGotoPosition, self._settingsManager.maximumGotoPosition) self._mainView.motorVoltageSliderValueSpinBox.setRange( self._settingsManager.minimumVoltage, self._settingsManager.maximumVoltage) self._mainView.motorVoltageSlider.setRange( self._settingsManager.minimumVoltage, self._settingsManager.maximumVoltage) self._mainView.applicationSettingsAction.triggered.connect( self._settingsManagerView.show) self._mainView.loadZeroPositionDataAction.triggered.connect( self.loadZeroPosition) self._mainView.saveZeroPositionDataAction.triggered.connect( self.saveZeroPosition) self._mainView.connectButton.clicked.connect(self.connect) self._mainView.disconnectButton.clicked.connect(self.disconnect) self._mainView.goPushButton.clicked.connect(self.createGotoPositionJob) self._mainView.motorVoltageSlider.doubleValueChanged.connect( self.setMotorVoltage) self._mainView.resetVoltageButton.clicked.connect( self.resetMotorVoltage) self._mainView.stopPushButton.clicked.connect(self.stopMotion) self._mainView.stepPushButton.clicked.connect(self.stepPosition) self._mainView.resetZeroPositionButton.clicked.connect( self.resetPositionOffest) self._mainView.setCurrentPositionAsZeroButton.clicked.connect( self.setPositionOffset) self._mainView.applicationClosed.connect(self.stop) self._mainView.motorVoltageSlider.setValue(0.000) self._mainView.show() #------------------------------------------------------------------------------ # Starting and Stopping Methods #------------------------------------------------------------------------------ def start(self): self._jobThreads.updateGUI = TimedJobThread( self._settingsManager.GUIUpdatePeriod, self.updateGUI) self._jobThreads.updateGUI.start() def stop(self): logging.debug("Stopping Turn Table Controller") self.stopMotion() self.disconnect() logging.debug("Turn Table Controller Stopped...") def stopMotion(self): if self._jobThreads.gotoPosition is not None: self._stopTurnTableEvent.set() self._jobThreads.gotoPosition = None if self._motorController.getCurrentVoltage() != 0.000: self.resetMotorVoltage() #------------------------------------------------------------------------------ # Connection Handling Methods #------------------------------------------------------------------------------ def connect(self): self._motorController.start() self._shaftEncoder.start() self._tcpServer.connect() if self._motorController.isWatchdogConnected( ) and self._motorController.isMotorControllerConnected( ) and self._shaftEncoder.isConnected() and self._tcpServer.isConnected( ): self._mainView.toggleControls() def disconnect(self): self._motorController.stop() self._shaftEncoder.stop() self._tcpServer.disconnect() if self._motorController.isWatchdogConnected( ) and self._motorController.isMotorControllerConnected( ) and self._shaftEncoder.isConnected() and self._tcpServer.isConnected( ): self._mainView.toggleControls() #------------------------------------------------------------------------------ # Position Helper Methods #------------------------------------------------------------------------------ def setPositionOffset(self): self._position.offset = -self._shaftEncoder.currentPosition def resetPositionOffest(self): self._position.offset = 0.000 def getCurrentPosition(self) -> float: self._position.current = self._shaftEncoder.currentPosition return self._position.current #------------------------------------------------------------------------------ # GUI Update Helper Methods #------------------------------------------------------------------------------ def updateGUI(self): shaftEncoderConnectionStatus = self._shaftEncoder.isConnected() motorControllerConnectionStatus = self._motorController.isMotorControllerConnected( ) watchdogConnectionStatus = self._motorController.isWatchdogConnected() tcpServerConnectionStatus = self._tcpServer.isConnected() self._mainView.updateConnectionStatusLineEdits( shaftEncoderConnectionStatus, motorControllerConnectionStatus, watchdogConnectionStatus, tcpServerConnectionStatus) self._mainView.updatePositionLineEdits(self._position) #------------------------------------------------------------------------------ # Motor Control Methods #------------------------------------------------------------------------------ def setMotorVoltage(self, newVoltage: float): if (not self._motorController.isEnabled()) and (newVoltage != 0.000): self._motorController.toggleEnable() self._motorController.setVoltage(newVoltage=newVoltage) def resetMotorVoltage(self): if self._motorController.isEnabled(): self._motorController.toggleEnable() self._motorController.setVoltage(0.000) def createGotoPositionJob(self, targetPosition: float): self._jobThreads.gotoPosition = Thread(target=self.gotoPosition, args=(targetPosition, )) self._jobThreads.gotoPosition.start() def stepPosition(self, step: float): currentPosition = self.getCurrentPosition() self.createGotoPositionJob(currentPosition + step) def gotoPosition(self, targetPosition: float): maxVoltage = self._settingsManager.maximumVoltage updatePeriod = self._settingsManager.voltageUpdatePeriod KP = self._settingsManager.controlProportionalGain KI = self._settingsManager.controlIntegralGain KD = self._settingsManager.controlDerivativeGain minimumControlSignalValue = self._settingsManager.minimumControlSignalValue maximumAllowedError = self._settingsManager.maximumAllowedError self._position.target = targetPosition if not self._motorController.isEnabled(): self._motorController.toggleEnable() previousError = 0 if self._stopTurnTableEvent.is_set(): self._stopTurnTableEvent.clear() while True: error = self._position.error if (abs(error) < maximumAllowedError) or ( self._stopTurnTableEvent.is_set()): self._motorController.setVoltage(0.000) self._motorController.toggleEnable() break errorDelta = error - previousError previousError = error voltageControlSignal = (KP * error + KI * error * updatePeriod + KD * errorDelta / updatePeriod) voltageControlSignal = sorted( (-maxVoltage, voltageControlSignal, maxVoltage))[1] voltageControlSignal = math.copysign( max(abs(voltageControlSignal), minimumControlSignalValue), voltageControlSignal) self._motorController.setVoltage(voltageControlSignal) time.sleep(updatePeriod) def saveZeroPosition(self): saveZeroPoint = SaveZeroPoint(self._position.offset, self._zeroPointManager) saveZeroPoint.exec_() def loadZeroPosition(self): loadZeroPoint = LoadZeroPointView(self._zeroPointManager) loadZeroPoint.exec_() self._position.offset = self._zeroPointManager.getOffset()
# ******************************************************** #Close TCP socket tcpClient.closeTCPclient() print '[ImageSource] TCPClient closed' #**************************MIDI PART****************************************** # ******************************************************** #Wait for UDP Packet Flag saying MIDI is ready to be sent ret = udpClient.receiveUDPmsg(delay) # ******************************************************** #Start TCP Server midi_data=ret.split(',') print '[ImageSource] Image Name: {0}, Image Size: {1}'.format(midi_data[0], midi_data[1]) # ******************************************************** #Accept RPI TCP connection tcpServer = TCPServer(MY_IP,TCP_PORT,BUFFER_SIZE,os.uname()[1]) tcpServer.bindSocket() udpClient.sendUDPmsg("OK", RPI_IP, UDP_PORT) tcpServer.acceptSocket() # ******************************************************** #Receive MIDI print '[ImageSource] Using receiveDatabySize to receive: '+midi_data[1]+' bytes of '+midi_data[0] data_received = tcpServer.receiveDataBySize(int(midi_data[1])) f = open(midi_data[0],"w") f.write(data_received) f.close() print '[ImageSource] Created file '+midi_data[0]+' with the data received by TCP.' # ******************************************************** #Close TCP socket tcpServer.closeTCPServer() print '[ImageSource] TCPServer closed'
import sys import json from TCPServer import TCPServer # Load config config = None try: with open('config.json', 'r') as configFile: config = configFile.read() if config is not None: config = json.loads(config) except: print("ERROR! Configuration file not found.", file=sys.stderr) exit() # Starts VisionAlert Server server = TCPServer(config['port']) try: server.start() except KeyboardInterrupt: server.stop() print("Bye") sys.exit()
#Close TCP socket tcpClient.closeTCPclient() print '[ImageSource] TCPClient closed' #**************************MIDI PART****************************************** # ******************************************************** #Wait for UDP Packet Flag saying MIDI is ready to be sent ret = udpClient.receiveUDPmsg(delay) # ******************************************************** #Start TCP Server midi_data = ret.split(',') print '[ImageSource] Image Name: {0}, Image Size: {1}'.format( midi_data[0], midi_data[1]) # ******************************************************** #Accept RPI TCP connection tcpServer = TCPServer(MY_IP, TCP_PORT, BUFFER_SIZE, os.uname()[1]) tcpServer.bindSocket() udpClient.sendUDPmsg("OK", RPI_IP, UDP_PORT) tcpServer.acceptSocket() # ******************************************************** #Receive MIDI print '[ImageSource] Using receiveDatabySize to receive: ' + midi_data[ 1] + ' bytes of ' + midi_data[0] data_received = tcpServer.receiveDataBySize(int(midi_data[1])) f = open(midi_data[0], "w") f.write(data_received) f.close() print '[ImageSource] Created file ' + midi_data[ 0] + ' with the data received by TCP.' # ******************************************************** #Close TCP socket
d_stats = dict() d_stats['config'] = config d_stats['neighbours_ids'] = dict() d_stats['neighbours_lastmsg_time'] = dict() d_stats['t_init'] = int(time.strftime("%s")) d_stats['server_id'] = 1 d_stats['membership'] = dict() d_stats['l_threads'] = list() d_stats['count_rcv_msg'] = 0 d_stats['conns'] = 0 # Launching server if config['Server']['SocketType'] == 'udp': server = SocketServer.UDPServer((config['Server']['ListeningToAddress'], int(config['Server']['ListeningToPort'])), MyUDPHandler) elif config['Server']['SocketType'] == 'tcp': server = TCPServer(config['Server']['ListeningToAddress'], int(config['Server']['ListeningToPort']), max_threads = 16, stats=d_stats, config = config, queue=None, whoami='server') else: logging.critical("Error: SocketType is neither udp or tcp.") exit(1) # Launching Observer obs = Observer(server, d_stats) # Now listen to petitions server.serve_forever()
class IoTHUBServer: VERSION = '1.0' def __init__(self, ip: str, port: int, uri: str = None): self._server = TCPServer(ip, port) self.uri = uri if uri is not None else "{}@{}".format(ip, ip) self.callbacks = [] def connection_handler(self, conn, addr): pass def request_handler(self, request: TCPRequest, response: TCPResponse): try: request_content = self.parse_request(request.receive()) while not request_content.params_received(): request_content = self.parse_request(request.more()) callbacks = [ value for key, value in self.callbacks if key == request_content.type ] if len(callbacks) > 0: for cb in callbacks: cb(request, response) return True # handling has been done else: raise Exception("Operation {} not supported".format( request_content.type)) except Exception as e: res = IoTHUBMessage() res.type = "ERROR" res.uri = self.uri res.protocol_version = self.VERSION res.sender = IoTHUBMessage.parse_address(response.local_addr) res.receiver = IoTHUBMessage.parse_address(request.remote_addr) res.ctype = "text/plain" res.parameters = {"message": str(e)} response.write_string(str(res)) return True #close the connection def on(self, operation): def inner(callback): self.callbacks.append((operation, callback)) return inner def parse_request(self, content: bytes): content = IoTHUBMessage.from_string(content.decode('utf-8')) return content def listen(self): self._server.listen(self.request_handler, self.connection_handler)
def __init__(self, ip: str, port: int, uri: str = None): self._server = TCPServer(ip, port) self.uri = uri if uri is not None else "{}@{}".format(ip, ip) self.callbacks = []
import time from TCPServer import TCPServer server = TCPServer() out_list = ['sample', 'test', 'list'] @server.handler(pass_list=out_list) def test(addr: tuple, data: bytes, pass_list) -> (bytes, bytearray): print(pass_list) print(f'{addr[0]}:{addr[1]} - {data}') time.sleep(0.3) return bytes(data) if __name__ == '__main__': server.run()
class WalleServer(Thread): """ Controls Walle-robot. Walle has capabilities like moving, hearing, seeing and position sense. Technically we use socket servers to communicate with external devices. Romeo board is controlled using library using USB. We use USB-microphones and Raspberry pi camera. Walle emulates sensorys (camera, microphone, mobile phone) that have emit sensations to "brain" that has state and memory and gives commands (technically Sensation class instances) to muscles (Romeo Board, mobile phone) Sensations from integrated sensorys are transferred By axons ad in real organs, implemented as Queue, which is thread safe. Every sensory runs in its own thread as real sensorys, independently. External Sensorys are handled using sockets. """ TURN_ACCURACYFACTOR = math.pi * 10.0 / 180.0 FULL_TURN_FACTOR = math.pi * 45.0 / 180.0 DEFAULT_OBSERVATION_DISTANCE = 3.0 ACTION_TIME = 1.0 def __init__(self): Thread.__init__(self) self.name = "WalleServer" self.number = 0 self.azimuth = 0.0 # position sense, azimuth from north self.turning_to_object = False # Are we turning to see an object self.hearing_angle = 0.0 # device hears sound from this angle, device looks to its front # to the azimuth direction self.observation_angle = 0.0 # turn until azimuth is this angle self.leftPower = 0.0 # moving self.rightPower = 0.0 self.number = 0 self.in_axon = Axon() # global queue for senses to put sensations to walle self.out_axon = Axon() # global queue for walle to put sensations to external senses # starting build in capabilities/senses # we have capability to move if MANUAL: self.romeo = ManualRomeo() else: self.romeo = Romeo() # we have hearing (positioning of object using sounds) self.hearing = Hearing(self.in_axon) # starting tcp server as nerve pathway to external senses to connect # we have azimuth sense (our own position detection) self.tcpServer = TCPServer(out_axon=self.in_axon, in_axon=self.out_axon, server_address=(HOST, PORT)) self.running = False self.turnTimer = Timer(WalleServer.ACTION_TIME, self.stopTurn) self.calibrating = False # are we calibrating self.calibrating_angle = 0.0 # calibrate device hears sound from this angle, device looks to its front # self.calibratingTimer = Timer(WalleServer.ACTION_TIME, self.stopCalibrating) print "WalleServer: Calibrate version" def run(self): print "Starting " + self.name # starting other threads/senders/capabilities self.running = True self.hearing.start() print "WalleServer: starting TCPServer" self.tcpServer.start() while self.running: sensation = self.in_axon.get() print "WalleServer: got sensation from queue " + str(sensation) self.process(sensation) # as a test, echo everything to external device # self.out_axon.put(sensation) self.tcpServer.stop() self.hearing.stop() def stop(self): self.running = False def process(self, sensation): print "WalleServer.process: " + time.ctime(sensation.getTime()) + " " + str(sensation) if sensation.getSensationType() == Sensation.SensationType.Drive: print "Walleserver.process Sensation.SensationType.Drive" elif sensation.getSensationType() == Sensation.SensationType.Stop: print "Walleserver.process Sensation.SensationType.Stop" self.stop() elif sensation.getSensationType() == Sensation.SensationType.Who: print "Walleserver.process Sensation.SensationType.Who" elif sensation.getSensationType() == Sensation.SensationType.HearDirection: print "Walleserver.process Sensation.SensationType.HearDirection" # inform external senses that we remember now hearing self.out_axon.put(sensation) self.hearing_angle = sensation.getHearDirection() if self.calibrating: print "Walleserver.process Calibrating hearing_angle " + str( self.hearing_angle ) + " calibrating_angle " + str(self.calibrating_angle) else: self.observation_angle = self.add_radian( original_radian=self.azimuth, added_radian=self.hearing_angle ) # object in this angle print "Walleserver.process create Sensation.SensationType.Observation" self.in_axon.put( Sensation( number=++self.number, sensationType=Sensation.SensationType.Observation, observationDirection=self.observation_angle, observationDistance=WalleServer.DEFAULT_OBSERVATION_DISTANCE, ) ) # mark hearing sensation to be processed to set direction out of memory, we forget it sensation.setDirection(Sensation.Direction.Out) # inform external senses that we don't remember hearing any more self.out_axon.put(sensation) elif sensation.getSensationType() == Sensation.SensationType.Azimuth: if not self.calibrating: print "Walleserver.process Sensation.SensationType.Azimuth" # inform external senses that we remember now azimuth # self.out_axon.put(sensation) self.azimuth = sensation.getAzimuth() self.turn() elif sensation.getSensationType() == Sensation.SensationType.Observation: if not self.calibrating: print "Walleserver.process Sensation.SensationType.Observation" # inform external senses that we remember now observation self.out_axon.put(sensation) self.observation_angle = sensation.getObservationDirection() self.turn() elif sensation.getSensationType() == Sensation.SensationType.Picture: print "Walleserver.process Sensation.SensationType.Picture" elif sensation.getSensationType() == Sensation.SensationType.Calibrate: print "Walleserver.process Sensation.SensationType.Calibrate" if sensation.getMemory() == Sensation.Memory.Working: if sensation.getDirection() == Sensation.Direction.In: print "Walleserver.process asked to start calibrating mode" self.calibrating = True else: print "Walleserver.process asked to stop calibrating mode" self.calibrating = False # ask external senses to to set same calibrating mode self.out_axon.put(sensation) elif sensation.getMemory() == Sensation.Memory.Sensory: if self.calibrating: if self.turning_to_object: print "Walleserver.process turning_to_object, can't start calibrate activity yet" else: # allow requester to start calibration activaties if sensation.getDirection() == Sensation.Direction.In: print "Walleserver.process asked to start calibrating activity" self.calibrating_angle = sensation.getHearDirection() self.hearing.setCalibrating(calibrating=True, calibrating_angle=self.calibrating_angle) sensation.setDirection(Sensation.Direction.In) self.out_axon.put(sensation) # self.calibratingTimer = Timer(WalleServer.ACTION_TIME, self.stopCalibrating) # self.calibratingTimer.start() else: print "Walleserver.process asked to stop calibrating activity" self.hearing.setCalibrating(calibrating=False, calibrating_angle=self.calibrating_angle) # self.calibratingTimer.cancel() else: print "Walleserver.process asked calibrating activity WITHOUT calibrate mode, IGNORED" elif sensation.getSensationType() == Sensation.SensationType.Capability: print "Walleserver.process Sensation.SensationType.Capability" elif sensation.getSensationType() == Sensation.SensationType.Unknown: print "Walleserver.process Sensation.SensationType.Unknown" def turn(self): # calculate new power to turn or continue turning self.leftPower, self.rightPower = self.getPower() if self.turning_to_object: print "WalleServer.turn: self.hearing_angle " + str(self.hearing_angle) + " self.azimuth " + str( self.azimuth ) print "WalleServer.turn: turn to " + str(self.observation_angle) if math.fabs(self.leftPower) < Romeo.MINPOWER or math.fabs(self.rightPower) < Romeo.MINPOWER: self.stopTurn() print "WalleServer.turn: Turn is ended" self.turnTimer.cancel() else: print "WalleServer.turn: powers adjusted to " + str(self.leftPower) + " " + str(self.rightPower) self.number = self.number + 1 sensation, picture = self.romeo.processSensation( Sensation( number=self.number, sensationType="D", leftPower=self.leftPower, rightPower=self.rightPower ) ) self.leftPower = sensation.getLeftPower() # set motors in opposite power to turn in place self.rightPower = sensation.getRightPower() # set motors in opposite power to turn in place else: if math.fabs(self.leftPower) >= Romeo.MINPOWER or math.fabs(self.rightPower) >= Romeo.MINPOWER: self.turning_to_object = True # adjust hearing # if turn, don't hear sound, because we are giving moving sound # we want hear only sounds from other objects self.hearing.setOn(not self.turning_to_object) print "WalleServer.turn: powers initial to " + str(self.leftPower) + " " + str(self.rightPower) self.number = self.number + 1 sensation, picture = self.romeo.processSensation( Sensation( number=self.number, sensationType="D", leftPower=self.leftPower, rightPower=self.rightPower ) ) self.leftPower = sensation.getLeftPower() # set motors in opposite power to turn in place self.rightPower = sensation.getRightPower() # set motors in opposite power to turn in place self.turnTimer = Timer(WalleServer.ACTION_TIME, self.stopTurn) self.turnTimer.start() def stopTurn(self): self.turning_to_object = False self.leftPower = 0.0 # set motors in opposite power to turn in place self.rightPower = 0.0 print "WalleServer.stopTurn: Turn is stopped/cancelled" print "WalleServer.stopTurn: powers to " + str(self.leftPower) + " " + str(self.rightPower) self.hearing.setOn(not self.turning_to_object) self.number = self.number + 1 # test=Sensation.SensationType.Drive sensation, picture = self.romeo.processSensation( Sensation(number=self.number, sensationType="D", leftPower=self.leftPower, rightPower=self.rightPower) ) self.leftPower = sensation.getLeftPower() # set motors in opposite power to turn in place self.rightPower = sensation.getRightPower() print "WalleServer.stopTurn: powers set to " + str(self.leftPower) + " " + str(self.rightPower) # def stopCalibrating(self): # self.calibrating=False # print "WalleServer.stopCalibrating: Calibrating mode is stopped/cancelled" def add_radian(self, original_radian, added_radian): result = original_radian + added_radian if result > math.pi: return -math.pi + (result - math.pi) if result < -math.pi: return math.pi - (result - math.pi) return result def getPower(self): leftPower = 0.0 # set motor in opposite power to turn in place rightPower = 0.0 if math.fabs(self.observation_angle - self.azimuth) > WalleServer.TURN_ACCURACYFACTOR: power = (self.observation_angle - self.azimuth) / WalleServer.FULL_TURN_FACTOR if power > 1.0: power = 1.0 if power < -1.0: power = -1.0 if math.fabs(power) < Romeo.MINPOWER: power = 0.0 leftPower = power # set motorn in opposite power to turn in place rightPower = -power if math.fabs(leftPower) < Romeo.MINPOWER or math.fabs(rightPower) < Romeo.MINPOWER: leftPower = 0.0 # set motors in opposite power to turn in place rightPower = 0.0 # test system has so little power, that we must run it at full speed # if leftPower > Romeo.MINPOWER: # leftPower = 1.0 # set motorn in opposite pover to turn in place # rightPower = -1.0 # elif leftPower < -Romeo.MINPOWER: # leftPower = -1.0 # set motorn in opposite pover to turn in place # rightPower = 1.0 return leftPower, rightPower
from TCPServer import TCPServer if __name__ == "__main__": server = TCPServer() server.start()
def main(): tcpserver = TCPServer('localhost', 8000)
def startServer(self): self.serverNotifier = self.ServerNotifier(self) self.server = TCPServer(self.serverPort, self.serverNotifier) assert self.server.start() == True self.serverRunning = True return True
from TCPServer import TCPServer if __name__ == '__main__': t = TCPServer("127.0.0.1", 9001) t.start()
def __init__(self, src_id, host, port, vc, sock, snd, log, stats, config): #self.logging = logging self.src_id = src_id self.config = config self.host = host self.port = port self.sock = sock self.vc = vc self.log = log self.dups = set() self.sem_limbo = Semaphore() self.snd = snd self.d_stats = stats self.d_stats['count_ack'] = 0 self.d_stats['count_nack'] = 0 self.d_stats['count_dup'] = 0 self.d_stats[ 'tvop'] = 0 # stands for, The Virtue Of Patience, and counts the number of ops "recovered" it waiting time. # But it really doesnt because is not counting properly. self.d_stats['count_missing'] = 0 self.d_stats['count_recovery'] = 0 self.d_stats['count_received'] = 0 self.d_stats["count_limbo"] = 0 self.d_stats["count_fp"] = 0 self.d_stats["count_A3"] = 0 self.d_stats["already_in_limbo"] = 0 self.d_stats["already_in_rer"] = 0 # Dict to store missing operations for RER to wait self.rer = dict() self.wt = float(self.config['rer']['wt']) self.wt_iter = float( self.config['rer'] ['wtIter']) # If 0, it with eat to many resources (now waits ~1ms) # Limbo HeartBeat self.hb = float(self.config['limbo']['hb']) # Received messages self.q_rcv = Queue() # Messages with dependencies to be fulfilled self.l_limbo = list() # Messages ready to be used by the application self.q_deliv = Queue() self.rcv_thread = Thread(target=self.worker) self.rcv_thread.daemon = True self.rcv_thread.start() self.rer_thread = Thread(target=self.rer_worker) self.rer_thread.daemon = True self.rer_thread.start() self.processer_thread = Thread(target=self.checker) self.processer_thread.daemon = True self.processer_thread.start() self.processer_thread = Thread(target=self.limbo_hb) self.processer_thread.daemon = True self.processer_thread.start() # Only for TCP if config['default']['SocketType'] == 'tcp': self.server = TCPServer(config['Server']['ListeningToAddress'], int(config['Server']['ListeningToPort']), max_threads=16, stats=stats, config=config, queue=self.q_rcv, whoami='client') self.server_thread = Thread(target=self.server.serve_forever) self.d_stats['ms_conns'] = self.server.conns self.server_thread.daemon = True self.server_thread.start() self.d_stats['l_limbo'] = self.l_limbo self.d_stats['log'] = self.log self.d_stats['last_vc_seen'] = None