def get_answer(self, socket): answer_len = socket.myreceive(2) # answer_len = int.from_bytes(answer_len, self.endian) answer_len = struct.unpack('!H', answer_len)[0] Log.log(5, 'answer len is {}'.format(answer_len)) answer = socket.myreceive(answer_len - 2) return answer
def mysend(self, msg): totalsent = 0 while totalsent < len(msg): sent = self.sock.send(msg[totalsent:]) if sent == 0: raise RuntimeError("socket connection broken") totalsent = totalsent + sent Log.log(5, 'sent msg: {}'.format(msg)) return totalsent
def __init__(self, port, server_ip, client, timeout=3): self.__port = port Log.log(1, 'pi server thread, port is {}'.format(port)) self.__server_ip = server_ip self.__client = client self.__timeout = timeout self.__socket = MySocket() self.__socket.bind(port) Log.log(0, 'binded on port {}'.format(port)) self.__socket.listen(2) self.__stopped = threading.Event() self.__server_thread = threading.Thread(target=self.main, name='pi_server_t')
def main(self): while not self.__registered.isSet() and not self.__stopped.isSet(): self.register_on_server() if self.__registered.isSet(): break self.__stopped.wait(self.__timeout) self.__stopped.wait(self.__timeout) while not self.__stopped.is_set(): for device in self.__devices: if type(device) is Thermometer: temp = device.getTemp() Log.log(4, 'temp is {}'.format(temp)) self.send_float_val(device.getKey(), temp) Log.log(1, 'waiting for stop') self.__stopped.wait(self.__timeout)
def __createDevicesList(self, devs_file_path): with open(devs_file_path, 'r') as devices_file: lines = devices_file.readlines() dev_key = 0 current_line = 0 for line in lines: current_line += 1 try: self.__devices.append(initialize.addDevice(line, dev_key)) dev_key += 1 except KeyError as error: Log.log( 1, 'unresolved device code {} at line {}'.format( error, current_line)) except ValueError as error: Log.log( 1, '{} at line {}: {}'.format(devs_file_path, current_line, error))
def send_float_val(self, dev_key, val): socket = MySocket() socket.connect(self.__server_ip, self.__port) Log.log(1, 'connected to server') msg = ValMsg.generate_float_val_msg(val, self.__id, dev_key) try: socket.mysend(msg) answer = self.get_answer(socket) Log.log( 2, 'reveived msg {}, msg type is {}'.format(answer, answer[0])) msg_type = MsgType.to_msg_type(struct.pack('B', answer[0])) if msg_type == MsgType.ack: Log.log(4, 'successfully sent value') elif msg_type == MsgType.nack: Log.log(4, 'Failed to send val') else: Log.log( 3, 'received msg_type {} when expecting ack/nack'.format( msg_type)) raise RuntimeError('unresolved msg_type received') except RuntimeError as e: Log.log( 0, 'Failed to send value {}: {} ... closing connection'.format( val, e)) socket.close()
def stop(self): self.__stopped.set() self.__main_thread.join() Log.log(0, 'client main thread joined')
def register_on_server(self): socket = MySocket() socket.connect(self.__server_ip, self.__port) Log.log(1, "connected to server") msg = (3).to_bytes(2, self.endian) msg += MsgType.reg.value try: socket.mysend(msg) answer = self.get_answer(socket) Log.log( 2, "received msg {}, msg_type is {}".format(answer, answer[0])) # msg_type = MsgType.to_msg_type(answer[0].to_bytes(1, self.endian)) msg_type = MsgType.to_msg_type(struct.pack('B', answer[0])) if msg_type == MsgType.ack: self.__id = struct.unpack('!H', answer[1:3])[0] Log.log(3, 'received id is {}'.format(self.__id)) elif msg_type == MsgType.nack: raise RuntimeError('nack received, reg refused by server') else: # Log.log(3, 'received msg_type {} when expecting ack'.format(msg_type)) raise RuntimeError( 'unresolved msg_type received {}, expecting ack/nack'. format(msg_type)) for device in self.__devices: msg, length = device.generateMsg() msg = struct.pack( '!H', length + 5) + MsgType.dev.value + struct.pack( '!H', self.__id) + msg socket.mysend(msg) answer = self.get_answer(socket) # msg_type = MsgType.to_msg_type(answer[0].to_bytes(1, self.endian)) msg_type = MsgType.to_msg_type(struct.pack('B', answer[0])) if msg_type == MsgType.ack: dev_id = struct.unpack('!H', answer[1:3])[0] Log.log(3, 'device {} successful sent'.format(dev_id)) elif msg_type == MsgType.nack: dev_id = struct.unpack('!H', answer[1:3])[0] Log.log(3, 'failed to send device {}'.format(dev_id)) else: Log.log( 3, 'received msg_type {} when expecting ack'.format( msg_type)) raise RuntimeError('unresolved msg_type received') msg = struct.pack('!H', 5) + MsgType.end.value + struct.pack( '!H', self.__id) socket.mysend(msg) Log.log(2, 'successfully registered on server') socket.close() self.__registered.set() except RuntimeError as e: Log.log(0, 'registering failed: {} ... closing connection'.format(e)) socket.close()
def sigint_handler(signum, frame): Log.log(0, 'ending by SIGINT') client.stop() pi_server.stop() Log.log(0, 'ending') Log.close()
def sigint_handler(signum, frame): Log.log(0, 'ending by SIGINT') client.stop() pi_server.stop() Log.log(0, 'ending') Log.close() signal.signal(signal.SIGINT, sigint_handler) port = 12345 server_ip = '192.168.1.19' rpi_key = 12 # TODO: rpi_key port and ip from file or other better way devices_path = 'devices.conf' log_filepath = 'logs/file.log' Log.init(log_filepath, 5) Log.log(0, 'server parameters: port = {}, ip = {}'.format(port, server_ip)) # TODO: path from file or something client = Client(devices_path, server_ip, port) pi_server = RpiServer(port + 1, server_ip, client) Log.log(0, 'configured {} devices'.format(len(client.getDevices()))) for dev in client.getDevices(): # Log.log(1, dev.__dict__) Log.log(1, dev.str()) client.start_work() pi_server.start()
# try: from .endpoint import Endpoint from .device_types import DevTypeCode from .device_types import DevTypeId from socket import htons import struct from logger.logger import Log GpioEnabled = True try: import RPi.GPIO as gpio except ModuleNotFoundError as e: Log.log(0, 'Failed to import RPi.GPIO: {}'.format(e)) GpioEnabled = False # except SystemError: # from endpoint import Endpoint # from device_types import DevTypeCode # from device_types import DevTypeId class Light(Endpoint): def __init__(self, key, name, pin, zero_triggered=False): super().__init__(key, name) self.__pin = pin self.__zero_triggered = zero_triggered if GpioEnabled: gpio.setmode(gpio.BCM) gpio.setup(pin, gpio.OUT) def turnOn(self): #TODO
def stop(self): self.__stopped.set() self.__server_thread.join() Log.log(1, 'server pi thread joined')
def main(self): Log.log(0, 'pi server is working') while not self.__stopped.isSet(): Log.log(3, 'waiting for connection') self.__socket.set_timeout(1) try: connection, address = self.__socket.accept() except Exception as e: Log.log(0, 'exception when accepting connection {}'.format(e)) continue Log.log(1, 'something connected') client_socket = MySocket(connection) msg = client_socket.get_msg() # Log.log(1, 'msg from server: {}'.format(msg)) msg_type = MsgType.to_msg_type(struct.pack('B', msg[2])) if msg_type == MsgType.setState: dev_id = struct.unpack('!H', msg[3:5])[0] state = struct.unpack('!H', msg[5:7])[0] Log.log(2, 'received set state dev={}, state={}'.format(dev_id, state)) device = self.__client.getDevice(dev_id) device.setState(state) else: Log.log(1, 'received bad msg type={} (expected setState)'.format(struct.pack('B', msg[0])))
def get_msg(self): msg_len = self.myreceive(2) unpacked_len = struct.unpack('!H', msg_len)[0] Log.log(3, 'received msg len is {}'.format(unpacked_len)) msg = self.myreceive(unpacked_len - 2) return msg_len + msg