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
