def __init__(self):
log.info('__init__')
self.__cmd_run = True
self.flag_set_com = True
self.flag_set_baud = True
self.flag_set_current_dis = True
self.flag_set_bat_name = True
self.port = None
self.baud = None
self.discharge_current = None
self.battery_name = None
self.class_serial_start = None
self.thread_for_serial = None
self.db_conn = None
self.db_cursor = None
self.db_name = None
self.start = None
self.stop = None
self.volt = None
self.flag_end = False
def run(self):
self.db_conn, self.db_cursor = db.init_db(self.db_name)
log.info('Thread was run')
while self._running:
try:
data = self.serial_port.readline()
except Exception as err:
log.error('Can not read from port {}'.format(err))
else:
try:
data = (data.decode('ascii')).strip()
except Exception as err:
log.error('Can not decode in "ascii" {}'.format(err))
else:
if not self._pause:
# print('not pause')
if self._print:
print('{} {}'.format(datetime.now(), data))
self.__handler(data)
if 'V' in data:
if not db.insert_into_db(
self.db_cursor, time.time(),
datetime.now(), int(data.split('V')[1])):
print('Can not insert in db {} {} {}'.format(
time.time(), datetime.now(),
int(data.split('V')[1])))
sys.exit(0)
if not db.commit_changes(self.db_conn):
print('Can not commit')
sys.exit(0)
def commit_changes(conn):
# Make the changes to the database persistent
try:
conn.commit()
except Exception as err:
log.error(err)
return False
else:
log.info('Commit: successfully')
return True
def disconnect_from_port(self):
try:
self.serial_port.close()
except Exception as err:
print('Could not disconnect from port {}'.format(self.port))
log.error(err)
return False
else:
log.info('Disconnect from port: OK')
return True
def send_to_port(self, message):
try:
self.serial_port.write(message)
except Exception as err:
print('Could send {} to port {}'.format(message, self.port))
log.error(err)
return False
else:
log.info('Send {} to port {}: successfully'.format(
message, self.port))
return True
def cmd_run(self):
while self.__cmd_run:
data_cmd = input('Enter command -> ')
log.info('Enter command -> {}'.format(data_cmd))
if data_cmd == 'exit':
self.serial_disconnect()
self.__cmd_run = False
self.stop = time.time()
if self.start:
delta_3600 = (int(self.stop) - int(self.start)) / 3600
print('{} sec'.format(int(self.stop) - int(self.start)))
print('{} hours'.format(delta_3600))
print('{} mA'.format(delta_3600 *
int(self.discharge_current)))
print('{} V'.format(self.volt))
elif data_cmd == 'start':
self.start = time.time()
self.stop = None
self.thread_for_serial._pause = False
elif data_cmd == 'stop':
self.stop = time.time()
self.thread_for_serial._pause = True
elif data_cmd == 'stat':
if self.start and self.stop is None:
delta_3600 = (int(time.time()) - int(self.start)) / 3600
print('{} sec'.format(int(time.time()) - int(self.start)))
print('{} hours'.format(delta_3600))
print('{} mA'.format(delta_3600 *
int(self.discharge_current)))
print('{} V'.format(self.volt))
elif self.start and self.stop:
delta_3600 = (int(self.stop) - int(self.start)) / 3600
print('{} sec'.format(int(self.stop) - int(self.start)))
print('{} hours'.format(delta_3600))
print('{} mA'.format(delta_3600 *
int(self.discharge_current)))
print('{} V'.format(self.volt))
else:
print('Measurement not started')
elif data_cmd == 'read_db':
db.select_from_db(self.db_cursor,
name_table_in_db='battery_data')
elif data_cmd == 'start print':
self.thread_for_serial._print = True
elif data_cmd == 'stop print':
self.thread_for_serial._print = False
elif data_cmd == 'capacity':
data = db.select_from_db(self.db_cursor,
name_table_in_db='battery_data',
param='volt')
if not data:
print('Can not select from table <battery_data>')
def serial_connect(self):
self.class_serial_start = SerialStart(port=self.port, baud=self.baud)
if not self.class_serial_start.connect_to_port():
print('Can not connect to {}'.format(self.port))
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
self.thread_for_serial = Thread4Serial(
self.call_back_from_serial, self.class_serial_start.serial_port,
self.db_name)
self.thread_for_serial.go_go()
def insert_into_head_data(cursor, bat_name, dis, in_sec, in_date):
try:
cursor.execute("INSERT INTO head_data ("
"battery_name, "
"discharge_current, "
"start_at_in_sec, "
"start_at_in_date) VALUES(?, ?, ?, ?)", (bat_name, str(dis), in_sec, in_date))
except Exception as err:
log.error(err)
return False
else:
log.info('Insert in table <head_data> {} {} {} {}: successfully'.format(bat_name, str(dis), in_sec, in_date))
return True
def create_table_in_db(cursor):
# Execute a command: this creates a new table
try:
cursor.execute("CREATE TABLE battery_data ("
"id INTEGER PRIMARY KEY AUTOINCREMENT, "
"time_sec timestamp, "
"time_in_date timestamp, "
"volt int);")
except Exception as err:
log.error(err)
return False
else:
log.info('Create table <battery_data>: successfully')
return True
def create_table_head_data_in_db(cursor):
# Execute a command: this creates a new table
try:
cursor.execute("CREATE TABLE head_data ("
"battery_name varchar, "
"discharge_current int, "
"start_at_in_sec timestamp, "
"start_at_in_date timestamp);")
except Exception as err:
log.error(err)
return False
else:
log.info('Create table <head_data>: successfully')
return True
def connect_to_port(self):
log.info('Try connect to serial port {}'.format(self.port))
try:
self.serial_port = serial.Serial(port=self.port,
baudrate=self.baud,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS)
except Exception as err:
print('Could not open port {}'.format(self.port))
log.error(err)
return False
else:
log.info('Connect to Serial-port: OK')
return True
def insert_into_db(cursor, in_sec, in_date, volt):
try:
cursor.execute("INSERT INTO battery_data ("
"time_sec, "
"time_in_date, "
"volt) VALUES(?, ?, ?)", (in_sec, in_date, volt))
except Exception as err:
log.error(err)
return False
else:
log.info("INSERT INTO battery_data ("
"time_sec, "
"time_in_date, "
"volt) VALUES({}, {}, {})".format(in_sec, in_date, volt))
return True
def init_db(name_db):
try:
conn = sqlite3.connect('{}.db'.format(name_db)) # или :memory: чтобы сохранить в RAM
except Exception as err:
print(err)
log.error(err)
return False, False
else:
log.info('Init db <{}>: successfully'.format(name_db))
try:
cursor = conn.cursor()
except Exception as err:
print(err)
log.error(err)
return False, False
else:
log.info('Create cursor for db <{}>: successfully'.format(name_db))
return conn, cursor
def set_baud(self):
while self.flag_set_baud:
log.info('Enter the baud')
data = input('Enter the baud: ')
if data.isalpha():
log.info(
'Uncorrect baud !\nYou may enter only digits !\nTry again')
elif data.isdigit():
self.baud = data
log.info('User entered {}'.format(self.baud))
self.flag_set_baud = False
else:
log.info('Somthing was wrong !\nTry again')
def set_com_port(self):
while self.flag_set_com:
log.info('Enter the com port')
data = input('Enter the com port: ')
if data.isalpha():
log.info(
'Uncorrect com port number !\nYou may enter only digits !\nTry again'
)
elif data.isdigit():
self.port = 'COM{}'.format(data)
log.info('User entered {}'.format(self.port))
self.flag_set_com = False
else:
log.info('Something was wrong !\nTry again')
def set_current_dis(self):
while self.flag_set_current_dis:
log.info('Enter discharge current')
data = input('Enter discharge current: ')
if data.isalpha():
log.info(
'Uncorrect discharge current !\nYou may enter only digits !\nTry again'
)
elif data.isdigit():
self.discharge_current = data
log.info('Discharge current is {}'.format(
self.discharge_current))
self.flag_set_current_dis = False
else:
log.info('Somthing was wrong !\nTry again')
def select_from_db(cursor, name_table_in_db, param='*'):
try:
cursor.execute("SELECT {} FROM {};".format(param, name_table_in_db))
# cursor.execute("SELECT {} FROM {} WHERE volt > 2400;".format(param, name_table_in_db))
except Exception as err:
print(err)
log.error(err)
return False
else:
try:
data = cursor.fetchall()
except Exception as err:
print(err)
log.error(err)
return False
else:
log.info('Select {} from table {}: successfully'.format(param, name_table_in_db))
print(len(data))
# print(data)
# for line in data:
# print(line)
return data
def set_bat_name(self):
log.info('Enter the battery name')
while self.flag_set_bat_name:
data = input('Enter the battery name: ')
if data:
self.battery_name = data
log.info('Battery name is {}'.format(self.battery_name))
self.flag_set_bat_name = False
else:
log.info('Somthing was wrong !\nTry again')
def db_head_data(self):
if not db.insert_into_head_data(self.db_cursor, self.battery_name,
self.discharge_current, time.time(),
datetime.now()):
print('Can not insert in db {} {} {} {}'.format(
self.battery_name, self.discharge_current, time.time(),
datetime.now()))
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
if not db.select_from_db(self.db_cursor, name_table_in_db='head_data'):
print('Can not select from table <head_data>')
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
if not db.commit_changes(self.db_conn):
print('Can not commit')
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
def go_go(self):
log.info('Run')
self._running = True
self.start()
def terminate(self):
log.info('Terminate')
self._running = False
import serial
import time
from datetime import datetime
from Drivers.log_settings import log
from Drivers.lib_serial import SerialStart
from Drivers.lib_serial import Thread4Serial
from Drivers import db
from Drivers import build_curves
from multiprocessing import Process
__author__ = "PyARKio"
__version__ = "1.0.1"
__email__ = "*****@*****.**"
__status__ = "Production"
log.info('Starting of check_battery_capacity')
port = 'COM13'
baud = 38400
class CheckBatteryCapacity(object):
def __init__(self):
log.info('__init__')
self.__cmd_run = True
self.flag_set_com = True
self.flag_set_baud = True
self.flag_set_current_dis = True
self.flag_set_bat_name = True
def db_init(self):
self.db_name = '{} {}'.format(self.battery_name, time.time())
log.info('DB name: {}'.format(self.db_name))
self.db_conn, self.db_cursor = db.init_db(self.db_name)
log.info('DB_conn: {}\nDB_cursor: {}'.format(self.db_conn,
self.db_cursor))
if self.db_conn and self.db_cursor:
if not db.create_table_head_data_in_db(self.db_cursor):
print('Can not create table <head_data>')
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
if not db.create_table_in_db(self.db_cursor):
print('Can not create table <battery_data>')
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
if not db.commit_changes(self.db_conn):
print('Can not commit')
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
else:
print('Can not init db')
self.serial_disconnect()
log.info('SYSTEM STOP')
sys.exit(0)
