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
