def month_archive(reg_list, fromdate, todate):
# ÔÁË ËÁË ×ÒÅÍÑ ÐÒÉ ÓÎÑÔÉÉ ÁÒÈÉ×Á ÉÄ£Ô ÏÔ ÓÅÇÏÄÎÑ É × ÇÌÕÂØ ×ÅËÏ× - ÍÅÎÑÅÍ ÍÅÓÔÁÍÉ to_date & from_date
from_date = todate
to_date = fromdate
month_now = datetime(*ddate.today().timetuple()[:3])
f_date = months_left(month_now, from_date)
archive_records = months_left(from_date, to_date) + 1
print "f_date %d, records = %d" % (f_date, archive_records)
for reg in reg_list:
constants.table[reg] = [reg]
constants.data = read_month_arch(reg, f_date, archive_records, 0)
print repr(constants.data)
if not constants.data:
dbmsg(7, ">> -------- NO MONTH DATA --------- \n ")
sys.exit(1)
if reg == 1003:
dt = 0
tmp_list = []
for mean in constants.data:
dt = mult2python_date(mean)
if not dt:
tmp_list.append(mean)
else:
tmp_list.append(dt.strftime('%d.%m.%Y'))
constants.table[reg] += tmp_list
#constants.table[reg] += [ mult2python_date(dt).strftime('%d.%m.%Y') for dt in constants.data]
else:
constants.table[reg] += ["%.2f" % x for x in constants.data]
constants.data = []
return constants.table
def months_left(first_date, second_date):
print locals()
if (first_date < second_date):
dbmsg(6, " months_left fail -> first_date < second_date")
return False
return ((first_date.year * 12) + first_date.month) - (
(second_date.year * 12) + second_date.month)
def MC601Cmd2Rqs(Cmd, n, request):
i = bite_counter = b = 0
if n <= 0:
return
dbmsg(3, "Cmd without CRC %s" % lst2hx(Cmd))
i = CRC_CCITT16(Cmd, n, 0)
Cmd = Cmd + list(unpack('BB', pack('>h', i)))
dbmsg(3, "Cmd with CRC %s" % lst2hx(Cmd))
request.append(
constants.SB_HdQ) # Добавляем стартовый байт
bite_counter = 1
b = 0
for i in range(n + 2):
b = Cmd[i]
b, stuffing_done = Stuffing(b)
if stuffing_done:
print "stuf enable"
request.append(constants.SB_Stf)
bite_counter += 1
request.append(b)
bite_counter += 1
request.append(
constants.SB_End) # Добавляем стоповый байт
bite_counter += 1
#print "request = %s"%lst2hx(request)
return bite_counter, request
def hour_archive(reg_list, from_date, to_date):
from_date += timedelta(days=+1)
to_date += timedelta(days=+2)
#day += timedelta(days=+1)
day = from_date
for reg in reg_list:
constants.table[reg] = [reg]
for day_inc in range(days_left(to_date, from_date)):
day = from_date + timedelta(days=day_inc)
print "day = %s" % (day)
constants.data = read_hour_arch(reg, day) # hour
print 'LEN=', len(constants.data), " ", repr(constants.data), "\n"
if not constants.data:
dbmsg(7, ">> -------- NO HOUR DATA --------- \n ")
sys.exit(1)
if reg == 1002:
constants.table[reg] += [
str(int(dt)) for dt in list(constants.data)
]
elif reg == 1003:
constants.table[reg] += [
dt.strftime('%d.%m.%Y') for dt in constants.data
]
else:
constants.table[reg] += ["%.2f" % x for x in constants.data]
constants.data = []
return
def read_heatmeter_number():
constants.Cmd.from_array([0x3f,0x2])
if SendCommand(constants.Cmd,2) != 0:
dbmsg(6,"ERROR of SendCommand in read_heatmeter_number function")
return # error
res = Bytes2L(constants.response,4,2)
print "Heatmeter number = %d" % res
return res
def days_left(first_date, second_date):
#print "days_left ",locals()
if (first_date < second_date):
dbmsg(
6, " days_left fail -> first_date(%s) < second_date(%s)" %
(str(first_date), str(second_date)))
#return False
return 0
return (first_date - second_date).days
def check_CRC():
if constants.reading_error == 0:
crc_res = CRC_CCITT16(constants.response, constants.response_data_len,
0)
#print " response =%d response_data_len =%d CRC = %d" %(len(response), response_data_len,crc_res)
if crc_res == 0:
constants.response_data_len -= 2
constants.response = constants.response[:-2]
else:
dbmsg(6, "CRC - FALSE")
constants.reading_error = constants.EP_CRC
def proccess_array(array):
constants.reading_status = constants.IP_Wait
dbmsg(3,
"proccess_array reading_error = %d \n\n" % constants.reading_error)
cnt = 0
for x in array:
cnt += 1
#save_bite(x)
proccess_bite(ord(x))
#print "cnt=",cnt
if constants.reading_error != 0:
print "ERROR = " + constants.reading_error_log[
constants.reading_error]
sys.exit(1)
return
def read_day_arch(registr, from_date, days_amount, day ):
print "from_date = ",from_date,"| days_amount= ", days_amount
constants.active = True
if not constants.active:
return empty_day_arch(registr,from_date, days_amount, day)
records_amount = mantis_size = iPos = factor = 0
data = [0] * days_amount
#print "here"
constants.Cmd.from_array([0x3f,0x66]) # ÎÏÍÅÒ ÆÕÎÃÉÉ × ËÏÍÍÁÎÄÕ
constants.Cmd = I2Bytes(registr, constants.Cmd, 2) # ÎÏÍÅÒ ÒÅÇÉÓÔÒÁ × ËÏÍÍÁÎÄÕ
f_date = from_date
day = 0
while day < days_amount:
constants.Cmd = I2Bytes(f_date, constants.Cmd, 4)
constants.reading_error = SendCommand(constants.Cmd, 6)
if constants.reading_error != 0:
dbmsg(5,"some errors")
return data
try:
mantis_size = constants.response[5] # ������ ��������
except IndexError:
print "response[5]=" , constants.response # ������ ��������
break
print 'mantis_size = ', mantis_size
if mantis_size == 0:
break
factor = Byte2Factor(constants.response[6]) # ������
records_amount = (constants.response_data_len - 7) / mantis_size # ���������� ��Þޣ��� ����������
if records_amount == 0:
return data
iPos = 7
#for j in range(records_amount):
#for j in range(days_amount):
print "records_amount = ",records_amount
for j in range(records_amount):
if day == days_amount:
break
#print "DAY = ",day,"records_amount =",records_amount
try:
data[day] = Byte2Mantiss(constants.response, mantis_size, iPos) * factor
except:
print "ERROR day = %d | response = %s | mant = %d | pos = %d"%(day,lst2hx(constants.response),mantis_size, iPos)
sys.exit(2)
iPos = iPos + mantis_size
day += 1
f_date += records_amount
return data
def read_current(register):
constants.active = True
"""if not constants.active:
dbmsg(7,"Not Active")
return 0"""
#Cmd.from_array([0x3f,0x10,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0])
constants.Cmd.from_array([0x3f,0x10,0x1,0x0,0x0])
constants.Cmd = I2Bytes(register,constants.Cmd,3)
if SendCommand(constants.Cmd , 5) != 0:
dbmsg(6,"ERROR of SendCommand")
return # error
if constants.response_data_len <= 7:
dbmsg(6,"return empty response")
print "empty current response"
return 0 # empty response
#print "CuRR_response_data_len = %d " % constants.response_data_len
return Byte2Mantiss(constants.response,constants.response[5],7) * Byte2Factor(constants.response[6])
def read_month_arch(registr, from_date, months_amount, month ):
constants.active = True
print "REGISTR = ",registr
data = [0] * months_amount
factor = f_date = records_amount = mantis_size = 0
#if not constants.active:
#return empty_day_arch(registr,from_date, months_amount, month)
#if not registr == 1003:
# data = empty_day_arch(registr,from_date, months_amount, month)
# print repr(data)
constants.Cmd.from_array([0x3f,0x65]) # ÎÏÍÅÒ ÆÕÎÃÉÉ × ËÏÍÍÁÎÄÕ
constants.Cmd = I2Bytes(registr, constants.Cmd, 2) # ÎÏÍÅÒ ÒÅÇÉÓÔÒÁ × ËÏÍÍÁÎÄÕ
f_date = from_date
month = 0
while month < months_amount:
constants.Cmd = I2Bytes(f_date, constants.Cmd, 4) # ÎÏÍÅÒ ÒÅÇÉÓÔÒÁ × ËÏÍÍÁÎÄÕ
constants.reading_error = SendCommand(constants.Cmd, 6)
if constants.reading_error != 0:
dbmsg(5,"some errors")
return [0] * months_amount
try:
mantis_size = constants.response[5] # ������ ��������
factor = Byte2Factor(constants.response[6]) # ������
except IndexError:
return [0] * months_amount
records_amount = (constants.response_data_len - 7) / mantis_size # ���������� ��Þޣ��� ����������
if records_amount == 0:
return [0] * months_amount
iPos = 7
if records_amount > months_amount:
records_amount = months_amount
for j in range(records_amount):
print j
data[month] = Byte2Mantiss(constants.response, mantis_size, iPos) * factor
#print "data[month] =",repr(data[month])
month += 1
iPos += mantis_size
f_date += records_amount
data.reverse()
return data
def read_hour_arch(registr, date):
"""óÞÉÔÁÔØ ÐÏËÁÚÁÎÉÅ ÞÅÇÏ-ÔÏ ÔÁÍ ÕËÁÚÁÎÎÏÇÏ × ÒÅÇÉÓÔÒÅ ÚÁ 24 ÞÁÓÁ """
records_amount = mantis_size = iPos = factor = b = 0
dbmsg(6,"REGISTR (%d)"%registr)
if registr in ( 1002 , 1003):
# ÅÓÌÉ ÄÁÔÁ ÉÌÉ ×ÒÅÍÑ ÔÏ ÚÁÐÏÌÎÑÅÍ ÓÏÏÔ×ÅÔÓÔ×ÅÎÏ, É ÎÁ ÓÞ£ÔÞÉË ÎÅ ÌÅÚÅÍ
return empty_hour_arch( registr, date )
res = [0] * 24
#date = date + timedelta(hours = +1)
constants.Cmd.from_array([0x7f,0x63]) # ÎÏÍÅÒ ÆÕÎÃÉÉ × ËÏÍÍÁÎÄÕ
constants.Cmd = I2Bytes(registr, constants.Cmd, 2) # ÎÏÍÅÒ ÒÅÇÉÓÔÒÁ × ËÏÍÍÁÎÄÕ
constants.Cmd += [(date.year - 2000), (date.month), (date.day), 0x0 ] # ÚÁ ËÁËÕÀ ÄÁÔÕ ÓÞÉÁÔØ × ËÏÍÍÁÎÄÕ
constants.reading_error = SendCommand(constants.Cmd, 8) # ÚÁÓÌÁÔØ É ÓÌÕÛÁÔØ ÏÔ×ÅÔ
if constants.reading_error != 0:
print "Detected some errors during reading process - try again"
return False
#dbmsg(6," >>> response (%s)"%lst2hx(response))
mantis_size = constants.response[5] # ������ ��������
factor = Byte2Factor(constants.response[6]) # ������
print "response_data_len = ",constants.response_data_len
records_amount = (constants.response_data_len - 8) / mantis_size # ���������� ��Þޣ��� ���������� (24)
#sys.exit(1)
if records_amount <= 0:
reading_error = 99
print "Error reading hour arch NO records"
return res
iPos = 8 # ÇÄÅ ÎÁÞÉÎÁÀÔÓÑ ÓÏÂÓÔ×ÅÎÎÏ ÄÁÎÎÙÅ
if records_amount > 24:
records_amount = 24
tmp = 0
print "here! KKK = %d"%records_amount
for j in range(0,records_amount):
#print "---<> resp = %s, mantis=%d, ipos=%d "%(lst2hx(constants.response), mantis_size, iPos)
tmp = Byte2Mantiss(constants.response, mantis_size, iPos) # 1234
res[j] = tmp * factor # 1234 * 0.01 = 12.34
iPos = iPos + mantis_size # ÓÍÅÝÅÎÉÅ
#dbmsg(6,"res[%d] = %2f "%(j,res[j]))
#print "+++ " , repr(res)
res.reverse()
return res
def day_archive(reg_list, fromdate, todate):
# ÔÁË ËÁË ×ÒÅÍÑ ÐÒÉ ÓÎÑÔÉÉ ÁÒÈÉ×Á ÉÄ£Ô ÏÔ ÓÅÇÏÄÎÑ É × ÇÌÕÂØ ×ÅËÏ× - ÍÅÎÑÅÍ ÍÅÓÔÁÍÉ to_date & from_date
from_date = todate # 12 november
to_date = fromdate # 01 august
#from_date += relativedelta(days=1)
#to_date += relativedelta(days=2)
now_day = datetime(*ddate.today().timetuple()[:3])
start_date = days_left(now_day, from_date)
#print "now_day = %s, from_date = %s"%(repr(now_day),repr(from_date))
#print "from_day = %s, to_date = %s"%(repr(from_date),repr(to_date))
archive_records = days_left(from_date,
to_date) + 1 # c 12.11 ÐÏ 01.08 Ë ÐÒÉÍÅÒÕ
#print "startdate %d, records =%d"%(start_date, archive_records)
len_reglist = len_reglist2 = len(reg_list)
for reg in reg_list:
len_reglist2 -= 1
constants.table[reg] = []
constants.data = read_day_arch(reg, start_date, archive_records, 0)
if not constants.data:
dbmsg(7, ">> -------- NO DAY DATA --------- \n ")
sys.exit(1)
if reg == 1003:
try:
constants.table[reg] += [
mult2python_date(dt).strftime('%d.%m.%Y')
for dt in constants.data
]
except:
constants.table[reg] += ["%d" % x for x in constants.data]
#[ mult2python_date(dt).strftime('%d.%m.%Y') for dt in constants.data]
else:
constants.table[reg] += ["%.2f" % x for x in constants.data]
constants.data = []
constants.table[reg] += [reg]
constants.table[reg].reverse()
return constants.table
def proccess_bite(bite):
# ������� ��ɣ��. �������� ���, ������� ��������� � �������� ������ � �.�.
dbmsg(
3, "reading_error = %s reading_status = %s" %
(constants.reading_error_log[constants.reading_error],
constants.reading_status_log[constants.reading_status]))
if (constants.reading_status == constants.IP_Void):
#print "1"
# ��ɣ� �� ���������. ����� ���� -- ������
if constants.reading_error != 0:
constants.reading_error = constants.EP_Raving
elif (constants.reading_status == constants.IP_Wait):
#print "2"
# �ģ� ��� ��� ���������� ������.
if (bite == constants.SB_HdQ):
# ������ ��� � ����-�������
constants.reading_status = constants.IP_Echo # ÅÓÌÉ ÓÔÁÒÔÏ×ÙÊ ÂÉÔ 0x80 - ÔÏ ÖÄ£Í ÜÈÁ
elif (bite == constants.SB_HdR):
constants.reading_status = constants.IP_Resp # ÅÓÌÉ 0x40 - ������ ������
#print "detect 0x40 "
else:
constants.reading_status = constants.IP_Void
constants.reading_error = constants.EP_Violation
elif (constants.reading_status == constants.IP_Echo):
#print "3"
# ��������� ���. �� ����-����� ����������
if (bite == constants.SB_End):
constants.reading_status = constants.IP_Paus
else:
# � ��������, ����� ���������� � ��������
# �� �� ���� ������ �� ������
pass
elif (constants.reading_status == constants.IP_Paus):
#print "4"
# �ģ� ������. �������� ������ ��������� ����
if (bite == constants.SB_HdR):
constants.reading_status = constants.IP_Resp
elif (bite == constants.SB_Ack):
constants.reading_status = constants.IP_Void
save_bite(bite)
else:
constants.reading_status = constants.IP_Void
constants.reading_error = constants.EP_Violation
save_bite(bite)
elif (constants.reading_status == constants.IP_Resp):
#print "5"
# ��������� �����
if (bite == constants.SB_End):
constants.reading_status = constants.IP_Void # if bite == 0x0d
elif (bite == constants.SB_Stf):
constants.reading_status = constants.IP_Stuf
else:
save_bite(bite)
elif (constants.reading_status == constants.IP_Stuf):
#print "6"
# �ģ� ���� ������
bite, destuffing_done = Destuffing(bite)
if destuffing_done:
constants.reading_status = constants.IP_Resp
else:
constants.reading_status = constants.IP_Void
constants.reading_error = constants.EP_Stuff
save_bite(bite)
def hours_left(first_date, second_date):
if (first_date < second_date):
dbmsg(6, " hours_left fail -> first_date < second_date")
return False
return (first_date - second_date).days * 24
def years_left(first_date, second_date):
if (first_date < second_date):
dbmsg(6, " months_left fail -< first_date < second_date")
return False
return (first_date.year - second_date.year)
sys.exit()"""
#open('tmp.tzt','a').write('info = %s'%str(info)) """
#open('tmp.tzt','a').write('-=( registr = %d )=-\n'%reg)
#registr_list = [1002,1003,99,72,73,86,87,61,62]
#registr_list = [86,87]
#registr_list = [1003,99,72,73,86,87,61,62] # hour, day
#registr_list = [1003,99,60,61,62,68,69,97,110]
#registr_list = [1003,99,72,73,86,87,61,62] # hour, day
#constants.moxaport = '/dev/ttyr03'
print "ARCHIVE_TYPE = %s from %s to %s" % (
arch_type, start_date.strftime('%d.%m.%Y %H:%M'),
end_date.strftime('%d.%m.%Y %H:%M'))
read_archive(reg_list, start_date, end_date, arch_type) #,constants)
if not constants.table:
dbmsg(7, "NO DATA")
sys.exit(1)
print repr([constants.table[x] for x in reg_list])
constants.table = map(None, *[constants.table[x] for x in reg_list])
info = ""
for row in constants.table:
info += "\t".join(str(value) for value in row) + "\n"
print info
f = open(output, 'w')
f.write('\t%s' % str(info))
#f.flush()
f.close()
# 192.168.3.100
def SendCommand(command, n):
#print "sendcommand"
if not constants.port:
init_port()
clear_constats_before_reading(
) # ц╞ц┌ц▌ц∙ц▄ц▒ц┘ц█ ц▐ц⌡ц┴ц┌ц▀ц┴ ц·ц■ц┘ц▌ц┴ц▒, ц└ц▄ц┴ц▌ц∙-ц▐ц■ц≈ц┘ц■ц│, ц⌠ц■ц│ц■ц∙ц⌠-ц·ц■ц┘ц▌ц┴ц▒ - IP_WAIT
constants.reading_status = constants.IP_Wait
constants.request_data_len, constants.request = MC601Cmd2Rqs(
command, n, constants.request
) # ц░ц▐ц▄ц∙ц·ц┘ц█ ц▀ц▐ц▄-ц≈ц▐ ц▐ц■ц⌠ц≥ц▄ц│ц┘ц█ц≥ц┬ ц┌ц│ц┼ц■ + ц░ц▐ц└ц┤.ц ц│ц░ц▓ц▐ц⌠
dbmsg(7, "Rqs: %s" % (lst2hx(constants.request)))
#print "request after MC601Cmd2Rqs = %s type(request) = %s" % (lst2hx(request),repr(type(request)))
#request = request[:-1]
Rqs = constants.request
#open('tmp.tzt','a').write('locals = %s'%repr(locals()))
open('tmp.tzt', 'a').write('Cmd: ' + lst2hx(Rqs) + "\n")
constants.port.write(
Rqs.as_str()
) # ц▐ц■ц⌠ц≥ц▄ц│ц┘ц█ ц≈ц⌠бё ц≈ ц░ц▐ц▓ц■
#raw_response = False
raw_response = ""
raw_response_cnt = 6
while not raw_response and raw_response_cnt:
if raw_response_cnt < 6:
print "attemp(to get data) no.", raw_response_cnt
sleep(1)
constants.port.write(
Rqs.as_str()
) # ц▐ц■ц⌠ц≥ц▄ц│ц┘ц█ ц≈ц⌠бё ц≈ ц░ц▐ц▓ц■
read_bite = "1"
"""while read_bite:
read_bite = constants.port.read(1)
if read_bite:
#proccess_bite(read_bite)
raw_response += read_bite"""
raw_response = constants.port.read(1024)
raw_response_cnt -= 1
#print "LEN = " + str(len(raw_response))
open('tmp.tzt', 'a').write('Rsp: ' + lst2hx(raw_response) + "\n")
dbmsg(7, 'Rsp: %s \n\n' % lst2hx(raw_response))
if not raw_response:
#return constants.port.EP_Line
dbmsg(6, "heatmeter don't response!")
return False
constants.reading_status = constants.IP_Void
proccess_array(raw_response)
#start_timer(3) # ц▌ц│ 3 ц⌠ц┘ц▀ц∙ц▌ц└ц≥ ц≈ц▀ц▄ц─ц·ц│ц┘ц█ ц├ц▄ц│ц┤ "wait"
#while not data_recived(): # ц░ц▓ц▐ц≈ц┘ц▓ц▒ц┘ц■ reading_status
# timer_check() # ц░ц▓ц▐ц≈ц┘ц▓ц▒ц┘ц█ ц▌ц┘ ц≈ц≥ц⌡ц┘ц▄ ц▄ц┴ ц■ц│ц┼ц█ц│ц∙ц■ ц≈ 3 ц⌠ц┘ц▀ц∙ц▌ц└ц≥
#stop_timer() # ц▐ц⌠ц■ц│ц▌ц│ц≈ц▄ц┴ц≈ц│ц┘ц█ ц■ц│ц┼ц█ц┘ц▓ ц■.ц▀. ц∙ц√ц┘ ц≈ц⌠бё ц░ц▓ц▐ц·ц┴ц■ц│ц▌ц▐
"""if not check_function():
dbmsg(7,"Request function != response Function = Error")
constants.reading_error = constants.EP_Violation
sys.exit(1) """
check_CRC()
try:
constants.port.close()
constants.port = None
constants.active = False
except:
pass
return constants.reading_error
