def loop_read(self): sensor_repo = SensorRepository() sensors = sensor_repo.get_all_sensors() if len(sensors) == 0: raise Exception("No sensors found! Check '/sys/bus/w1/devices/' for sensor devices, you may have to run sudo modprobe w1-gpio/therm") reader = TempReader(sensors) self.truncate_temp_logs(self.log_file, self.max_lines) self.file_writer.append_to_end_of_file("---------- Temp Logging Started {0} ----------\n".format(self.get_time_now())) while True: try: temps = reader.read_temps() avg_temp = reader.get_average_temp() time = self.get_time_now() index = 0 for temp in temps: index += 1 temp_string = u"Sensor {0} - time: {1} | temp: {2}{3}\n".\ format(index, time, str(temp), u"\u00b0"+'C') #print temp_string.encode("UTF-8") self.file_writer.append_to_end_of_file(temp_string) avg_temp_string = u"\t({0}) Average temp: {1}{2}\n".format(time, str(avg_temp), u"\u00b0"+'C') self.file_writer.append_to_end_of_file(avg_temp_string) self.truncate_temp_logs(self.log_file, self.max_lines) sleep(10) except (KeyboardInterrupt, SystemExit): print 'Stopping writing to temp logs now! Adding end marker to temp file' self.file_writer.append_to_end_of_file("---------- Temp Logging Stopped ----------\n") raise
def __init__(self, time_units=1): self.time_units = time_units self.temp_reader = TempReader() self.comparer = TempComparer() self.state = ControllerState.CORRECT self.controller_thread = Thread(target=self.main_loop) self.state_controller = StateController() self.database_client = InfluxDBClient(host="localhost", port=8086, database="ferm_data")
def __init__(self): #self.steps = [] self.current_temp = 0 self.current_step = None #self.current_step_count = 0 self.current_start_time = None self.current_step_length = None self.step_end_time = None self.temp_reader = TempReader() self.pin_controller = PinController() self.temp_comparer = TempComparer() self.tick_interval = 1 self.running = False self.loop_thread = Thread(target=self.main_loop) self.loop_thread.start()
def main(): # stop_event = Event() # stop_event.clear() str_port_list = ["/dev/ttyUSB0", "/dev/ttyUSB1", "/dev/ttyUSB2"] temp_reader = [None, None, None] rate = 115200 for i, str_port in enumerate(str_port_list): save_file = f"output_{i}.txt" temp_reader[i] = TempReader(str_port=str_port, rate=rate, save_file=save_file) # ssr[] temp_reader[i].start() time.sleep(10) # keyboard.wait("esc") # stop_event.set() # time.sleep(3) for i, str_port in enumerate(str_port_list): # temp_reader[i].join() print('exiting at temp_reader.join') temp_reader[i].close() time.sleep(1) sys.exit()
class FermentationController: def __init__(self, time_units=1): self.time_units = time_units self.temp_reader = TempReader() self.comparer = TempComparer() self.state = ControllerState.CORRECT self.controller_thread = Thread(target=self.main_loop) self.state_controller = StateController() self.database_client = InfluxDBClient(host="localhost", port=8086, database="ferm_data") def write_to_database(self, current_temp, current_state): new_point = [{ "measurement": "ferm-temp", "tags": { "recipe-id": 1, }, "time": datetime.datetime.now().isoformat(), "fields": { "temp-reading": current_temp, "hold-temp": self.comparer.get_hold_temp(), "state": current_state.name } }] return self.database_client.write_points(new_point) def set_step(self, step): self.comparer.set_hold_temp(step["hold_temp"]) self.comparer.set_temp_range(step["temp_range"]) return self.get_step() def update_step(self, update): return self.get_step() def get_step(self): return { "hold_temp": self.comparer.get_hold_temp(), "temp_range": self.comparer.get_temp_range() } def run(self): print("Running") try: self.controller_thread.start() return True except RuntimeError: return False def main_loop(self): print("main loop") while True: current_temp = self.temp_reader.get_current_temp() new_state = self.comparer.compare_temps(current_temp, self.state) self.state = new_state self.state_controller.set_state(self.state) self.write_to_database(current_temp, self.state) print(current_temp, self.state) time.sleep(self.time_units)
class TemperatureController: def __init__(self, target_temp=65, temp_range=1): self.reader = TempReader() self.target_temp = target_temp self.temp_range = temp_range self.current_mode = TempControllerStatus.CORRECT def set_target_temp(self, new_target_temp): self.target_temp = new_target_temp def get_target_temp(self): return self.target_temp def set_temp_range(self, new_temp_range): self.temp_range = new_temp_range def get_temp_range(self): return self.temp_range def compare_temp(self): current_temp = self.reader.get_temp_reading() if current_temp > self.target_temp + self.temp_range and self.current_mode != TempControllerStatus.COOLER: self.turn_cooler_on() elif current_temp < self.target_temp - self.temp_range and self.current_mode != TempControllerStatus.HEATER: self.turn_heater_on() elif current_temp > self.target_temp: self.turn_cooler_on() elif current_temp < self.target_temp: self.turn_heater_on() else: self.correct_temp() return current_temp, self.target_temp, self.current_mode.name def turn_cooler_on(self): if self.current_mode == TempControllerStatus.COOLER: return self.current_mode = TempControllerStatus.COOLER def turn_heater_on(self): if self.current_mode == TempControllerStatus.HEATER: return self.current_mode = TempControllerStatus.HEATER def correct_temp(self): if self.current_mode == TempControllerStatus.CORRECT: return self.current_mode = TempControllerStatus.CORRECT def error_mode(self): print('There was an error') pass
def main(): """ with open("./config.json", mode="r") as fr: conf_dict = json.load(fr) print(conf_dict) exit() """ q_tc_temp = queue.Queue() # stop_event = Event() # stop_event.clear() str_port_list = ["/dev/ttyUSB0"] list_temp_reader = [] rate = 115200 for i, str_port in enumerate(str_port_list): save_file = f"output_{i}.txt" temp_reader = TempReader(str_port=str_port, rate=rate, save_file=save_file, q_tc_temp=q_tc_temp) temp_reader.start() list_temp_reader.append(temp_reader) time.sleep(1) # SSR制御スレッド # pin number is as on the RsPi4 board #ssr_pins = [2, 3, 4, 10, 9,11, 5,6,13,19,26, 14,15,18] # SSR PWM output pins ssr_pins = [2, 3, 4, 9] #{201122} #system configulation {201117} sys_config={ "items":("key: =group_numnerof heater and thermo-couple", ("ssr_pins"),("Tc's") ), "g1":( (2, 4), (0, 2) ), "g2":( (3, 9), (1, 3) ), } g="g1" print(f"sys_config= {sys_config[g]}") # スレッド起動 list_ssr = [] for i, pin_num in enumerate(ssr_pins): ssr = SsrController(pin_num, q_tc_temp=q_tc_temp) ssr.start() list_ssr.append(ssr) try: while True: time.sleep(1) # print(f"que_len: {q_tc_temp.qsize()}") pass except KeyboardInterrupt: # Ctrl-C print('interrupted!') # SSR を先に止める for i, ssr in enumerate(list_ssr): # print (f"exiting at ssr.join({i})") ssr.close() time.sleep(0.1) time.sleep(1) for i, temp_reader in enumerate(list_temp_reader): # print (f"exiting at temp_reader.join({i})") temp_reader.close() time.sleep(0.1) GPIO.cleanup() time.sleep(1) print("call exit!") exit()
def main(): with open("./config.json", mode="r") as fr: config = json.load(fr) print(config) rate = 115200 # 通信レート # 温度用キュー(現在:全て同じキューを使用) """ (以下、変数の中身の例) str.port= /dev/ttyUSB0 tc_readers_dictというスレッドの立ち上がり: tc_readers_dict (スレッド)== {'/dev/ttyUSB0': <TempReader(Thread-1, started 1985582176)>} """ q_maxlen = 20 tc_readers_dict = {} for str_port in config["Tc"].keys(): print("tc_reader USB port=", str_port) tc_index = config["Tc"][str_port]["index"] # ジェイソン使って順番を指定してもらう。Kメモ{210103} save_file = f"output_{str_port[-1]}.txt" tc_readers_dict[str_port] = TempReader( str_port=str_port, rate=rate, tc_index=tc_index, q_maxlen=q_maxlen, save_file=save_file ) # とにかく、順番に、温度を読んでくる。Kメモ{210103} tc_readers_dict[str_port].start() # スレッドを起動 time.sleep(1) print("tc_readers_dictというスレッドの立ち上がり") #Kinoshita{210102} print("str.port=", str_port) #Kinoshita{210102} print("jsonからの情報の持ち込み方を見たい:") #Kinoshita{210102} print("tc_readers_dict (スレッド)== ",tc_readers_dict) #Kinoshita{210102} # SSR制御スレッド # スレッド起動 """ SSR のスレッドは以下のように立ち上がる: ssr_group_dict= { 0: <SsrDriver(Thread-2, started 1975514208)>, 1: <SsrDriver(Thread-3, started 1965028448)>, 2: <SsrDriver(Thread-4, started 1954542688)>, 3: <SsrDriver(Thread-5, started 1944056928)>} """ ssr_group_dict = {} # SSRの各々で現時点では、{210104} ループしている # confis.jsonで指定した、Groupでの ループにする方向ではないかとおもう。 for i, target_pin in enumerate(config["SSR"]): #ここでGroup別にイテレーションLoopに。{201212} ssr_group_dict[i] = SsrDriver( target_pin, tc_readers_dict=tc_readers_dict ) ssr_group_dict[i].start() #ここで起動1 print("SsrDriverへの情報伝達を見たい:") #Kinoshita{210103} print("ssr_group_dict (スレッド)==",ssr_group_dict) #Kinoshita{210103} print() print("ssr_group_dict.keys()=",ssr_group_dict.keys()) #Kinoshita{210103} # ここから Ctrl-C が押されるまで無限ループ try: while True: # ここに処理を記載 time.sleep(1) # 例 """ 支配層と被支配層とに分けて「ロジック」(やりたいこと)を書き込むのではなくて やりたいことを表現する場を、上手に、被支配層と支配層とを突き抜けて、用意する方法を うまくつくっていく。そういう技法を身に着けなければいけない。 複雑なことを、どう整理するか、 UML 図 を描いてみようと思います。 Kコメント{210103} """ #目標温度をGroup別に。現時点 {210104} では SSRに一対一対応している。 ssr_group_dict[0].set_target_temp(40) ssr_group_dict[1].set_target_temp(40) ssr_group_dict[2].set_target_temp(40) ssr_group_dict[3].set_target_temp(40) # print(f"que_len: {q_tc_temp.qsize()}") pass except KeyboardInterrupt: # Ctrl-C print('interrupted!') # SSRスレッド終了処理 ※先に止める for i, ssr in enumerate(ssr_group_dict.keys()): #現時点では、SSRのここに対応している。 # print (f"exiting at ssr.join({i})") ssr_group_dict[ssr].close() time.sleep(0.1) time.sleep(1) # 温度取得スレッド終了処理 for i, str_port in enumerate(tc_readers_dict.keys()): # print (f"exiting at temp_reader.join({i})") tc_readers_dict[str_port].close() time.sleep(0.1) GPIO.cleanup() time.sleep(1) print("call exit!") exit()
def __init__(self, target_temp=65, temp_range=1): self.reader = TempReader() self.target_temp = target_temp self.temp_range = temp_range self.current_mode = TempControllerStatus.CORRECT
class Controller: def init_gpio(self): o_states = {} GPIO.setmode(GPIO.BOARD) for ioConfig in self.config.io: if ioConfig.mode == 'CONTROLLER': GPIO.setup(ioConfig.o_pin, GPIO.OUT) o_states[ioConfig.o_pin] = 0 else: o_states[ioConfig.o_pin] = None return o_states def __init__(self, config_path): self.config_path = config_path self.config = Config(config_path) self.tempReader = TempReader() self.o_states = self.init_gpio() def refresh_config(self): try: self.config = Config(self.config_path) except: print "Error: Unable to update configuration file." def cur_dt_str(self): return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) def control(self, ioConfig): temp_c, temp_f = self.tempReader.read_temp(ioConfig.i_path) if ioConfig.mode == 'CONTROLLER': if (temp_c == 0.0 and temp_f == 0.0): #Temp probe not plugged in GPIO.output(ioConfig.o_pin, False) self.o_states[ioConfig.o_pin] = 0 elif ( ioConfig.on_fn(temp_f) ): GPIO.output(ioConfig.o_pin, True) self.o_states[ioConfig.o_pin] = 1 elif (ioConfig.off_fn(temp_f)): GPIO.output(ioConfig.o_pin, False) self.o_states[ioConfig.o_pin] = 0 return temp_f def run(self): while True: log_lst = [self.cur_dt_str()] for ioConfig in self.config.io: cur_temp = self.control(ioConfig) log_lst.append(str(cur_temp)) log_lst.append(str(ioConfig.set_temp)) log_lst.append(str(self.o_states[ioConfig.o_pin])) log_line = '\t'.join(log_lst) print log_line f = open(self.config.log_path, 'a') f.write(log_line) f.write('\n') f.close() time.sleep(5) self.refresh_config()
def __init__(self, config_path): self.config_path = config_path self.config = Config(config_path) self.tempReader = TempReader() self.o_states = self.init_gpio()
from linear_fan_control import LinearFanControl from temp_reader import TempReader from rpm_reader import RPMReader from wifi import connect_wifi from metrics import send_metrics from machine import Pin connect_wifi() lfc_in = LinearFanControl(pwm_pin=23, min_temp=23, max_temp=30) lfc_out = LinearFanControl(pwm_pin=18, min_temp=23, max_temp=30) rpm_in = RPMReader(rpm_pin=22) rpm_out = RPMReader(rpm_pin=5) temp_reader = TempReader(pin=19) # temp_reader_2 = TempReader(pin=16) fan_switch = Pin(21, Pin.OUT) fan_switch_2 = Pin(17, Pin.OUT) while True: temp = 100 temp2 = 100 try: temps = list(temp_reader.read_temps()) temp = temps[0] temp2 = temps[1] except Exception: pass if temp < lfc_out.min_temp:
def main(): with open("./config.json", mode="r") as fr: config = json.load(fr) print(config) rate = 115200 # 通信レート # 温度用キュー(現在:全て同じキューを使用) q_maxsize = 200 tc_queue_dict = {} tc_readers_dict = {} for str_port in config["Tc"].keys(): print(str_port) tc_queue_dict[str_port] = {} for idx in config["Tc"][str_port]["index"]: tc_queue_dict[str_port][idx] = queue.Queue(maxsize=q_maxsize) save_file = f"output_{str_port[-4]}.txt" tc_readers_dict[str_port] = TempReader(str_port=str_port, rate=rate, save_file=save_file, tc_queue_dict=tc_queue_dict) tc_readers_dict[str_port].start() # スレッドを起動 time.sleep(1) # SSR制御スレッド # スレッド起動 ssr_group_dict = {} for i, group in enumerate(config["SSR"]): ssr_group_dict[i] = SsrDriver(group, tc_queue_dict=tc_queue_dict) ssr_group_dict[i].start() # ここから Ctrl-C が押されるまで無限ループ try: while True: # ここに処理を記載 time.sleep(1) # 例 ssr_group_dict[0].set_target_temp(200) ssr_group_dict[1].set_target_temp(200) # print(f"que_len: {q_tc_temp.qsize()}") pass except KeyboardInterrupt: # Ctrl-C print('interrupted!') # SSRスレッド終了処理 ※先に止める for i, ssr in enumerate(ssr_group_dict.keys()): # print (f"exiting at ssr.join({i})") ssr_group_dict[ssr].close() time.sleep(0.1) time.sleep(1) # 温度取得スレッド終了処理 for i, str_port in enumerate(tc_readers_dict.keys()): # print (f"exiting at temp_reader.join({i})") tc_readers_dict[str_port]["reader"].close() time.sleep(0.1) GPIO.cleanup() time.sleep(1) print("call exit!") exit()
class BrewhouseController: def __init__(self): #self.steps = [] self.current_temp = 0 self.current_step = None #self.current_step_count = 0 self.current_start_time = None self.current_step_length = None self.step_end_time = None self.temp_reader = TempReader() self.pin_controller = PinController() self.temp_comparer = TempComparer() self.tick_interval = 1 self.running = False self.loop_thread = Thread(target=self.main_loop) self.loop_thread.start() def broadcast_data(self): if self.running and self.current_step is not None: time_remaining = self.step_end_time - datetime.now() minutes = str((time_remaining.seconds // 60) % 60).zfill(2) seconds = str(time_remaining.seconds % 60).zfill(2) return { "currentTemp": self.current_temp, "running": self.running, "currentStep": self.current_step, "timeRemaining": "{}:{}".format(minutes, seconds) } else: return { "currentTemp": self.current_temp, "running": self.running, "currentStep": self.current_step, "timeRemaining": None } # def set_steps(self, steps): # self.steps = steps # return self.steps def set_step(self, step): self.current_step = step return self.current_step # def get_steps(self): # return self.steps def get_current_step(self): return self.current_step # def get_step_by_index(self, index): # try: # step = self.steps[index] # return step # except IndexError: # return None # def update_step(self, index, step): # try: # self.steps[index] = step # except IndexError: # return None def delete_step(self, index): try: del self.steps[index] return True except IndexError: return False def start(self): if not self.running and self.current_step is not None: self.step_end_time = datetime.now() + timedelta( minutes=self.current_step["holdTime"]) print(self.step_end_time) self.running = True return True else: return False def stop(self): if self.running: self.current_step = None self.running = False self.loop_thread = Thread(target=self.main_loop) return True else: return False def pause(self): pass def get_pump_state(self, id): pump_state = self.pin_controller.get_pump_state(id) return pump_state def cycle_pump_state(self, id): return self.pin_controller.cycle_pump_state(id) # def next_step(self): # self.current_step = self.steps[self.current_step_count] # self.current_start_time = datetime.datetime.now() # self.current_step_length = datetime.timedelta(minutes=self.steps[self.current_step_count]["hold_time"]) # self.current_end_time = self.current_start_time + self.current_step_length # self.temp_comparer.set_hold_temp(self.steps[self.current_step_count]["start_temp"]) def main_loop(self): try: while True: self.current_temp = self.temp_reader.get_current_temp() if self.running: new_state = self.temp_comparer.compare_temps( self.current_temp, self.pin_controller.get_heater_pin()) self.pin_controller.cycle_heater(new_state) if datetime.now() > self.step_end_time: self.current_step = None self.running = False time.sleep(1) except Exception as e: print(e) finally: PinController.cleanup()