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 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, 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 __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, 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)