def __init__(self, client):
"""
\brief Initialise the server and stock the file and address of the
client.
"""
AbstractServer.__init__(self)
self._file = client[0]
self._addr = client[1]
def __init__(self, addr_input, addr_output):
AbstractServer.__init__(self)
shm_in = shm()
shm_out = shm()
self._receiver = Receiver(addr_input, shm_in)
self._handler = FilterHandler(shm_in, shm_out)
self._emitter = Listener(addr_output, Emitter(shm_out))
def __init__(self, addr_input, addr_output):
AbstractServer.__init__(self)
shm_in = shm()
shm_out = shm()
self._receiver = Receiver(addr_input, shm_in)
self._handler = FilterHandler(shm_in, shm_out)
self._emitter = Listener(addr_output, Emitter(shm_out))
def start(self):
time.sleep(5) # Wait for the serial to be ready
for s in [
# self._accel_handler,
# self._gyro_handler,
# self._compass_handler,
self._handler,
self._emitter]:
s.start()
AbstractServer.start(self)
def __init__(self, input_shm, output_shm):
AbstractServer.__init__(self)
self._in_shm = input_shm
self._out_shm = output_shm
self._time = None
self.pos = [Histo(1) for _ in range(3)]
self.ang = [Histo(10) for _ in range(3)]
self.acc = [Histo(10) for _ in range(3)]
self.gyr = [Histo(50) for _ in range(3)]
self.com = [Histo(10) for _ in range(3)]
def start(self):
time.sleep(5) # Wait for the serial to be ready
for s in [
# self._accel_handler,
# self._gyro_handler,
# self._compass_handler,
self._handler,
self._emitter
]:
s.start()
AbstractServer.start(self)
def __init__(self, input_shm, output_shm):
AbstractServer.__init__(self)
self._in_shm = input_shm
self._out_shm = output_shm
self._time = None
self.pos = [Histo(1) for _ in range(3)]
self.ang = [Histo(10) for _ in range(3)]
self.acc = [Histo(10) for _ in range(3)]
self.gyr = [Histo(50) for _ in range(3)]
self.com = [Histo(10) for _ in range(3)]
def __init__(self, name, request, transformation, shm_serial, shm):
AbstractServer.__init__(self)
self._request = request
self._transformation = transformation
self._shm_serial = shm_serial
self._shm = shm
self._name = name
self._calibrated = False
self._gyr_avg = [0, 0, 0]
self._acc_avg = [0, 0, 0]
self._avg_size = 500
self._avg_cur = 0
def __init__(self, name, request, transformation, shm_serial, shm):
AbstractServer.__init__(self)
self._request = request
self._transformation = transformation
self._shm_serial = shm_serial
self._shm = shm
self._name = name
self._calibrated = False
self._gyr_avg = [0, 0, 0]
self._acc_avg = [0, 0, 0]
self._avg_size = 500
self._avg_cur = 0
def start(self):
if os.path.exists(self._addr):
try:
os.remove(self._addr)
except OSError:
raise
try:
self._socket.bind(self._addr)
self._socket.listen(5)
except socket.error:
self._socket.close()
raise
except OSError:
self._socket.close()
raise
AbstractServer.start(self)
def start(self):
if os.path.exists(self._addr):
try:
os.remove(self._addr)
except OSError:
raise
try:
self._socket.bind(self._addr)
self._socket.listen(5)
except socket.error:
self._socket.close()
raise
except OSError:
self._socket.close()
raise
AbstractServer.start(self)
def __init__(self, addr_input, addr_output):
AbstractServer.__init__(self)
# Offset en bits
# gyr_offset_x = 4.18973187447
# gyr_offset_y = -7.3076830588
# gyr_offset_z = 14.5367319947
acc_scale = 1.0 # bits -> mg -> g
gyr_scale = math.pi / 180.0 * 8.75 / 1000 # bits -> deg -> rad
tr_accel = lambda bits, avg: (
(bits[0] - avg[0]) * 0.00376390 * acc_scale,
(bits[1] - avg[1]) * 0.00376009 * acc_scale,
(bits[2] - avg[2]) * 0.00349265 * acc_scale + 1)
tr_gyro = lambda bits, avg: (
(bits[0] - avg[0]) * gyr_scale,
(bits[1] - avg[1]) * gyr_scale,
(bits[2] - avg[2]) * gyr_scale)
tr_compass = lambda bits: (
0.019292 * (bits[0] - 50.097),
0.019780 * (bits[1] + 313.964),
0.018400 * (bits[2] - 197.500))
transformation = lambda bits, a_avg, g_avg: (
tr_accel(bits[0:3], a_avg) +
tr_gyro(bits[3:6], g_avg) +
tr_compass(bits[6:9]))
shm_data = shm()
# shm_accel = shm()
# shm_gyro = shm()
# shm_compass = shm()
shm_serial = shm(serial.Serial(addr_input, 115200, timeout=0))
self._handler = SerialHandler('R', 'r', transformation, shm_serial, shm_data)
# self._accel_handler = SerialHandler('A', 'a', tr_accel, shm_serial, shm_accel)
# self._gyro_handler = SerialHandler('G', 'g', tr_gyro, shm_serial, shm_gyro)
# self._compass_handler = SerialHandler('C', 'c', tr_compass, shm_serial, shm_compass)
self._emitter = Listener(addr_output,
Emitter(shm_data)) #shm_accel, shm_gyro, shm_compass))
def __init__(self, addr_input, addr_output):
AbstractServer.__init__(self)
# Offset en bits
# gyr_offset_x = 4.18973187447
# gyr_offset_y = -7.3076830588
# gyr_offset_z = 14.5367319947
acc_scale = 1.0 # bits -> mg -> g
gyr_scale = math.pi / 180.0 * 8.75 / 1000 # bits -> deg -> rad
tr_accel = lambda bits, avg: (
(bits[0] - avg[0]) * 0.00376390 * acc_scale,
(bits[1] - avg[1]) * 0.00376009 * acc_scale,
(bits[2] - avg[2]) * 0.00349265 * acc_scale + 1)
tr_gyro = lambda bits, avg: ((bits[0] - avg[0]) * gyr_scale,
(bits[1] - avg[1]) * gyr_scale,
(bits[2] - avg[2]) * gyr_scale)
tr_compass = lambda bits: (0.019292 * (bits[0] - 50.097), 0.019780 *
(bits[1] + 313.964), 0.018400 *
(bits[2] - 197.500))
transformation = lambda bits, a_avg, g_avg: (tr_accel(
bits[0:3], a_avg) + tr_gyro(bits[3:6], g_avg) + tr_compass(bits[6:9
]))
shm_data = shm()
# shm_accel = shm()
# shm_gyro = shm()
# shm_compass = shm()
shm_serial = shm(serial.Serial(addr_input, 115200, timeout=0))
self._handler = SerialHandler('R', 'r', transformation, shm_serial,
shm_data)
# self._accel_handler = SerialHandler('A', 'a', tr_accel, shm_serial, shm_accel)
# self._gyro_handler = SerialHandler('G', 'g', tr_gyro, shm_serial, shm_gyro)
# self._compass_handler = SerialHandler('C', 'c', tr_compass, shm_serial, shm_compass)
self._emitter = Listener(
addr_output,
Emitter(shm_data)) #shm_accel, shm_gyro, shm_compass))
def __init__(self, addr, handler):
# TODO let chose the protocol and the type of the socket to use
# TODO let chose the address more efficiently (filename of a socket or IP+PORT)
# TODO Do some test on the arguments used
"""
\brief Initialise the server to listen connexion on a socket.
\param addr Address where the socket is created
\param handler Class inherited by Handler class used to communicate
with new clients.
The socket is on the UNIX domain using the TCP protocol.
Try to bind this socket to the given address. If a file `addr` already
exists, try to remove it before binding.
Could throw OSError or socket.error exception.
During the run of the listener, when a new client is connected, create
a new instance of `clientServer` and start it immedialty.
"""
AbstractServer.__init__(self)
self._addr = addr
self._socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self._clients = []
self._handler = handler
def __init__(self, addr, handler):
# TODO let chose the protocol and the type of the socket to use
# TODO let chose the address more efficiently (filename of a socket or IP+PORT)
# TODO Do some test on the arguments used
"""
\brief Initialise the server to listen connexion on a socket.
\param addr Address where the socket is created
\param handler Class inherited by Handler class used to communicate
with new clients.
The socket is on the UNIX domain using the TCP protocol.
Try to bind this socket to the given address. If a file `addr` already
exists, try to remove it before binding.
Could throw OSError or socket.error exception.
During the run of the listener, when a new client is connected, create
a new instance of `clientServer` and start it immedialty.
"""
AbstractServer.__init__(self)
self._addr = addr
self._socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self._clients = []
self._handler = handler
def __init__(self, input_queue):
AbstractServer.__init__(self)
self._input_queue = input_queue
# Init plotlib
self.retrace = 0.1 # Temps en secondes, retrace le graphique à chaque retrace millisecondes
# On définit les paramètres du graphique; une seule figure. Le programme ouvrira une fenêtre différente pour chaque courbe.
fig = pylab.figure('Figure')
self.manager = pylab.get_current_fig_manager()
# Initialise quelques variables
self.time = 0.0 # Temps actuel
self.delta_t = 0.1 # Pas de temps
#De même que les tableaux, vecteurs temps et valeur de fonction pour graphique
self.temps = []
self.valeur = []
# On crée le graphique
self.courbe = pylab.plot(self.temps, self.valeur)
# Définit le titre et xlabel
self.titre = pylab.title("X en fonction du temps")
self.etiquette = pylab.xlabel("Retrace %f " % (self.time))
def start(self):
self.manager.show()
AbstractServer.start(self)
def __init__(self, addr_input):
AbstractServer.__init__(self)
queue_in = Queue()
self._receiver = Receiver(addr_input, queue_in)
self._handler = PlotHandler(queue_in)
def __init__(self, addr_input, addr_output):
AbstractServer.__init__(self)
queue_in = Queue()
self._receiver = Receiver(addr_input, queue_in)
self._emitter = Emitter(queue_in)(addr_output, True)
def start(self):
self._receiver.start()
self._handler.start()
self._emitter.start()
AbstractServer.start(self)
def start(self):
self._receiver.start()
self._handler.start()
self._emitter.start()
AbstractServer.start(self)
def __init__(self, addr_input):
AbstractServer.__init__(self)
queue_in = Queue()
self._receiver = Receiver(addr_input, queue_in)
self._handler = PlotHandler(queue_in)
def __init__(self, addr_input, addr_output):
AbstractServer.__init__(self)
queue_in = Queue()
self._receiver = Receiver(addr_input, queue_in)
self._emitter = Emitter(queue_in)(addr_output, True)
