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")
Example #3
0
 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()
Example #4
0
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)
Example #6
0
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
Example #7
0
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()
Example #8
0
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()
Example #9
0
 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()
Example #12
0
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:
Example #13
0
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()
Example #14
0
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()