def v8_call_get_konstanty(c: sqlite3.Cursor, adrhex: int):
k14, k58 = v8_create_get_konstanty(adrhex)
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)",
(datetime.now(), conv_hex_to_str(k14),
APP_TYP_DOTAZU.V8_KONSTANTY.value))
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)",
(datetime.now(), conv_hex_to_str(k58),
APP_TYP_DOTAZU.V8_KONSTANTY.value))
def v8_process_konstanty(cur: sqlite3.Cursor, ddata: bytes, od: bytes):
data = ddata[6:-1]
r = data[3:]
k1 = (r[0] + r[1] * 256 + r[2] * 65536) / 1000
k2 = (r[3] + r[4] * 256 + r[5] * 65536) / 1000
k3 = (r[6] + r[7] * 256 + r[8] * 65536) / 1000
k4 = (r[9] + r[10] * 256 + r[11] * 65536) / 1000
p = 1
if data[1] == 0x0C:
p = 5
adr = conv_hex_to_str(od)
cur.execute(
"update zapojeni_vstupy set konst=? where cislo=? and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)",
(k1, p, adr))
cur.execute(
"update zapojeni_vstupy set konst=? where cislo=? and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)",
(k2, (p + 1), adr))
cur.execute(
"update zapojeni_vstupy set konst=? where cislo=? and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)",
(k3, (p + 2), adr))
cur.execute(
"update zapojeni_vstupy set konst=? where cislo=? and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)",
(k4, (p + 3), adr))
def v8_call_live_vykon(c: sqlite3.Cursor, adrhex: int):
#ff a5 20 3f 02 fa 12 00 01 ed
hx = telegram_create(adrhex, Telegram.BEZNY, b'\x12\x00\x01')
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)",
(datetime.now(), conv_hex_to_str(hx),
APP_TYP_DOTAZU.V8_LIVE_VYKON.value))
def v8_call_live_prace(c: sqlite3.Cursor, adrhex: int):
#ff a5 20 3f 02 fa 10 90 00 60
hx = telegram_create(adrhex, Telegram.BEZNY, b'\x10\x90\x00')
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)",
datetime.now(),
(conv_hex_to_str(hx), APP_TYP_DOTAZU.V8_LIVE_PRACE.value))
def v8_call_zaznam_historie(c: sqlite3.Cursor, pro: int, cislo_zaznamu: int,
ityp_dotazu: int):
hx = telegram_create(
pro, Telegram.BEZNY, b'\x52' +
int_to_bytes_data(cislo_zaznamu * 18 + 2304)) #cti zaznamy 18B
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)",
(datetime.now(), conv_hex_to_str(hx), ityp_dotazu))
def hmp_process_history_posl_ulozena_pozice(cur: sqlite3.Cursor, data:bytes, od:bytes) :
try:
dd = data[9:11]
pos = int(dd[1]) * 256 + int(dd[0])
s_adr = conv_hex_to_str(od)
cur.execute("update zapojeni set hw_pozice_zaznamu=? where adr_zarizeni=?", (pos, s_adr,))
except Exception as e:
print("hmp_process_history_posl_ulozena_pozice(): Ex: {}".format(str(e)), flush=True)
pass
def hmp_process_stoupaci_konstanta(cur: sqlite3.Cursor, data:bytes, od:bytes) :
try:
dd = data[9:-1]
konst = bytes_to_int_reverse(dd)
s_adr = conv_hex_to_str(od)
cur.execute("update zapojeni set stoupkonst=? where adr_zarizeni=?", (konst, s_adr,))
except Exception as e:
print("hmp_process_techmax(): Ex: {}".format(str(e)), flush=True)
pass
def hmp_process_posun_regulacni_krivka(cur: sqlite3.Cursor, data:bytes, od:bytes) :
try:
dd = data[9:-1]
posun = bytes_to_int_reverse(dd)
s_adr = conv_hex_to_str(od)
cur.execute("update zapojeni set posregkriv=? where adr_zarizeni=?", (posun, s_adr,))
except Exception as e:
print("hmp_process_techmax(): Ex: {}".format(str(e)), flush=True)
pass
def hmp_process_konstanty(cur: sqlite3.Cursor, data:bytes, od:bytes) :
r = data[9:-1]
k1 = (r[0] + r[1]*256 + r[2]*65536)/1000
k2 = (r[3] + r[4]*256 + r[5]*65536)/1000
k3 = (r[6] + r[7]*256 + r[8]*65536)/1000
k4 = (r[9] + r[10]*256 + r[11]*65536)/1000
adr = conv_hex_to_str(od)
cur.execute("update zapojeni_vstupy set konst=? where cislo=1 and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)", (k1, adr))
cur.execute("update zapojeni_vstupy set konst=? where cislo=2 and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)", (k2, adr))
cur.execute("update zapojeni_vstupy set konst=? where cislo=3 and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)", (k3, adr))
cur.execute("update zapojeni_vstupy set konst=? where cislo=4 and zapojeni_id in (select id from zapojeni where adr_zarizeni=?)", (k4, adr))
def hmp_process_datumcas(cur: sqlite3.Cursor, data:bytes, od:bytes) :
r = data[9:-1]
s_adr = conv_hex_to_str(od)
sec = str(r[1]) + str(r[0])
min = str(r[3]) + str(r[2])
hod = str(r[5]) + str(r[4])
den = str(r[7]) + str(r[6])
mes = str(r[9]) + str(r[8])
rok = "20" + str(r[11]) + str(r[10])
cur.execute("update zapojeni set cas=? where adr_zarizeni=?", ("{}.{}.{} {}:{}:{}".format(den, mes,rok, hod, min, sec), s_adr,))
def v8_process_live_vykon(cur: sqlite3.Cursor, data: bytes, od: bytes):
data = data[6:-1]
r = data[3:]
s_adr = conv_hex_to_str(od)
cur.execute(
"""select (select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=1) k1,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=2) k2,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=3) k3,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=4) k4,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=5) k5,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=6) k6,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=7) k7,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=8) k8""",
(s_adr, s_adr, s_adr, s_adr, s_adr, s_adr, s_adr, s_adr))
k = cur.fetchone()
for i in range(0, 8):
try:
x = i * 2
cas = bytes_to_int_reverse(r[x:x + 2])
if cas > 0 and cas <= 32767:
cas = int(round(cas / 1000, 0))
elif cas > 32767 and cas <= 65280:
cas = int(round((cas - 32768) + 32.767, 0))
else:
cas = 0
vykon = 0
if cas > 0 and k[i] != 0:
vykon = 3600 / (cas * k[i])
vykon = round(vykon, 2)
f = cur.execute(
"select 1 from livedata_v8 where adr_zarizeni=? and vstup=? ",
(s_adr, i + 1)).fetchone()
if f != None:
cur.execute(
"update livedata_v8 set cas_imp=?, vykon=?, cas_odecet=? where adr_zarizeni=? and vstup=?",
(cas, vykon, datetime.now(), s_adr, i + 1))
else:
cur.execute(
"insert into livedata_v8(adr_zarizeni, vstup, cas_imp, vykon, prace, cas_odecet) values(?,?,?,?,0,?)",
(s_adr, i + 1, cas, vykon, datetime.now()))
except Exception as e:
print("v8_process_live_vykon(): i: {} Ex: {}".format(
str(i), str(e)),
flush=True)
pass
def v8_process_live_prace(cur: sqlite3.Cursor, data: bytes, od: bytes):
data = data[6:-1]
r = data[3:]
s_adr = conv_hex_to_str(od)
cur.execute(
"""select (select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=1) k1,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=2) k2,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=3) k3,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=4) k4,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=5) k5,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=6) k6,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=7) k7,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.cislo=8) k8""",
(s_adr, s_adr, s_adr, s_adr, s_adr, s_adr, s_adr, s_adr))
k = cur.fetchone()
for i in range(0, 8):
try:
x = i * 2
imp = bytes_to_int_reverse(r[x:x + 2])
try:
prace = imp / k[i]
except:
prace = 0
pass
prace = round(prace, 2)
f = cur.execute(
"select 1 from livedata_v8 where adr_zarizeni=? and vstup=? ",
(s_adr, i + 1)).fetchone()
if f != None:
cur.execute(
"update livedata_v8 set prace=?, cas_odecet=? where adr_zarizeni=? and vstup=?",
(datetime.now(), prace, s_adr, i + 1))
else:
cur.execute(
"insert into livedata_v8(adr_zarizeni, vstup, prace, cas_imp, vykon, cas_odecet) values(?,?,?,0,0,?)",
(s_adr, i + 1, prace, datetime.now()))
except Exception as e:
print("v8_process_live_prace(): i: {} Ex: {}".format(
str(i), str(e)),
flush=True)
pass
def do_main_program(self):
self.running = True
print("do_main_program(): Spoustim sluzbu...", flush=True)
ntf.notify("READY=1")
ntf.notify("STATUS=Inicializuji sluzbu HMP...")
conn = self.get_DB()
c = conn.cursor()
self.sett = {}
for r in c.execute("select param, sval from setting"):
self.sett[r[0]] = r[1]
self.tasks.queue.clear()
self.resp.queue.clear()
c.execute(
"update inprogress set probiha = 0 where akce='NACTENI_STRUKTURY_ZAPOJENI'"
)
c.execute(
"update inprogress set probiha = 0, sval='Služba spuštěna' where akce='HMP_DAEMON'"
)
conn.commit()
self.check_serial_comm()
#spust GSM modul pokud je potreba
try:
if int(self.sett["USE_GSM_MODULE"]) == 1:
self.gsmth = GsmDaemonTask()
self.gsmth.start(
self.sett["GSM_USBINTERFACE"], self.sett["GSM_HW_ADDR"],
self.sett["GSM_SIM_PIN"], self.sett["GSM_APN_NAME"],
self.sett["GSM_APN_USER"], self.sett["GSM_APN_PASS"],
int(self.sett["GSM_WATCHDOG_TIMEINTERVAL"]),
self.sett["GSM_WATCHDOG_PING_SERVER"])
except:
pass
self.tlast = time.time()
self.thKeepAlive = RepeatTimer(15, self.keep_alive) # kontrola co 15s
if int(self.sett["CLOUD_SEND_14H_INTERVAL_SEC"]) > 0:
self.thCloudExportHistory = RepeatTimer(
int(self.sett["CLOUD_SEND_14H_INTERVAL_SEC"]),
self.cloud_export_history)
if int(self.sett["CLOUD_SEND_LIVE_INTERVAL_SEC"]) > 0:
self.thCloudExportLive = RepeatTimer(
int(self.sett["CLOUD_SEND_LIVE_INTERVAL_SEC"]),
self.cloud_export_live)
self.thHistoryDownload = RepeatTimer(
int(self.sett["SERIAL_DOWNLOAD_HISTORY_INTERVAL_SEC"]),
self.download_history) # kontrola co 900s
self.thKonstantyRefresh = RepeatTimer(910, self.reload_konstanty)
self.thClearHistory = RepeatTimer(86400, self.clean_history)
self.clean_history()
self.reload_konstanty()
self.download_history()
while self.running:
try:
#posbirej dotazy na hmp zarizeni a posli je do 485 pouze 5 zaznamu
for q in c.execute(
"select id, prikaz, typ_dotazu, isql, iscmd, iswrite from serial_prikaz where odpoved is null and islock=0 order by id asc limit 8"
).fetchall():
if q[4] == 1: #jedna se o prikaz pro sluzbu, provadi se ihned
if q[1] == "FLUSH_QUEQUE":
with self.tasks.mutex:
self.tasks.queue.clear()
elif q[1] == "RESTART":
with self.tasks.mutex:
self.tasks.queue.clear()
self.running = False
self.restart()
elif q[3] == 1: #jedna se o sql prikaz ten se provadi FIFO
self.tasks.put({
'data': q[1],
'id': q[0],
'typ': q[2],
'sql': 1,
'wr': 0
})
else:
bf = conv_str_hex_in_bytes(q[1])
self.tasks.put({
'data': bf,
'id': q[0],
'typ': q[2],
'sql': 0,
'wr': q[5]
})
c.execute("update serial_prikaz set islock=1 where id=?",
(q[0], ))
conn.commit()
self.check_serial_comm()
ntf.notify("WATCHDOG=1")
while self.resp.qsize() > 0: # odpoved od HMP
rs = self.resp.get()
if rs['sql'] == 1:
c.execute(rs['data'])
c.execute(
"update serial_prikaz set odpoved='sql_done', cas_odpoved=CURRENT_TIMESTAMP where id=?",
(rs['id'], ))
conn.commit()
self.resp.task_done()
continue
#zaznamenej cas kdy naposledy odpovedel
dfrom = telegram_get_from(rs['data'])
try:
if rs['id'] > 0:
self.tlast = time.time()
c.execute(
"update serial_prikaz set odpoved=?, cas_odpoved=CURRENT_TIMESTAMP where id=?",
(
conv_hex_to_str(rs['data']),
rs['id'],
))
conn.commit()
fce = switcher_process(rs['typ'])
fce(c, rs['data'], dfrom)
else: #aktualni bezny datagram spotreba
fce = switcher_process(-1) #vychozi
fce(c, rs['data'], dfrom)
except Exception as e:
print(
"do_main_program()[call]: Ex: {}, Typ: {}, Id: {}, Data: {}"
.format(str(e), rs['typ'], rs['id'],
conv_hex_to_str(rs['data'])),
flush=True)
pass
conn.commit()
self.resp.task_done()
except sqlite3.OperationalError as ex:
ntf.notify("ERRNO=1")
except Exception as e:
print(
"do_main_program()[2]: Ex: {}, Typ: {}, Id: {}, Data: {}".
format(str(e), rs['typ'], rs['id'],
conv_hex_to_str(rs['data'])),
flush=True)
pass
time.sleep(0.1)
conn.close()
#ukonci komunikaci sluzba nebezi
self.sth.running = False
print("do_main_program(): Konec sluzby...", flush=True)
ntf.notify("STOPPING=1")
def hmp_process_history(cur: sqlite3.Cursor, ddata:bytes, od:bytes) :
data = ddata[6:-1]
r = data[3:]
#print("hmp_process_history() : {}".format(conv_hex_to_str(r)))
if r[0] == 0xFF and r[1] == 0xFF and r[2] == 0xFF and r[3] == 0xFF :
return
cas_s = (r[0] & 0x1F) * 2
cas_m = (r[1] & 0x07) << 3 | (r[0] & 0xE0) >> 5
cas_h = (r[1] & 0xF8) >> 3
cas_d = (r[2] & 0x1F)
cas_mes = ((r[3] & 0x01) << 3) | (r[2] & 0xE0) >> 5
cas_rok = (r[3] & 0xFE) >> 1
cas_rok = 2000 + cas_rok
d = datetime(cas_rok,cas_mes,cas_d,cas_h, cas_m, cas_s, tzinfo=timezone.utc)
unixstamp = d.timestamp()
cas14h = ((r[5] & 0x07) * 256 ) + r[4]
cas_tstop = ((r[5] & 0xF8) >> 3) * 30 # cas total stop v sekundach
rs1 = (r[6] & 0x7F) * 10 # cas vypnuti 1.stupne v sekundach 58
rs2 = (r[7] & 0x7F) * 10 # cas vypnuti 2.stupne v sekundach 56
rs3 = (r[8] & 0x7F) * 10 # cas vypnuti 3.stupne v sekundach 54
rs4 = (r[9] & 0x7F) * 10 # cas vypnuti 4.stupne v sekundach 53
rs5 = (r[10] & 0x7F) * 10 # cas vypnuti 5.stupne v sekundach 50
rs6 = (r[11] & 0x7F) * 10 # cas vypnuti 6.stupne v sekundach CF
imp_hl = ((r[13] & 0x0F) * 256) + r[12] # pocet imp HL elektromeru
impl_1p = (r[14] * 256) + ((r[13] & 0xF0)*16) #pocet imp 1P elektromeru
# 00 + bity7 (b8=58 b9=56 b10=54 b11=53) pocet imp 2P elektromeru = 0 prepoctu stejnym vzorcem jak HL, 1P
impl_2p = ((r[9] & 0x80) >> 4) | ((r[8] & 0x80) >> 5) | ((r[7] & 0x80) >> 6) | ((r[6] & 0x80) >> 7)
impl_2p = (impl_2p * 256) + r[15]
ukonc = (r[10] & 0x80) >> 7
istop = (r[11] & 0x80) >> 7
rmax = ((r[17] & 0x3F) * 256) + (r[16] & 0xFF) #regulacni maximum spatne misto se cte !!!! KW W???
s_adr = conv_hex_to_str(od)
kk = cur.execute("""select (select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni=? and cislo=?) k1,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and cislo=?) k2,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and cislo=?) k3""",
(s_adr, 1, s_adr, 2, s_adr, 3)).fetchone()
k1 = kk[0]
k2 = kk[1]
k3 = kk[2]
imp_hl = round(((imp_hl * 4) / k1), 2)
impl_1p = round(((impl_1p * 4) / k2), 2)
impl_2p = round(((impl_2p * 4) / k3), 2)
#cosF se vypocita = cinny/sqrt(cinny^2 + jalovy^2) , cinny = HL, jalovy = 1P
if imp_hl == 0 or impl_1p == 0:
cosF = 0
else:
cosF = round( imp_hl / math.sqrt(imp_hl**2 + impl_1p**2), 2)
aodber = [imp_hl, impl_1p, impl_2p] #odbery za jednotlive vstupy 0, 1, 2
jk = "[{},{},{}]".format(k1, k2,k3)
try:
cur.execute("""insert into historie_data_raw(adr_zarizeni, rok, mesic, den, hh, mm, ss, cas_14h, hmp_tstop,
hmp_cas_vyp_st1, hmp_cas_vyp_st2, hmp_cas_vyp_st3, hmp_cas_vyp_st4, hmp_cas_vyp_st5, hmp_cas_vyp_st6,
ukon_14h_inext, piv_1, piv_2, piv_3, hmp_rmax, hmp_istop, unixstamp, rawdata, k)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
(s_adr,cas_rok, cas_mes, cas_d, cas_h, cas_m, cas_s, cas14h, cas_tstop,
rs1, rs2, rs3, rs4, rs5, rs6, ukonc, imp_hl, impl_1p, impl_2p,rmax, istop, unixstamp, conv_hex_to_str(ddata), jk))
except Exception as e:
print("hmp_process_history(): Ex: {}".format(str(e)), flush=True)
pass
#aktualizuj poradi zaznamu
try:
dd = data[1:3]
pos = int(((int(dd[1]) * 256 + int(dd[0])) - 1536) / 18)
cur.execute("update zapojeni set cislozaznamu=? where adr_zarizeni=?", (pos, s_adr,))
except Exception as e:
#print("hmp_process_history(): Ex: {}".format(str(e)), flush=True)
pass
try:
# v = 2020-10-12 14:35:00+00:00
#>>> v = v - timedelta(minutes=15)
#d = datetime(cas_rok,cas_mes,cas_d,cas_h, cas_m, tzinfo=timezone.utc)
d = d + timedelta(seconds=10) - timedelta(minutes=15) #posun o 15 nazpet
s = int(d.minute / 15) # cislo ctvrthodiny
d = d.replace(minute=0, second=0) #vynuluj minuty
ux = d.timestamp()
ss = ["s1", "s2", "s3", "s4"]
for vstup in [0,1,2]:
try:
vs = vstup + 1
cur.execute("select s1, s2, s3, s4, id from historie where datum=? and adr_zarizeni=? and vstup=?", (ux,s_adr, vs))
r = cur.fetchone()
odber = round(aodber[vstup], 2)
if r:
rid = r[4]
if r[s] is None :
s5v = [r[0], r[1], r[2], r[3]]
s5v[s] = aodber[vstup]
# POZOR TOHLE UPRAVIT /4 JE POUZE PRO KWH JE POTREBA PRIDAT JEDNOTKY Z KTERYCH SE TO PAK BERE ZDA PRUMER NEBO JEN SOUCET
# TO SAME I PRO V8 !!!
s5 = round((int_none(s5v[0]) + int_none(s5v[1]) + int_none(s5v[2]) + int_none(s5v[3]))/4, 2)
q = "update historie set {}=?, s5=?, regmax=?, regtimes_{}=?, cloud_sent=0 where id=?".format(ss[s],ss[s])
cur.execute(q, (odber, s5, rmax, "[{},{},{},{},{},{}]". format(rs1,rs2,rs3,rs4,rs5,rs6), rid))
else :
q = "update historie set {}_dupl= coalesce({}_dupl, '') || ? || ',', cloud_sent=0 where id=?".format(ss[s],ss[s])
cur.execute(q, (odber, rid))
else:
# POZOR TOHLE UPRAVIT /4 JE POUZE PRO KWH JE POTREBA PRIDAT JEDNOTKY Z KTERYCH SE TO PAK BERE ZDA PRUMER NEBO JEN SOUCET
# TO SAME I PRO V8 !!!
s5 = round(odber / 4, 2)
q = "insert into historie(datum, vstup, adr_zarizeni, regmax, {}, s5, cosf, regtimes_{}) values(?, ?, ?, ?, ?, ?, ?, ?)".format(ss[s],ss[s])
cur.execute(q, (ux, vs, s_adr, rmax, odber, s5, cosF, "[{},{},{},{},{},{}]". format(rs1,rs2,rs3,rs4,rs5,rs6)))
except:
pass
except:
pass
return
def v8_process_history(cur: sqlite3.Cursor, ddata: bytes, od: bytes):
data = ddata[6:-1]
r = data[3:]
#print("v8_process_history() : {}".format(conv_hex_to_str(r)))
if r[0] == 0xFF and r[1] == 0xFF and r[2] == 0xFF and r[3] == 0xFF:
return
cas_s = (r[0] & 0x1F) * 2
cas_m = (r[1] & 0x07) << 3 | (r[0] & 0xE0) >> 5
cas_h = (r[1] & 0xF8) >> 3
cas_d = (r[2] & 0x1F)
cas_mes = ((r[3] & 0x01) << 3) | (r[2] & 0xE0) >> 5
cas_rok = (r[3] & 0xFE) >> 1
cas_rok = 2000 + cas_rok
d = datetime(cas_rok,
cas_mes,
cas_d,
cas_h,
cas_m,
cas_s,
tzinfo=timezone.utc)
unixstamp = d.timestamp()
cas14h = ((r[5] & 0x0F) * 256) + r[4] # 84 x3 - delka zaznamu = 900 sekund
v8_sammod = r[5] & 0x80
v8_ukon_14h = r[5] & 0x40
ukon_14h_inext = r[5] & 0x20
# 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
# A5 3F 20 35 C7 52 4E 15 | E0 91 B4 28 84 23 | 35 02 A2 40 20 7C F9 00 64 F3 01 E0 5C 15
vs = []
vs.append(((r[7] & 0x0F) * 256) + r[6]) # pocet impulzu vstup 1
vs.append(((r[7] & 0xF0) * 256) + r[8]) # pocet impulzu vstup 2
vs.append(((r[10] & 0x0F) * 256) + r[9]) # pocet impulzu vstup 3
vs.append(((r[10] & 0xF0) * 256) + r[11]) # pocet impulzu vstup 4
vs.append(((r[13] & 0x0F) * 256) + r[12]) # pocet impulzu vstup 5
vs.append(((r[13] & 0xF0) * 256) + r[14]) # pocet impulzu vstup 6
vs.append(((r[16] & 0x0F) * 256) + r[15]) # pocet impulzu vstup 7
vs.append(((r[16] & 0xF0) * 256) + r[17]) # pocet impulzu vstup 8
#vypocet je identicky jak u HMP
s_adr = conv_hex_to_str(od)
#Hodnota odberu se z impulsu a konstanty vypocita takto
#odber:=4 * 1000 * Pocet_impulsu / Konstanta
dbvstupy = cur.execute(
"select cislo, konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? order by cislo asc",
(s_adr, )).fetchall()
jk = ""
for vstup in dbvstupy:
jk += str(vstup[1]) + ","
if len(jk) > 0:
jk = jk[:-1]
jk = "[" + jk + "]"
last_hw_id = -1
try:
cur.execute(
"""insert into historie_data_raw(adr_zarizeni, rok, mesic, den, hh, mm, ss, piv_1, piv_2, piv_3, piv_4, piv_5, piv_6, piv_7, piv_8, cas_14h, v8_sammod, v8_ukon_14h, ukon_14h_inext, unixstamp, rawdata, k)
values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?, ?,?)""",
(s_adr, cas_rok, cas_mes, cas_d, cas_h, cas_m, cas_s, vs[0], vs[1],
vs[2], vs[3], vs[4], vs[5], vs[6], vs[7], cas14h,
v8_sammod, v8_ukon_14h, ukon_14h_inext, unixstamp,
conv_hex_to_str(ddata), jk))
last_hw_id = cur.lastrowid
except Exception as e:
pass
try:
dd = data[1:3]
pos = int(((int(dd[1]) * 256 + int(dd[0])) - 2304) / 18)
cur.execute("update zapojeni set cislozaznamu=? where adr_zarizeni=?",
(
pos,
s_adr,
))
except Exception as e:
print("v8_process_history(): Ex: {}".format(str(e)), flush=True)
pass
#cosF se vypocita = cinny/sqrt(cinny^2 + jalovy^2) , cinny = HL, jalovy = 1P
cosF = 0
try:
cur.execute(
"select cislo, konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.is_jalovy=1",
(s_adr, ))
jal = cur.fetchone()
cur.execute(
"select cislo, konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and zv.is_cinny=1",
(s_adr, ))
jin = cur.fetchone()
if jal and jin:
imp_jal = round(((vs[jal[0] - 1] * 4) / jal[1]), 2)
imp_cin = round(((vs[jin[0] - 1] * 4) / jin[1]), 2)
if imp_cin == 0:
cosF = 0
else:
cosF = round(imp_cin / math.sqrt(imp_cin**2 + imp_jal**2), 2)
except:
pass
try:
#d = datetime(cas_rok,cas_mes,cas_d,cas_h, cas_m, tzinfo=timezone.utc)
d = d + timedelta(seconds=10) - timedelta(
minutes=15
) # posun o 15 min nazpet + pripocti 10s k datum nektere vychazji 9:59:58
s = int(d.minute / 15) # cislo ctvrthodiny
d = d.replace(minute=0, second=0) #vynuluj minuty
ux = d.timestamp()
ss = ["s1", "s2", "s3", "s4"]
ivs = cis = -1
for vstup in dbvstupy:
try:
cis = vstup[0]
ivs = cis - 1
cur.execute(
"select s1, s2, s3, s4, id from historie where datum=? and adr_zarizeni=? and vstup=?",
(ux, s_adr, cis))
r = cur.fetchone()
odber = round(((vs[ivs] * 4) / vstup[1]), 2)
if r:
rid = r[4]
if r[s] is None: # s - cislo ctvrthodiny
s5v = [r[0], r[1], r[2], r[3]]
s5v[s] = odber
# POZOR TOHLE UPRAVIT /4 JE POUZE PRO KWH JE POTREBA PRIDAT JEDNOTKY Z KTERYCH SE TO PAK BERE ZDA PRUMER NEBO JEN SOUCET
# TO SAME I PRO HMP !!!
s5 = round((int_none(s5v[0]) + int_none(s5v[1]) +
int_none(s5v[2]) + int_none(s5v[3])) / 4,
2)
q = "update historie set {}=?, s5=?, regmax=?, cosf=?, cloud_sent=0 where id=?".format(
ss[s], )
cur.execute(q, (odber, s5, -1, cosF, rid))
else:
q = "update historie set {}_dupl= coalesce({}_dupl, '') || ? || ',', cloud_sent=0 where id=?".format(
ss[s], ss[s])
cur.execute(q, (odber, rid))
else:
# POZOR TOHLE UPRAVIT /4 JE POUZE PRO KWH JE POTREBA PRIDAT JEDNOTKY Z KTERYCH SE TO PAK BERE ZDA PRUMER NEBO JEN SOUCET
# TO SAME I PRO HMP !!!
s5 = round(odber / 4, 2)
q = "insert into historie(datum, vstup, adr_zarizeni, {}, s5, cosf) values(?,?,?, ?,?,?)".format(
ss[s], )
cur.execute(q, (ux, cis, s_adr, odber, s5, cosF))
except Exception as e:
print(
"v8_process_history() foreach: Ex: {} cis: {} ivs: {} vs: {} s: {}"
.format(str(e), cis, ivs, vs, s),
flush=True)
pass
except Exception as e:
print("v8_process_history() FF: Ex: {}".format(str(e)), flush=True)
pass
return
def v8_call_get_history_posl_ulozena_pozice(c: sqlite3.Cursor, adrhex: int):
dt = telegram_create(adrhex, Telegram.BEZNY, b'\x02\x54\x00')
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)",
(datetime.now(), conv_hex_to_str(dt),
APP_TYP_DOTAZU.V8_POSLEDNI_CTENA_POZICE.value))
def hmp_call_get_konstanty(c: sqlite3.Cursor) -> bytes:
hx = hmp_create_get_konstanty()
c.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)", (datetime.now(), conv_hex_to_str(hx), APP_TYP_DOTAZU.HMP_KONSTANTY.value))
def hmp_write_konstanty(cur: sqlite3.Cursor, adr:str):
#povol zapis
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), "FF A5 00 3F 03 19 E1 00 00 F4 2B", APP_TYP_DOTAZU.HMP_ZAPIS.value))
vstupy = cur.execute("SELECT zv.cislo, zv.konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni=? order by cislozaznamu ASC ", (adr,)).fetchall()
for r in vstupy:
cis = (r[0] - 1) * 3
konst = r[1]
hx = telegram_create(Jednotka.HMP.value, Telegram.BEZNY, b'\xA3' + cis.to_bytes(1, 'little') + b'\x00' + int_to_bytes_data(konst,3))
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), conv_hex_to_str(hx), APP_TYP_DOTAZU.HMP_ZAPIS.value))
#zrus povoleni zapisu
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), "FF A5 00 3F 03 19 E1 00 00 F0 2F", APP_TYP_DOTAZU.HMP_ZAPIS.value))
def hmp_write_regmax(cur: sqlite3.Cursor, newmax:int):
try:
r = cur.execute("select posregkriv from zapojeni where adr_zarizeni=?", ("00",)).fetchone()
k = round(((newmax-r[0]) * 65536)/900)
#povol zapis
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), "FF A5 00 3F 03 19 E1 00 00 F4 2B", APP_TYP_DOTAZU.HMP_ZAPIS.value))
#zapis regmax
hx = telegram_create(Jednotka.HMP.value, Telegram.BEZNY, b'\xA2\x20\x00' + int_to_bytes_data(newmax))
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), conv_hex_to_str(hx), APP_TYP_DOTAZU.HMP_ZAPIS.value))
#stoupaci konstanta
hx = telegram_create(Jednotka.HMP.value, Telegram.BEZNY, b'\xA3\x2A\x00' + int_to_bytes_data(k, 3))
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), conv_hex_to_str(hx), APP_TYP_DOTAZU.HMP_ZAPIS.value))
#zrus povoleni zapisu
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), "FF A5 00 3F 03 19 E1 00 00 F0 2F", APP_TYP_DOTAZU.HMP_ZAPIS.value))
except Exception as e:
print("hmp_write_regmax(): Ex: {}".format(str(e)), flush=True)
pass
hmp_call_stoup_konst(cur)
hmp_call_rmax(cur)
#VERZE CISLO 2 import os import sys import serial import serial.rs485 import binascii import sys import queue import threading import subprocess import time import sqlite3 from datetime import datetime, timezone from knihovna import Jednotka,conv_str_hex_in_bytes, conv_hex_to_str, bytes_to_int, int_none, bytes_to_int_reverse, telegram_get_from, print_in_hex from parser_hmp import * from parser_v8 import * from repeat_timer import RepeatTimer from export_cloud import cloud_send_data k = 21117 hx = telegram_create(Jednotka.HMP.value, Telegram.BEZNY, b'\xA3\x2A\x00' + int_to_bytes_data(k, 3)) print(conv_hex_to_str(hx))
def hmp_call_get_history_posl_ulozena_pozice(c: sqlite3.Cursor):
dt = telegram_create(Jednotka.HMP.value, Telegram.BEZNY, b'\x52\xD2\x00')
c.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)", (datetime.now(), conv_hex_to_str(dt), APP_TYP_DOTAZU.HMP_POSLEDNI_CTENA_POZICE.value))
def hmp_process_ctvrthodiny_data(cur: sqlite3.Cursor, ddata:bytes, od:bytes): #predpoklad obecny cas ctvrthodiny
#print("hmp_process_ctvrthodiny_data()")
res = { 'cas': 0, 'odhad': 0, 'hl_poc_imp': 0, 'podr_cas_imp1':0, 'podr_poc_imp1':0, 'podr_cas_imp2':0, 'podr_poc_imp2':0 }
data = ddata[6:-1]
#d0 = data[0] # stav vystupu
#d1 = data[1] # SYSTEM byte (RAM addr 20h)
d2 = data[2] # cas ve 1/4 low byte
d3 = data[3] # bity 0 1 jsou ve 1/4 high byte, bity 4-7 jsou high byte odhadu spotrebovane prace na konci 1/4h
d4 = data[4] # odhad spotrebovane prace na konci 1/4 low byte
#cas 1/4h
res['cas'] = (((d3 << 6) & 0xFF) >> 6) * 256 + d2 #cas v sekundach
#odhad
odhad = ((d3 >> 4) & 0x0F) # Odhad.bit 11 = 0 => Odhad = odhad
if odhad & 8 == 8 : # komprimovano Odhad.bit 11 = 1 => Odhad = (odhad.bit0-10 * 4) + 2048
odhad = ((odhad << 1) & 0x0F) >> 1
res['odhad'] = (odhad * 256 + d4)*4 + 2048
else:
res['odhad'] = odhad * 256 + d4 #odhad
res['hl_poc_imp'] = data[6] * 256 + data[5]
res['hl_cas_imp'] = (data[9] * 65536 + data[8] * 256 + data[7]) /1000
res['podr_cas_imp1'] = (data[12] * 65536 + data[11] * 256 + data[10]) /1000
res['podr_poc_imp1'] = data[14] * 256 + data[13]
res['podr_cas_imp2'] = (data[17] * 65536 + data[16] * 256 + data[15]) /1000
res['podr_poc_imp2'] = data[19] * 256 + data[18]
s_adr = conv_hex_to_str(od)
kk = cur.execute("""select (select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni=? and cislo=?) k1,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and cislo=?) k2,
(select konst from zapojeni_vstupy zv inner join zapojeni z on zv.zapojeni_id = z.id where adr_zarizeni = ? and cislo=?) k3""",
(s_adr, 1, s_adr, 2, s_adr, 3)).fetchone()
if not kk or kk[0] == None or kk[1] == None or kk[2] == None:
return
k1 = kk[0]
k2 = kk[1]
k3 = kk[2]
"""
vypocet vykonu = 3600 / (cas hl eml * konstanta) .... pro jednotlive vstupy
vypocet prace = aktulanli pocet impulsu * konstatnta ... -> impl_1p = round(((impl_1p * 4) / k), 2) <- ta 4.ka znamena 4*15 - 1h na hodinu"""
v_1 = round(3600 / (res['hl_cas_imp'] * k1), 2)
v_2 = round(3600 / (res['podr_cas_imp1'] * k2), 2)
v_3 = round(3600 / (res['podr_cas_imp2'] * k3), 2)
p_1 = round(((res['hl_poc_imp'] * 4) / k1), 2)
p_2 = round(((res['podr_poc_imp1'] * 4) / k2), 2)
p_3 = round(((res['podr_poc_imp2'] * 4) / k3), 2)
if res['hl_poc_imp'] == 0:
cosF = 0
else:
cosF = round( res['hl_poc_imp'] / math.sqrt(res['hl_poc_imp']**2 + res['podr_poc_imp1']**2), 2)
cur.execute("""REPLACE INTO livedata(adr_zarizeni, cas, odhad, vykon_1, prace_1, vykon_2, prace_2, vykon_3, prace_3, cosf, cas_odecet)
values (?,?,?,?,?,?,?,?,?,?,?);""", (s_adr, res['cas'], res['odhad'], v_1, p_1, v_2, p_2, v_3, p_3, cosF, datetime.now()))
def hmp_call_get_livedata(c: sqlite3.Cursor) -> bytes:
hx = conv_hex_to_str(telegram_create(Jednotka.HMP.value, Telegram.BEZNY, b'\x00\xF0\xFD'))
c.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)", (datetime.now(), hx, APP_TYP_DOTAZU.HMP_LIVE_DATA.value))
def hmp_write_techmax(cur: sqlite3.Cursor, newmax:int):
try:
#povol zapis
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), "FF A5 00 3F 03 19 E1 00 00 F4 2B", APP_TYP_DOTAZU.HMP_ZAPIS.value))
#zapis techmax
hx = telegram_create(Jednotka.HMP.value, Telegram.BEZNY, b'\xA2\x22\x00' + int_to_bytes_data(newmax))
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), conv_hex_to_str(hx), APP_TYP_DOTAZU.HMP_ZAPIS.value))
#zrus povoleni zapisu
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu, iswrite) values(?, ?, ?, 1)", (datetime.now(), "FF A5 00 3F 03 19 E1 00 00 F0 2F", APP_TYP_DOTAZU.HMP_ZAPIS.value))
except Exception as e:
print("hmp_write_regmax(): Ex: {}".format(str(e)), flush=True)
pass
hmp_call_techmax(cur)
def hmp_create_zaznam_historie_all(cur: sqlite3.Cursor):
cur.execute("select cislozaznamu, id, hw_pozice_zaznamu from zapojeni where hw_typ=1")
r = cur.fetchone()
if r :
pos = r[0]
id = r[1]
hw_pos = r[2]
hmp_call_get_history_posl_ulozena_pozice(cur)
if pos > HISTORIE_MAX_ZAZNAMU_HMP or pos < 0:
pos = 0
if pos > hw_pos:
while pos <= HISTORIE_MAX_ZAZNAMU_HMP:
tg = hmp_create_zaznam_historie(pos)
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)", (datetime.now(), conv_hex_to_str(tg), APP_TYP_DOTAZU.HMP_HISTORIE_DATA_ALL.value))
pos += 1
pos = 0
while pos <= hw_pos:
tg = hmp_create_zaznam_historie(pos)
cur.execute("insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)", (datetime.now(), conv_hex_to_str(tg), APP_TYP_DOTAZU.HMP_HISTORIE_DATA_ALL.value))
pos += 1
def zapojeni_nacti_schema_ajax():
if not request.form or not request.form['data']:
return json.dumps({'code': 1, 'm': "Nevalidní vstupni parametry"})
data = json.loads(request.form['data'])
conn = sqlite3.connect('sqlite.db', check_same_thread=False)
try:
c = conn.cursor()
#smaz stavajici zapojeni
c.execute("delete from zapojeni_vstupy")
c.execute("delete from zapojeni")
c.execute("delete from serial_prikaz") #smaz vsechny prikazy
c.execute(
"insert into serial_prikaz(cas, prikaz, iscmd) values(CURRENT_TIMESTAMP,?,?)",
('FLUSH_QUEQUE', 1))
conn.commit()
q = "update inprogress set probiha=1, sval='Načítám strukturu zapojení' where akce='NACTENI_STRUKTURY_ZAPOJENI'"
c.execute(
"insert into serial_prikaz(cas, prikaz, isql) values(CURRENT_TIMESTAMP,?,?)",
(q, 1))
if data['typ'] == "1": #HMP
c.execute(
"insert into zapojeni(nazev, adr, hw_typ, adr_zarizeni, master) values(?,?,?,?,?)",
('HMP', 1, 1, '00', 1))
id = c.lastrowid
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('Hl měření', 1, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('1P podružný', 2, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('2P podružný', 3, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('4. vstup', 4, id, 1))
#nacti konstanty z hmp
hmp_call_get_konstanty(c)
hmp_call_rmax(c)
hmp_call_techmax(c)
hmp_call_get_history_posl_ulozena_pozice(c)
#nacti pocet pripojenych expanderu
hx = hmp_create_get_v8_count()
typ = APP_TYP_DOTAZU.HMP_POCET_PRIPOJENYCH_V8
else: #VE-8 master
c.execute(
"insert into zapojeni(nazev, adr, hw_typ, adr_zarizeni, master) values(?,?,?,?,?)",
('Expander', 0, 2, '20', 1))
id = c.lastrowid
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst, is_cinny) values(?,?,?,?,?)",
('Vstup 1.', 1, id, 1, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst, is_jalovy) values(?,?,?,?,?)",
('Vstup 2.', 2, id, 1, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('Vstup 3.', 3, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('Vstup 4.', 4, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('Vstup 5.', 5, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('Vstup 6.', 6, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('Vstup 7.', 7, id, 1))
c.execute(
"insert into zapojeni_vstupy(nazev, cislo, zapojeni_id, konst) values(?,?,?,?)",
('Vstup 8.', 8, id, 1))
#nacti konstanty z hmp
v8_call_get_konstanty(c, Jednotka.VE8_0.value)
v8_call_get_history_posl_ulozena_pozice(c, Jednotka.VE8_0.value)
#nacti pocet pripojenych expanderu
hx = v8_create_get_v8_count()
typ = APP_TYP_DOTAZU.V8_POCET_PRIPOJENYCH_V8
#nacti pocet pripojenych expanderu
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(CURRENT_TIMESTAMP, ?, ?)",
(conv_hex_to_str(hx), typ.value))
conn.commit()
except Exception as e:
print("Web: zapojeni_nacti_schema_ajax-Ex: {}".format(str(e)),
flush=True)
pass
conn.close()
return json.dumps({'code': 0, 'm': "Načítám strukturu zapojení"})
def tester_ajax():
#if not session.get('logged_in'):
# return json.dumps([])
conn = sqlite3.connect('sqlite.db', check_same_thread=False)
c = conn.cursor()
rows = []
try:
if request.form:
"""HMP_HISTORIE_DATA = 1
HMP_SOFTWARE = 2
TESTER_DEV = 999"""
if "drop" in request.form:
id = int(request.form['drop'])
if id == -2:
c.execute(
"delete from serial_prikaz") #smaz vsechny prikazy
c.execute(
"insert into serial_prikaz(cas, prikaz, iscmd) values(?,?,?)",
(datetime.now(), 'FLUSH_QUEQUE', 1))
else:
c.execute("delete from serial_prikaz where id=?", (id, ))
conn.commit()
else:
typ = int(request.form['typ'])
hx = ""
if typ == 0:
ttyp = int(request.form['ttyp'])
pro = int(request.form['pro'])
misto = int(request.form['misto'])
delka = int(request.form['delka'])
adresa = request.form['adresa']
hx = telegream_request_int(pro, ttyp, misto, delka,
conv_str_hex_adr_to_int(adresa))
elif typ == 1:
pro = int(request.form['pro'])
cislo = int(request.form['cislo'])
if pro == 0:
hx = hmp_create_zaznam_historie(cislo)
else:
hx = v8_create_zaznam_historie(pro, cislo)
elif typ == 2:
hx = conv_str_hex_in_bytes(request.form['raw'])
c.execute(
"insert into serial_prikaz(cas, prikaz, typ_dotazu) values(?, ?, ?)",
(datetime.now(), conv_hex_to_str(hx),
APP_TYP_DOTAZU.TESTER_DEV.value))
conn.commit()
c.execute(
"select id, prikaz, odpoved, strftime('%Y-%m-%d %H:%M:%S', cas) cas, strftime('%Y-%m-%d %H:%M:%S', cas_odpoved) cas_odpoved, typ_dotazu from serial_prikaz order by id desc limit 20"
)
for it in c.fetchall():
rows.append({
'id': it[0],
'prikaz': it[1],
'odpoved': it[2],
'cas': it[3],
'cas_odpoved': it[4],
'typ': it[5]
})
except:
pass
conn.close()
return json.dumps(rows)
