def run(hs, gpu, epochs, snaps, batchsize, lr, thre):
planes = []
train, test = chainer.datasets.get_mnist()
xp = cp if gpu >=0 else np
test_xs, test_ys = tuple2array(test, xp)
size = 10000
test_xs = test_xs[:size]; test_ys = test_ys[:size]
bins = np.linspace(-1, 1, 30)
Ts_index = np.array(np.linspace(0, 1, snaps) * (epochs - 1)).astype(np.int)
least = 10
if Ts_index[1] > least:
Ts_index = np.unique(np.append(np.array(range(least)), Ts_index[1:]))
model = MLP(hs)
if gpu >= 0:
model.to_gpu()
train_iter = chainer.iterators.SerialIterator(train,
batch_size=batchsize)
Ts_list = train_model(model, train_iter, test_xs, test_ys,
epochs, batchsize, Ts_index, lr, hs, thre)
feature = '{}_thre{}_epoch{}_bs{}_lr{}'.format(
'_'.join([str(h) for h in hs]), thre, epochs, batchsize, lr)
points = calc_mi(to_cpu(test_xs), to_cpu(test_ys)[:, None],
Ts_list, bins)
plot_planes(points, Ts_index, hs, feature)
pr('')
def copy_log_to_www(self,dbug_flag): here = "copy_log_to_www" try: # send the same html file to the local web site copyfile(self.__log_filename_save_as, self.__local_www_log_filename) pr(dbug_flag,0, "Sent : " + self.__log_filename_save_as + " to : ", self.__local_www_log_filename) except: pr(True,0,"Fail with copy " + self.__log_filename_save_as + " to : ", self.__local_www_log_filename)
def send_log_by_ftp(self, FTP_dbug_flag, remote_log_dir, timeout):
here = "my_sensors.send_log_by_ftp"
ftp_result = send_by_ftp(FTP_dbug_flag,self.__ftp_creds, self.__log_filename_save_as, \
self.__log_filename,remote_log_dir,timeout)
# Folowing useful to debug the remote directory
# pr(FTP_dbug_flag,here,"### FTP_dbug_flag,self.__ftp_creds, self.__log_filename_save_as, self.__log_filename,remote_log_dir", \
# str(FTP_dbug_flag) + ":" + str(self.__ftp_creds) + ":" + str(self.__log_filename_save_as) + \
# ":" + str(self.__log_filename) + ":" + str(remote_log_dir))
for pres_ind in range(0, len(ftp_result)):
pr(FTP_dbug_flag, here,
str(pres_ind) + " : ", ftp_result[pres_ind])
return
def send_command(self, cmded, ip, port, dbug_flag):
here = "743 smartplug send command"
pr(dbug_flag, here, "command and ip : ", str(cmded) + " : " + str(ip))
try:
self.cmnd_start = datetime.now()
sock_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_tcp.settimeout(self.timeout / 1000000)
sock_tcp.connect((ip, port))
sock_tcp.send(self.encrypt(cmded))
data = sock_tcp.recv(2048)
sock_tcp.close()
return self.decrypt(data[4:])
except:
return "error"
def write_file(self):
here = "config.write_file"
config_write = RawConfigParser()
config_write.add_section('SetUp')
config_write.set('SetUp', 'scan_delay', self.scan_delay)
config_write.set('SetUp', 'max_scans', self.max_scans)
config_write.set('SetUp', 'log_directory', self.log_directory)
config_write.set('SetUp', 'local_dir_www', self.local_dir_www)
config_write.set('SetUp', 'sensor_config_filename',
self.sensor_config_filename)
config_write.set('SetUp', 'ftp_creds_filename',
self.ftp_creds_filename)
config_write.set('SetUp', 'delay_limit', self.delay_limit)
config_write.set('SetUp', 'delay_increment', self.delay_increment)
config_write.set('SetUp', 'ftp_log_max_count', self.ftp_log_max_count)
config_write.set('SetUp', 'heaterIP0', self.heaterIP0)
config_write.set('SetUp', 'heaterIP0_power_scale',
self.heaterIP0_power_scale)
config_write.set('SetUp', 'heaterIP1', self.heaterIP1)
config_write.set('SetUp', 'heaterIP1_power_scale',
self.heaterIP1_power_scale)
config_write.set('SetUp', 'heaterIP2', self.heaterIP2)
config_write.set('SetUp', 'heaterIP2_power_scale',
self.heaterIP2_power_scale)
config_write.set('SetUp', 'heaterIP3', self.heaterIP3)
config_write.set('SetUp', 'heaterIP3_power_scale',
self.heaterIP3_power_scale)
config_write.set('SetUp', 'sensor4readings', self.sensor4readings)
config_write.set('SetUp', 'change4log', self.change4log)
config_write.set('SetUp', 'control_hysteresis',
self.control_hysteresis)
config_write.set('SetUp', 'default_target', self.default_target)
config_write.set('SetUp', 'default_target_full_power',
self.default_target_full_power)
config_write.set('SetUp', 'max_target', self.max_target)
config_write.set('SetUp', 'min_target', self.min_target)
config_write.set('SetUp', 'precision', self.precision)
config_write.set('SetUp', 'target_integral', self.target_integral)
config_write.set('SetUp', 'one_heater_select', self.one_heater_select)
config_write.set('SetUp', 'percent_full_power',
self.percent_full_power)
config_write.set('SetUp', 'watchdog_time', self.percent_full_power)
config_write.set('SetUp', 'ftp_timeout', self.percent_full_power)
# Writing our configuration file to 'c_filename'
pr(self.dbug, here,
"ready to write new config file withdefault values: ",
self.__c_filename)
with open(self.__c_filename, 'w+') as configfile:
config_write.write(configfile)
return 0
def send_log_by_ftp(self,FTP_dbug_flag,remote_log_dir,ftp_timeout):
here = "bffr_log_log_by_ftp"
ftp_result = send_by_ftp(FTP_dbug_flag,self.__config.ftp_creds_filename, self.__log_filename_save_as, \
self.__log_filename,remote_log_dir,ftp_timeout)
for pres_ind in range(0,len(ftp_result)):
pr(FTP_dbug_flag,here, str(pres_ind) + " : ", ftp_result[pres_ind])
if self.__send_plain_count < 0 :
ftp_result = send_by_ftp(FTP_dbug_flag,self.__config.ftp_creds_filename, self.__log_filename_save_as, \
"log.csv",remote_log_dir,ftp_timeout)
for pres_ind in range(0,len(ftp_result)):
pr(FTP_dbug_flag,here, str(pres_ind) + " : ", ftp_result[pres_ind])
self.__send_plain_count = 10
else:
self.__send_plain_count -= 1
#print("Send plain count : ",self.__send_plain_count)
return
def set_status_text(self, config):
# set the status text based on the results of the last scan
self.status_text_error_count = 0
here = "mysensors.set_status_text"
for z in range(0, len(self.code), 1):
pr(
self.dbug, here, "setting status text (index:error:reading) ",
str(z) + " : " + str(self.error_number[z]) + " : " +
str(self.reading[z]))
if self.error_number[z] == 0:
self.status_text[z] = ("{0:.4}".format(float(self.reading[z])))
else:
self.status_text_error_count += 1
if self.delay[z] >= config.delay_limit:
self.status_text[z] = ("Wait : " + str(int(self.delay[z])))
else:
self.status_text[z] = ("Err# : " +
str(self.error_number[z]))
def write_file(self):
here = "config.write_file"
config_write = RawConfigParser()
section = "Scan"
config_write.add_section(section)
config_write.set(section, 'scan_delay', self.scan_delay)
config_write.set(section, 'max_scans', self.max_scans)
section = "Log"
config_write.add_section(section)
config_write.set(section, 'log_directory', self.log_directory)
config_write.set(section, 'local_dir_www', self.local_dir_www)
config_write.set(section, 'log_buffer_flag', self.log_buffer_flag)
config_write.set(section, 'text_buffer_length',
self.text_buffer_length)
section = "Ftp"
config_write.add_section(section)
config_write.set(section, 'ftp_creds_filename',
self.ftp_creds_filename)
config_write.set(section, 'ftp_log_max_count', self.ftp_log_max_count)
config_write.set(section, 'ftp_timeout', self.ftp_timeout)
config_write.set(section, 'ftplog', self.ftplog)
config_write.set(section, 'ftp_debug', self.ftp_debug)
section = "Sauna"
config_write.add_section(section)
config_write.set(section, 'max_temp', self.max_temp)
config_write.set(section, 'min_temp', self.min_temp)
config_write.set(section, 'min_speed', self.min_speed)
config_write.set(section, 'max_speed', self.max_speed)
config_write.set(section, 'min_freq', self.min_freq)
config_write.set(section, 'max_freq', self.max_freq)
config_write.set(section, 'sauna_GPIO_port', self.sauna_GPIO_port)
config_write.set(section, 'sensor4readings', self.sensor4readings)
section = "Lamps_and_logging"
config_write.set(section, 'lamps_control', self.lamps_control)
config_write.set(section, 'latitude', self.latitude)
config_write.set(section, 'longitude', self.longitude)
# Writing our configuration file to 'self.config_filename'
pr(self.debug, here,
"ready to write new config file with default values: ",
self.config_filename)
with open(self.config_filename, 'w+') as configfile:
config_write.write(configfile)
return 0
def write_file(self):
here = "config.write_file"
config_write = RawConfigParser()
config_write.add_section('SetUp')
config_write.set('SetUp', 'scan_delay', self.scan_delay)
config_write.set('SetUp', 'max_scans', self.max_scans)
config_write.set('SetUp', 'log_directory', self.log_directory)
config_write.set('SetUp', 'local_dir_www', self.local_dir_www)
config_write.set('SetUp', 'ftp_creds_filename',
self.ftp_creds_filename)
config_write.set('SetUp', 'ftp_log_max_count', self.ftp_log_max_count)
config_write.set('SetUp', 'ftp_timeout', self.ftp_timeout)
# Writing our configuration file to 'c_filename'
pr(self.dbug, here,
"ready to write new config file withdefault values: ",
self.config_filename)
with open(self.config_filename, 'w+') as configfile:
config_write.write(configfile)
return 0
def calc_information_for_layer_with_other(data, bins, unique_inverse_x,
unique_inverse_y, label, b, b1,
len_unique_a, pxs, p_YgX, pys1, e, l,
percent_of_sampling=50):
pr('Calculating MI for SNAP {} LAYER {}...'.format(e + 1, l + 1))
IXT, ITY = calc_information_sampling(data, bins, pys1, pxs, label, b, b1,
len_unique_a, p_YgX, unique_inverse_x,
unique_inverse_y)
number_of_indexs = int(data.shape[1] * (1. / 100 * percent_of_sampling))
indexs_of_sampls = np.random.choice(data.shape[1], number_of_indexs,
replace=False)
if percent_of_sampling != 100:
sampled_data = data[:, indexs_of_sampls]
sampled_IXT, sampled_ITY = calc_information_sampling(
sampled_data, bins, pys1, pxs, label, b, b1,
len_unique_a, p_YgX, unique_inverse_x, unique_inverse_y)
params = {}
params['ixt'] = IXT
params['ity'] = ITY
params['epoch'] = e
params['layer'] = l
return params
def run(gpu, epochs, snaps, batchsize, lr):
train, test = chainer.datasets.get_mnist()
xp = cp if gpu >=0 else np
test_xs, test_ys = tuple2array(test, xp)
size = 10000
test_xs = test_xs[:size]; test_ys = test_ys[:size]
bins = np.linspace(-1, 1, 30)
Ts_index = np.array(np.linspace(0, 1, snaps) * epochs).astype(np.int)
model = CNN()
if gpu >= 0:
model.to_gpu()
train_iter = chainer.iterators.SerialIterator(train,
batch_size=batchsize)
Ts_list = train_model(model, train_iter, test_xs, test_ys,
epochs, batchsize, Ts_index, lr)
points = calc_mi(to_cpu(test_xs), to_cpu(test_ys)[:, None], Ts_list, bins)
# points = calc_mmds(to_cpu(test_xs), to_cpu(test_ys)[:, None], Ts_list)
feature = 'cnn_epoch{}_bs{}_lr{}'.format(epochs, batchsize, lr)
plot_planes(points, Ts_index[:-1], feature)
pr('')
def write_file(self):
here = "config.write_file"
config_write = RawConfigParser()
section = "Scan"
config_write.add_section(section)
config_write.set(section, 'scan_delay', self.scan_delay)
config_write.set(section, 'max_scans', self.max_scans)
section = "Log"
config_write.add_section(section)
config_write.set(section, 'log_directory', self.log_directory)
config_write.set(section, 'local_dir_www', self.local_dir_www)
config_write.set(section, 'log_buffer_flag', self.log_buffer_flag)
config_write.set(section, 'text_buffer_length',
self.text_buffer_length)
section = "Ftp"
config_write.add_section(section)
config_write.set(section, 'ftp_creds_filename',
self.ftp_creds_filename)
config_write.set(section, 'ftp_log_max_count', self.ftp_log_max_count)
section = "Fan"
config_write.add_section(section)
config_write.set(section, 'max_temp', self.max_temp)
config_write.set(section, 'min_temp', self.min_temp)
config_write.set(section, 'min_speed', self.min_speed)
config_write.set(section, 'max_speed', self.max_speed)
config_write.set(section, 'min_freq', self.min_freq)
config_write.set(section, 'max_freq', self.max_freq)
config_write.set(section, 'brightness', self.max_freq)
# Writing our configuration file to 'self.config_filename'
pr(self.dbug, here,
"ready to write new config file with default values: ",
self.config_filename)
with open(self.config_filename, 'w+') as configfile:
config_write.write(configfile)
return 0
def write_file(self, new_data_count, new_file):
# add a new record to the sensor file
#global my_sensors
#global config
#global smartplug_info
here = "mysensors.write_file"
pr(self.dbug, here, "write_sensor_data will write : ", new_data_count)
fields = ['number', 'code', 'location', 'stype', 'comment']
# 'at' mode adds toimport sys, getopt end of the file and opens file as text
if new_file:
mode = 'wb'
else:
mode = 'at'
if self.__s_filename == "":
pr(True, here, "No Sensor File Name set", 1.234)
sys_exit()
try:
with open(self.__s_filename, mode) as sensorcsv_file:
writer = csv_DictWriter(sensorcsv_file, fieldnames=fields)
if new_file: # this is a blank file
writer.writeheader() # new file needs headings.
for line_count in range(self.width - new_data_count,
self.width, 1):
writer.writerow({
'number': self.number[line_count],
'code': self.code[line_count],
'location': self.location[line_count],
'stype': self.stype[line_count],
'comment': self.comment[line_count]
})
except:
pr(True, here, "Error accessing the existing sensor info file",
self.__s_filename)
pr(True, here, "Try deleting file let prog make a new one",
self.__s_filename)
sys_exit()
return
def turn_off_smartplug(self, index):
here = "turn_off_smartplug"
cmd = self.commands["off"]
# print("off called : ",index)
try:
if self.ip[index] == "not set":
pr(self_dbug, here, "Smart Plug no ip address for Index : ",
index)
else:
pr(self.dbug, here, "Smart Plug cmd and index : ",
str(cmd) + " : " + str(self.ip[index]))
responce = self.send_command(cmd, self.ip[index], 9999, False)
pr(self.dbug, here, "Index, IP, Off responce : ",
str(index) + " : " + self.ip[index] + " : " + responce)
return responce
except:
return "error"
def log_to_file(self, config, smartplug_info, target_temp, ref_sensor,
dbug_flag, smart_log_width):
here = "log_temperature_data_to_file"
#write the time at the start of the line in logging file
if self.__log_count == 0:
config.log_outfile.write("Time,")
config.log_outfile.write("Count,")
config.log_outfile.write("Target,")
config.log_outfile.write("Ref Sensor,")
if config.sauna:
config.log_outfile.write("On,")
config.log_outfile.write("Offset,")
config.log_outfile.write("Detect Off")
config.log_outfile.write("\n")
else:
for hdg_ind in range(1, (self.max_width + 1)):
config.log_outfile.write("T" + str(hdg_ind) + ",")
config.log_outfile.write("I1,")
config.log_outfile.write("V1,")
config.log_outfile.write("P1,")
config.log_outfile.write("T1,")
config.log_outfile.write("I2,")
config.log_outfile.write("V2,")
config.log_outfile.write("P2,")
config.log_outfile.write("T2,")
config.log_outfile.write("\n")
self.__log_count += 1
logtime = datetime.now()
logtime_text = (str(logtime.day).zfill(2) + "/" +
str(logtime.month).zfill(2) + "/" +
str(logtime.year).zfill(2) + " " +
str(logtime.hour).zfill(2) + ":" +
str(logtime.minute).zfill(2) + ":" +
str(logtime.second).zfill(2))
config.log_outfile.write(logtime_text)
if (self.sensor_present == False):
config.log_outfile.write(" : no sensors with Trg Temp of : " +
str(target_temp) + "\n")
else:
config.log_outfile.write("," + str(self.__log_count) + ",")
config.log_outfile.write(str(target_temp) + ",")
config.log_outfile.write(str(ref_sensor) + ",")
if config.sauna:
config.log_outfile.write(
str(config.percent_full_power * config.sauna_on) + ",")
config.log_outfile.write(str(config.target_offset) + ",")
config.log_outfile.write(str(config.detect_off_count))
else:
for z in range(0, self.max_width, 1):
#record the data last saved for this sensor
#send data to the file only if the sensor is connected
config.log_outfile.write(str(self.status_text[z]) + ",")
self.last_logged[z] = self.reading[z]
self.last_logged_error_number[z] = self.error_number[z]
config.log_outfile.write(str(smartplug_info.current[0]))
config.log_outfile.write("," + str(smartplug_info.voltage[0]))
config.log_outfile.write("," + str(smartplug_info.power[0]))
config.log_outfile.write("," + str(smartplug_info.total[0]))
pr(dbug_flag, here, "Total power going to log file",
smartplug_info.total[0])
#config.log_outfile.write("," + str(smartplug_info.error[1]))
#config.log_outfile.write("," + str(smartplug_info.state[1]))
config.log_outfile.write("," + str(smartplug_info.current[1]))
config.log_outfile.write("," + str(smartplug_info.voltage[1]))
config.log_outfile.write("," + str(smartplug_info.power[1]))
config.log_outfile.write("," + str(smartplug_info.total[1]))
pr(dbug_flag, here, "Total power going to log file",
smartplug_info.total[1])
#config.log_outfile.write("," + str(smartplug_info.error[1]))
config.log_outfile.write("\n")
config.log_outfile.flush()
return
def parse(data):
res = [line.split(',') for line in data.split('\n')]
return [[float(e) for e in line] for line in res]
getfloat = lambda msg: float(input(msg))
T1 = getfloat('Temp 1:')
T2 = getfloat('Temp 2:')
T = getfloat('Temp interp:')
data1, data2 = None, None
data = parse(data)
for l in data:
if l[0] == T1:
data1 = l[1:]
elif l[0] == T2:
data2 = l[1:]
del data
if data1 is None or data2 is None:
print('T1 or T2 not in data')
exit()
interpdata = []
for i in range(len(cols)):
val = interp(T, T1, T2, data1[i], data2[i])
interpdata.append(val * 10**(-exponent[i]))
pr(dict(zip(cols, interpdata)))
def write_file(self):
here = "config.write_file"
config_write = RawConfigParser()
section = "Debug"
config_write.add_section(section)
config_write.set(section, 'debug_reread_config',
self.debug_reread_config)
config_write.set(section, 'debug_flag_1', self.debug_flag_1)
config_write.set(section, 'debug_flag_2', self.debug_flag_2)
config_write.set(section, 'debug_flag_ftp', self.debug_flag_ftp)
section = "Scan"
config_write.add_section(section)
config_write.set(section, 'scan_delay', self.scan_delay)
config_write.set(section, 'max_scans', self.max_scans)
section = "Log"
config_write.add_section(section)
config_write.set(section, 'log_directory', self.log_directory)
config_write.set(section, 'local_dir_www', self.local_dir_www)
config_write.set(section, 'log_buffer_flag', self.log_buffer_flag)
config_write.set(section, 'text_buffer_length',
self.text_buffer_length)
section = "Ftp"
config_write.add_section(section)
config_write.set(section, 'ftp_creds_filename',
self.ftp_creds_filename)
config_write.set(section, 'ftp_log_max_count', self.ftp_log_max_count)
section = "Heating_Fan"
config_write.add_section(section)
config_write.set(section, 'heat_max_temp', self.heat_max_temp)
config_write.set(section, 'heat_min_temp', self.heat_min_temp)
config_write.set(section, 'heat_max_speed', self.heat_max_speed)
config_write.set(section, 'heat_min_speed', self.heat_min_speed)
config_write.set(section, 'heat_max_freq', self.heat_max_freq)
config_write.set(section, 'heat_min_freq', self.heat_min_freq)
section = "Sauna"
config_write.add_section(section)
config_write.set(section, 'sauna_max_temp', self.sauna_max_temp)
config_write.set(section, 'sauna_min_temp', self.sauna_min_temp)
config_write.set(section, 'sauna_max_speed', self.sauna_max_speed)
config_write.set(section, 'sauna_min_speed', self.sauna_min_speed)
config_write.set(section, 'sauna_max_freq', self.sauna_max_freq)
config_write.set(section, 'sauna_min_freq', self.sauna_min_freq)
config_write.set(section, 'sauna_GPIO_port', self.sauna_GPIO_port)
config_write.set(section, 'sauna_brightness', self.sauna_brightness)
section = "Power_Log"
config_write.add_section(section)
config_write.set(section, 'adc_scan_size', self.adc_scan_size)
config_write.set(section, 'adc_target_scan_msec',
self.adc_target_scan_msec)
config_write.set(section, 'adc_channel', self.adc_channel)
config_write.set(section, 'adc_default_gain ', self.adc_default_gain)
config_write.set(section, 'adc_top_limit', self.adc_top_limit)
config_write.set(section, 'adc_bottom_limit', self.adc_bottom_limit)
config_write.set(section, 'adc_input_offset_mv',
self.adc_input_offset_mv)
config_write.set(section, 'adc_input_amp_gain',
self.adc_input_amp_gain)
config_write.set(section, 'adc_CT_ratio', self.adc_CT_ratio)
config_write.set(section, 'adc_CT_resister', self.adc_CT_resister)
# Writing our configuration file to 'self.config_filename'
pr(self.debug_flag_1, here,
"ready to write new config file with default values: ",
self.config_filename)
with open(self.config_filename, 'w+') as configfile:
config_write.write(configfile)
return 0
def pr(self, appnd, ref, log_time, refresh_interval):
here = "buffer.pr for " + self.__name
make_values = [" -- "] * self.__width
prtime = datetime.now()
for_screen = log_time.strftime('%d/%m/%Y %H:%M:%S')
# following alternative will show more resolution for fractions of a second
# for_screen = log_time.strftime('%d/%m/%Y %H:%M:%S.%f')
make_values[0] = for_screen
file_start = """<head>
<meta http-equiv="refresh" content="""
file_start = file_start + str(refresh_interval)
file_start = file_start + """ />
</head>
<caption>Rotating Buffer Display</caption>"""
tbl_start = """ <p>
<table style="float: left;" border="1">
<tbody>"""
tbl_start_line = """<tr>"""
tbl_end_line = """</tr>"""
tbl_start_col = """<td>"""
tbl_end_col = """</td>"""
tbl_end = """</tbody>
</table>"""
file_end = """
</body>
</html>"""
try:
for i in range(0, self.__width - 1):
make_values[i + 1] = str(self.line_values[i])
for_screen = for_screen + " " + str(self.line_values[i])
except:
print("Error in make values in ...buffer.pr for : ", self.__name)
print("i,values,len(self.line_value>s),self.__width", i,
self.line_values, len(self.line_values), self.__width)
sys_exit()
# print to screen and to status log and update html file
if appnd:
print(" appending : " + self.__name + " : " + for_screen)
else:
print("not appending : " + self.__name + " : " + for_screen)
self.update_buffer(make_values, appnd, ref)
with open(self.__html_filename, 'w') as htmlfile:
htmlfile.write(file_start)
htmlfile.write("<p>" + self.__html_filename + " : " +
make_time_text(datetime.now()) + "</p>\n<p>")
htmlfile.write(tbl_start + tbl_start_line)
for ind in range(0, len(self.__headings)):
htmlfile.write(tbl_start_col + self.__headings[ind] +
tbl_end_col)
htmlfile.write(tbl_end_line)
buffer_dta = self.get_dta()
for ind in range(self.__size):
htmlfile.write(tbl_start_line)
for i in range(self.__width):
htmlfile.write(tbl_start_col + str(buffer_dta[ind][i]) +
tbl_end_col)
htmlfile.write(tbl_end_line)
htmlfile.write(tbl_end)
htmlfile.write(file_end)
copyfile(self.__html_filename, self.__www_filename)
# To debug FTP change end of following line to " = True"
FTP_dbug_flag = False
ftp_result = send_by_ftp(FTP_dbug_flag, self.__ftp_creds,
self.__html_filename_save_as,
self.__html_filename, "",
self.__config.ftp_timeout)
for pres_ind in range(0, len(ftp_result)):
pr(FTP_dbug_flag, here,
str(pres_ind) + " : ", ftp_result[pres_ind])
return
def get_smartplug_status(self, dbug_flag, config):
here = "get_smartplug_status"
read_cmd = self.commands["read"]
info_cmd = self.commands["info"]
read_results = ["not set"] * config.number_heaters
info_results = ["not set"] * config.number_heaters
self.get_status_error_count = 0
for index in range(0, config.number_heaters, 1):
# print("###### getting status index :",index, "config.number_heaters : ",config.number_heaters)
if self.ip[index] == "not set":
pr(dbug_flag, here, "Smart Plug no ip address for Index : ",
index)
else:
read_results[index] = self.send_command(
read_cmd, self.ip[index], 9999, dbug_flag)
if read_results[index] == "error":
pr(True, here,
"Error connecting for read index: " + str(index),
" IP : " + self.ip[index])
read_results[index] = "error"
self.get_status_error_count += 1
else:
self.do_read_time_taken = self.calculate_time("Do Read")
##pr(True,here,"Result for Read Index : " + str(index), read_results[index])
pr(dbug_flag, here,
"Result for Read Index : " + str(index),
read_results[index])
self.read_received[index] = read_results[index]
self.current[index] = self.get_json(
read_results[index], "current")
self.voltage[index] = self.get_json(
read_results[index], "voltage")
self.power[index] = self.get_json(
read_results[index],
"power") * self.heater_power_scale[index]
self.total[index] = self.get_json(read_results[index],
"total")
info_results[index] = self.send_command(
info_cmd, self.ip[index], 9999, dbug_flag)
if info_results[index] == "error":
pr(True, here,
"Error connecting for info index: " + str(index),
" IP : " + self.ip[index])
info_results[index] = "error"
self.get_status_error_count += 1
else:
self.do_info_time_taken = self.calculate_time("Do Info")
pr(dbug_flag, here,
"Result for Info Index : " + str(index),
info_results[index])
##pr(True,here,"Result for Info Index : " + str(index), info_results[index])
self.state[index] = self.get_json(info_results[index],
"relay_state")
self.error[index] = self.get_json(info_results[index],
"err_code")
pr(
dbug_flag, here,
"Relay, Volts, Amps, Power, Total Power & Error Code for Plug : "
+ str(self.ip[index]),
str(self.state[index]) + " : " +
str(self.voltage[index]) + " : " +
str(self.current[index]) + " : " +
str(self.power[index]) + " : " +
str(self.total[index]) + " : " +
str(self.error[index]))
self.sent[
index] = " Read: " + read_cmd + " : Info: " + info_cmd
self.info_received[index] = info_results[index]
if self.get_status_error_count == 0:
return "Got Status OK"
else:
return "error"
def pr(self, appnd, ref, log_time, refresh_interval):
here = "buffer.pr for " + self.__config.prog_name
make_values = [" -- "] * self.__width
prtime = datetime.now()
for_screen = log_time.strftime('%d/%m/%Y %H:%M:%S')
# following alternative will show more resolution for fractions of a second
# for_screen = log_time.strftime('%d/%m/%Y %H:%M:%S.%f')
make_values[0] = for_screen
file_start = """<head>
<meta http-equiv="refresh" content="""
file_start = file_start + str(refresh_interval)
file_start = file_start + """ />
</head>
<caption>Rotating Buffer Display</caption>"""
tbl_start = """ <p>
<table style="float: left;" border="1">
<tbody>"""
tbl_start_line = """<tr>"""
tbl_end_line = """</tr>"""
tbl_start_col = """<td>"""
tbl_end_col = """</td>"""
tbl_end = """</tbody>
</table>"""
file_end = """
</body>
</html>"""
try:
for i in range(0, self.__width - 1):
make_values[i + 1] = str(self.line_values[i])
for_screen = for_screen + " " + str(self.line_values[i])
except:
print("Error in make values in ...buffer.pr for : ",
self.__config.prog_name)
print("i,values,len(self.line_value>s),self.__width", i,
self.line_values, len(self.line_values), self.__width)
sys_exit()
# print to screen and to status log and update html file
if appnd:
print(" appending : " + self.__config.prog_name + " : " +
for_screen)
else:
print("not appending : " + self.__config.prog_name + " : " +
for_screen)
self.update_buffer(make_values, appnd, ref)
with open(self.__html_filename, 'w') as htmlfile:
htmlfile.write(file_start)
if self.__config.log_buffer_flag:
htmlfile.write(
'<p>' + self.__html_filename + ' : ' +
make_time_text(datetime.now()) + ' ' + '<a href= "' +
self.__config.log_directory + self.__log.log_filename +
'" target="_blank"> View CSV Log File </a></p>\n<p>')
else:
htmlfile.write("<p>" + self.__html_filename + " : " +
make_time_text(datetime.now()) + "</p>\n<p>")
htmlfile.write(tbl_start + tbl_start_line)
for ind in range(0, len(self.__headings)):
htmlfile.write(tbl_start_col + self.__headings[ind] +
tbl_end_col)
htmlfile.write(tbl_end_line)
buffer_dta = self.get_dta()
for ind in range(self.__size):
htmlfile.write(tbl_start_line)
for i in range(self.__width):
htmlfile.write(tbl_start_col + str(buffer_dta[ind][i]) +
tbl_end_col)
htmlfile.write(tbl_end_line)
htmlfile.write(tbl_end)
htmlfile.write(file_end)
try:
copyfile(self.__html_filename, self.__www_filename)
except:
print("Not able to copy : ", self.__html_filename, " to ",
self.__www_filename)
message = self.line_values[1]
try:
self.__mqttc.publish(self.__config.topic, message, retain=True)
self.__mqttc.loop(2) #timeout = 2s
except:
print("Mqtt cant send")
if fileexists(self.__ftp_creds):
if self.__send_html_count >= 3:
# To debug FTP change end of following line to " = True" !!!!!!!!!!!!
FTP_dbug_flag = False
ftp_result = send_by_ftp(FTP_dbug_flag, self.__ftp_creds,
self.__html_filename_save_as,
self.__html_filename, "",
self.__config.ftp_timeout)
for pres_ind in range(0, len(ftp_result)):
pr(FTP_dbug_flag, here,
str(pres_ind) + " : ", ftp_result[pres_ind])
self.__send_html_count = 0
else:
self.__send_html_count += 1
return
def get_temps(self):
# check which sensors are connected and update relavant flags
# build a list of all the new sensors and then add them to the data in use
# note : requires that my_sensors variable is populated
#global my_sensors
#global smartplug_info
#global config
here = "get_temps"
# Look for what sensors are connected
sensors = W1ThermSensor.get_available_sensors()
connected_codes = ["nocodeyet"] * len(sensors)
connected_temp = [-100] * len(sensors)
pr(self.dbug, here, " number seen", len(sensors))
ind = 0
for individual_sensor in W1ThermSensor.get_available_sensors():
#follwoing does not work so commented out
#try:
#individual_sensor.set_precision(config.precision)
#except:
# pr(self.dbug,here, "Cannot Change Precision" , str(individual_sensor.id) )
connected_codes[ind] = individual_sensor.id
try:
connected_temp[ind] = individual_sensor.get_temperature()
except:
pr(self.dbug, here, "Error Reading scanned item",
str(ind) + " : " + individual_sensor.id)
connected_temp[ind] = -100
pr(
self.dbug, here, "Scan of seen sensors",
str(ind) + " : " + connected_codes[ind] + " : " +
str(connected_temp[ind]))
ind += 1
self.number_seen = ind
if len(sensors) > 0:
self.sensor_present = True
pr(self.dbug, here,
"Sensor present Set True with count equal to : ",
str(len(connected_codes)))
else:
pr(self.dbug, here,
"Sensor present not Set with count equal to : ",
str(len(connected_codes)))
self.sensor_present = False
new_codes = []
self.ref_sensor_index = -1
for my_sensor_count in range(0, len(self.code)):
self.code_seen[my_sensor_count] = False
self.reading[my_sensor_count] = -100 # signal that no data seen
self.error_number[my_sensor_count] += 1
for seen_count in range(0, self.number_seen):
if connected_codes[seen_count] == self.code[my_sensor_count]:
# set flag to indicate has been seen during this run of program
pr(
self.dbug, here, "Scanning My Count, seen count ",
str(my_sensor_count) + " :" + str(seen_count) + " : " +
str(connected_temp[seen_count]))
self.code_seen[my_sensor_count] = True
self.connected[my_sensor_count] = True
self.error_number[
my_sensor_count] = 0 # signal that its not in error
if connected_temp[seen_count] != -100:
# codeget_temps there but not ready to be read
self.reading[my_sensor_count] = connected_temp[
seen_count] # copy across id temp found
else:
self.reading[my_sensor_count] = -100
self.code_seen[my_sensor_count] = False
self.error_number[my_sensor_count] = 1
if self.code[my_sensor_count] == self.sensor4readings:
self.ref_sensor_index = my_sensor_count
self.code_seen_but_disconnected[my_sensor_count] = False
count_connected = 0
new_codes = []
for element in connected_codes:
if not element in self.code:
new_codes.append(element)
count_connected += 1
if len(new_codes) > 0:
pr(self.dbug, here, str(len(new_codes)), " new sensors found")
new_ind = 0 # index for new_codes
start_entering_data = self.width
end_at = self.width + len(new_codes)
self.width = end_at # the number sensors whose data stored and pointer where put next
for ind in range(start_entering_data, end_at):
if ind > self.max_width:
print("Too Many sensors, new ones not added")
break
#if len(self.number) > 0:
# self.number.append("n" + str(count_connected-len(new_codes)+ind+1))
#else:
# self.number.append("n" + str(1))
print("for debug; ind : ", ind)
self.number[ind] = "nxx"
self.code[ind] = new_codes[new_ind]
self.connected[ind] = True
self.reading[ind] = -102
self.last_logged[ind] = -102
self.code_seen[ind] = True
self.code_seen_but_disconnected[ind] = False
self.location[ind] = "Lxx"
self.stype[ind] = "Txx"
self.comment[ind] = "Ccc"
self.delay[ind] = 0
self.error_number[ind] = 2
self.status_text[ind] = "New"
self.last_logged_error_number[ind] = 2
new_ind += 1
else:
pr(self.dbug, here, "no new codes, still only : ",
str(count_connected) + " connected")
return (len(new_codes))
def send_html_by_ftp(self, config, smartplug_info, target_temp,
target_full_power):
here = "sensors.send_by_ftp"
ftp_text_linestart = "<tr align=\"center\" valign=\"middle\"><td>"
ftp_text_line_end = "</td></tr>"
ftp_text_end = ["</tbody>"]
ftp_text_between = "</td><td>"
ftp_start = """<!--
Temperature Logging and Control
-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.oset_log_html_filenamerg/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Temperature Logging and Control</title>
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<meta http-equiv="refresh" content="15" />
</head>
<body><table style="background-color: #f4e7e7; width: 350px; height: 150px; border: 1px solid #1b58e4;\" cellpadding=\"5\" align=\"center\">
<caption>Temperatures Logging</caption><tbody>"""
ftp_end = """</td></tr>
</table>")
</body>
</html>"""
if self.__html_filename == "not_set":
pr(self.dbug, here, "Error", "html filename not set")
if self.__www_filename == "not_set":
pr(self.dbug, here, "Error", "html filename not set")
if self.__ftp_creds == "not_set":
pr(self.dbug, here, "Error", "html filename not set")
with open(self.__html_filename, 'w') as htmlfile:
htmlfile.write(ftp_start)
htmlfile.write(ftp_text_linestart + " Program Name: " + ftp_text_between \
+ config.prog_name + ftp_text_line_end)
htmlfile.write(ftp_text_linestart + " Scan Count: " + ftp_text_between \
+ str(config.scan_count) + ftp_text_line_end)
htmlfile.write(ftp_text_linestart + " System Time: " + ftp_text_between \
+ make_time_text(datetime.now()) + ftp_text_line_end)
htmlfile.write(ftp_text_linestart + " Html Log File: " + ftp_text_between \
+ "<a href=\"" + self.__log_html_filename + "\" target = \"_blank\">" \
+ self.__log_html_filename + "</a>" + ftp_text_line_end)
htmlfile.write(ftp_text_linestart + " Status File: " + ftp_text_between + "<a href=\"" + \
str(self.__status_html_filename) + "\" target = \"_blank\">" + \
str(self.__status_html_filename) + "</a>" + ftp_text_line_end)
htmlfile.write(ftp_text_linestart + " Debug File: " + ftp_text_between + "<a href=\"" + \
str("debug.html") + "\" target = \"_blank\">" + \
str("debug.html") + "</a>" + ftp_text_line_end)
htmlfile.write(ftp_text_linestart + " WD Log File: " + ftp_text_between + "<a href=\"" + \
str("wd_log.html") + "\" target = \"_blank\">" + \
str("wd_log.html") + "</a>" + ftp_text_line_end)
htmlfile.write(ftp_text_linestart + " CSV Log File: " +
ftp_text_between + "<a href=" + "\"" +
str(self.__log_filename_save_as) + "\"" +
"target = \"_blank\">" + str(self.__log_filename) +
"</a>" + ftp_text_line_end)
s_numb = 0
for element in self.number:
htmlfile.write(ftp_text_linestart + str(element) + ftp_text_between + str(self.location[s_numb]) + \
ftp_text_between + str(self.status_text[s_numb]) + ftp_text_line_end)
s_numb += 1
if config.sauna:
htmlfile.write(ftp_text_linestart + "Sauna" + ftp_text_between + "Target/Offset/On" + \
ftp_text_between + "{0:.4}/{1:.4}/{2:.4}".format( \
float(config.default_target),float(config.target_offset),float(config.percent_full_power * config.sauna_on)) + \
ftp_text_line_end)
else:
htmlfile.write(ftp_text_linestart + "Plug 1 Power and Total" +
ftp_text_between +
str(smartplug_info.power[0]) +
ftp_text_between +
str(smartplug_info.total[0]) +
ftp_text_line_end)
htmlfile.write(ftp_text_linestart + "Plug 2 Power and Total" +
ftp_text_between +
str(smartplug_info.power[1]) +
ftp_text_between +
str(smartplug_info.total[1]) +
ftp_text_line_end)
htmlfile.write(ftp_text_linestart + "Scheduled" +
ftp_text_between + "Target Temp : " +
ftp_text_between + str(target_temp) +
ftp_text_line_end)
htmlfile.write(ftp_text_linestart + "Scheduled" +
ftp_text_between + "Target Full Power : " +
ftp_text_between + str(target_full_power) +
ftp_text_line_end)
for element in ftp_text_end:
htmlfile.write(element)
# Change "False" to "True" on next line to debug FTP
FTP_dbug_flag = False
ftp_result = send_by_ftp(FTP_dbug_flag, self.__ftp_creds,
self.__html_filename, "index.html", "",
config.ftp_timeout)
for pres_ind in range(0, len(ftp_result)):
pr(FTP_dbug_flag, here,
str(pres_ind) + " : ", ftp_result[pres_ind])
try:
# send the same html file to the local web site
copyfile(self.__html_filename, self.__www_filename)
pr(self.dbug, 0, "Sent : " + config.html_filename + " to : ",
config.local_www_html_filename)
except:
pr(self.dbug, 0,
"Fail with copy " + config.html_filename + " to : ",
config.local_www_html_filename)
