def temperature(): CLK = 25 DO = 18 CS1 = 24 CS2 = 23 sensor1 = MAX31855.MAX31855(CLK, CS1, DO) sensor2 = MAX31855.MAX31855(CLK, CS2, DO) temp1 = sensor1.readTempC() temp2 = sensor2.readTempC() return {'Bearing': temp1, 'Motor': temp2}
def temperature(): # Raspberry Pi software SPI configuration. CLK = 25 CS1 = 23 CS2 = 24 DO = 18 sensor1 = MAX31855.MAX31855(CLK, CS1, DO) sensor2 = MAX31855.MAX31855(CLK, CS2, DO) temp1 = sensor1.readTempC() internal1 = sensor1.readInternalC() temp2 = sensor2.readTempC() internal2 = sensor2.readInternalC() #print('Thermocouple Temperature: {0:0.3F}*C / {1:0.3F}*F'.format(temp, c_to_f(temp))) return temp1, temp2
def __init__(self, spi, tempSensorId, clk=None, cs=None, do=None): if spi == "hardware": # Raspberry Pi hardware SPI configuration. SPI_PORT = 0 SPI_DEVICE = 0 self.sensor = MAX31855.MAX31855( spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) elif spi == "gpio": self.sensor = MAX31855.MAX31855(clk, cs, do) else: print "ABORT!!!" self.tempSensorId = tempSensorId self.sensorNum = TempMAX31855.numSensor TempMAX31855.numSensor += 1 print("Constructing MAX31855 sensor %s" % (tempSensorId))
def readTemp(): global tEngHist # global tIntHist global tEngine global tInternal tEngArr = [] tIntArr = [] counter = 0 engCounter = 0 intCounter = 0 t = 0 CLK = 5 CS = 23 DO = 18 tempSensor = MAX31855.MAX31855(CLK, CS, DO) while True: tEngineNow = tempSensor.readTempC() if (tEngineNow == tEngineNow): tEngArr.append(tEngineNow) engCounter += 1 tInternalNow = tempSensor.readInternalC() if (tInternalNow == tInternalNow): tIntArr.append(tInternalNow) intCounter += 1 counter += 1 if (tEngineNow == tEngineNow): tEngine = tEngineNow if (counter == 60): if (engCounter > 0): tEngine = sum(tEngArr) / engCounter if (intCounter > 0): tInternal = sum(tIntArr) / intCounter if (tEngine < 0): tEngHist.append((t + 2, 53)) elif (tEngine > 800): tEngHist.append((t + 2, 53 - 20)) else: tEngHist.append((t + 2, 53 - 20 * (tEngine / 800))) # if (tInternal < 0): # tIntHist.append((t + 65, 53)) # elif (tInternal > 50): # tIntHist.append((t + 65, 53 - 20)) # else: # tIntHist.append((t + 65, 53 - 20*(tInternal/50))) t += 1 tEngArr = [] tIntArr = [] engCounter = 0 intCounter = 0 counter = 0 if (len(tEngHist) > 124): del tEngHist[0] tEngHist = setArrayTime(2, tEngHist) # if (len(tIntHist) > 60): # del tIntHist[0] # tIntHist = setArrayTime(65, tIntHist) sleep(0.5)
def temperature(): # Raspberry Pi software SPI configuration. CLK = 25 CS = 24 DO = 18 sensor = MAX31855.MAX31855(CLK, CS, DO) temp = sensor.readTempC() internal = sensor.readInternalC() #print('Thermocouple Temperature: {0:0.3F}*C / {1:0.3F}*F'.format(temp, c_to_f(temp))) return temp
def getTC2Data(): CLK = 22 CS = 27 DO = 17 sensor = MAX31855.MAX31855(CLK, CS, DO) temp = sensor.readTempC() internal = sensor.readInternalC() tempf = c_to_f(temp) internalf = c_to_f(internal) return tempf, internalf
def __init__(self, logging_period): __clk_pin = 17 __cs_pin = 27 __do_pin = 22 # logging period is provided in seconds self.logging_period = logging_period self.sensor = MAX31855.MAX31855(__clk_pin, __cs_pin, __do_pin) self.current_reading = ''
def __init__(self, PLOTSEC=600, outfname='stripchartTemp'): self.PLOTSEC = 10 #PLOTSEC #720 # 12 minute sessions for x axis self.QUITS = ("q", "Q") self.STARTIN = ('I', 'i') self.ENDIN = ('E', 'e') # Uncomment one of the blocks of code below to configure your Pi or BBB to use # software or hardware SPI. # Raspberry Pi software SPI configuration. #CLK = 25 #CS = 24 #DO = 18 #sensor = MAX31855.MAX31855(CLK, CS, DO) # Raspberry Pi hardware SPI configuration. self.SPI_PORT = 0 self.SPI_DEVICE = 0 self.sensor = MAX31855.MAX31855( spi=SPI.SpiDev(self.SPI_PORT, self.SPI_DEVICE)) # BeagleBone Black software SPI configuration. #CLK = 'P9_12' #CS = 'P9_15' #DO = 'P9_23' #sensor = MAX31855.MAX31855(CLK, CS, DO) # BeagleBone Black hardware SPI configuration. #SPI_PORT = 1 #SPI_DEVICE = 0 #sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) self.ts = self.getTempStream() self.outf = open('%s.xls' % outfname, 'w') self.savepng = '%s.png' % outfname self.outf.write('Second\tTemperature\n') # set up a generator for PLOTSEC seconds of sampling style.use('ggplot') # prepopulate arrays to make updates quicker self.t = range(self.PLOTSEC + 2) self.y = [None for i in self.t] self.fig, self.ax = plt.subplots() #self.ax.set_xlim(auto=True) #self.ax.set_ylim(auto=True) # fig.canvas.mpl_connect('key_press_event', press) self.line, = self.ax.plot(0, 0, lw=1) self.text_template = 'Last temperature = %3.2f' self.title_template = 'Temperature strip chart at %d seconds' self.t_temp = self.ax.text(0.15, 0.15, self.text_template % (0), transform=self.ax.transAxes, family='monospace', fontsize=10) #self.t_title = self.ax.text(0.5,1.0,self.title_template%(0), # transform=self.ax.transAxes, family='monospace',fontsize=20) self.started = time.time()
def __init__(self, CLK, CS, DO): Thread.__init__(self) self.CLK = CLK self.CS = CS self.DO = DO self.val = 0 self.modif = 0 self.valide = 0 self.dont_stop = 1 self.lastT = [] self.mm = 0 self.sensor = MAX31855.MAX31855(self.CLK, self.CS, self.DO)
def init(self): # Hardware configuration: try: # Create an MAX31855 instance. self.MAX31855 = MAX31855.MAX31855(spi=SPI.SpiDev(0, self.ce)) except Exception as e: print("MAX31855Config: Error initialising device - exit") print(str(e)) sys.exit(1) # provide configuration parameters self.ChanNams = ['MAX31855']
def __init__(self, clk, cs, do, testing=False): super(MAX31855Sensor, self).__init__() self.logger = logging.getLogger("mycodo.inputs.max31855") self._temperature = None self._temperature_die = None self.clk = clk self.cs = cs self.do = do if not testing: import Adafruit_MAX31855.MAX31855 as MAX31855 self.sensor = MAX31855.MAX31855(clk, cs, do)
def temperature(): # Raspberry Pi software SPI configuration. CLK = 25 CS = 24 DO = 18 sensor = MAX31855.MAX31855(CLK, CS, DO) temp = sensor.readTempC() if np.isnan(temp) == True: temp = None else: pass return temp
def __init__(self, input_dev, testing=False): super(InputModule, self).__init__(input_dev, testing=testing, name=__name__) if not testing: import Adafruit_MAX31855.MAX31855 as MAX31855 self.pin_clock = input_dev.pin_clock self.pin_cs = input_dev.pin_cs self.pin_miso = input_dev.pin_miso self.sensor = MAX31855.MAX31855(self.pin_clock, self.pin_cs, self.pin_miso)
def __init__(self, input_dev, testing=False): super(MAX31855Sensor, self).__init__() self.logger = logging.getLogger("mycodo.inputs.max31855") self._temperature = None self._temperature_die = None if not testing: import Adafruit_MAX31855.MAX31855 as MAX31855 self.logger = logging.getLogger( "mycodo.inputs.max31855_{id}".format(id=input_dev.id)) self.pin_clock = input_dev.pin_clock self.pin_cs = input_dev.pin_cs self.pin_miso = input_dev.pin_miso self.convert_to_unit = input_dev.convert_to_unit self.sensor = MAX31855.MAX31855(self.pin_clock, self.pin_cs, self.pin_miso)
def __init__(self, input_dev, testing=False): super(InputModule, self).__init__() self.setup_logger(testing=testing, name=__name__, input_dev=input_dev) if not testing: import Adafruit_MAX31855.MAX31855 as MAX31855 self.device_measurements = db_retrieve_table_daemon( DeviceMeasurements).filter( DeviceMeasurements.device_id == input_dev.unique_id) self.pin_clock = input_dev.pin_clock self.pin_cs = input_dev.pin_cs self.pin_miso = input_dev.pin_miso self.sensor = MAX31855.MAX31855(self.pin_clock, self.pin_cs, self.pin_miso)
def temperatureloop(): # Raspberry Pi software SPI configuration. CLK = 25 DO = 18 #Comms pin for TCs CS = 4, 17, 27, 22 lst = [] for i in CS: sensor = MAX31855.MAX31855(CLK, i, DO) temp = sensor.readTempC() if np.isnan(temp) == True: temp = None lst.append(temp) return lst
def main(): # Get bus address if provided or use default address SPI_DEVICE = 0 if len(sys.argv) >= 2: SPI_DEVICE = int(sys.argv[1], 0) if not 0 <= SPI_DEVICE <= 1: raise ValueError("Invalid address value") # Raspberry Pi hardware SPI configuration. SPI_PORT = 0 sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) temp = sensor.readTempC() print('{0:0.1f}'.format(temp))
def senseTemperatures(): sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) timeStart = time.time() transmitter = TransmitterSingleSocket() try: while True: timeNow = time.time() timeVal = timeNow - timeStart tempInC = sensor.readTempC() internalTempInC = sensor.readInternalC() transmitter.sendDataPoint(SENSOR_TC, timeVal, tempInC) transmitter.sendDataPoint(SENSOR_INTERNAL, timeVal, internalTempInC) time.sleep(0.05) except KeyboardInterrupt: transmitter.signalEnd() transmitter.close()
def termo(q2, q): CONSECUTIVO = 0 CLK = 25 CS = 24 DO = 18 sensor = MAX31855.MAX31855(CLK, CS, DO) mariadb_connection = mariadb.connect(user='******', password='******', database='SENSORS') cursor = mariadb_connection.cursor() cont_to_store = 0 while True: temp = sensor.readTempC() - 30 #print('Thermocouple Temperature: {0:0.3F}*C '.format(temp)) q2.put(temp) #q.get() time.sleep(1) cont_to_store = cont_to_store + 1 if cont_to_store == 60: try: cursor.execute( "INSERT INTO temperature (consecutive, temperature_hot, temperature_cold) VALUES (%s, %s,%s)", (CONSECUTIVO, temp, ceil(q.get() * 100) / 100)) mariadb_connection.commit() #print "The last inserted id was: ", cursor.lastrowid #cursor.execute("INSERT INTO employees (first_name,last_name) VALUES (%s,%s)", ('Maria','DB')) #INSERT INTO products_tbl (product_name,product_manufacturer) VALUES ('6789','Orbitron 4010')", ('6789','Orbitron 4010') except mariadb.Error as error: print("Error: {}".format(error)) cont_to_store = 0 myFile = open('/home/pi/SENSORS.csv', 'a') with myFile: writer = csv.writer(myFile) myData = [[ CONSECUTIVO, temp, ceil(q.get() * 100) / 100, time.strftime("%x") + " " + time.strftime("%X") ]] writer.writerows(myData)
def __init__(self, input_dev, testing=False): super(InputModule, self).__init__() self.logger = logging.getLogger("mycodo.inputs.max31855") if not testing: import Adafruit_MAX31855.MAX31855 as MAX31855 self.logger = logging.getLogger("mycodo.max31855_{id}".format( id=input_dev.unique_id.split('-')[0])) self.device_measurements = db_retrieve_table_daemon( DeviceMeasurements).filter( DeviceMeasurements.device_id == input_dev.unique_id) self.pin_clock = input_dev.pin_clock self.pin_cs = input_dev.pin_cs self.pin_miso = input_dev.pin_miso self.sensor = MAX31855.MAX31855(self.pin_clock, self.pin_cs, self.pin_miso)
def main(web_output_file, interval, web_server_port, verbose, log_interval, output_file_pattern, output_separator, log_short_interval, short_interval, short_output_file_pattern): '''Interval is in minutes. Short_interval is seconds. ''' # Hardware configuration is set at top of file global CLK, DO, CS # Setup output_file = None log_interval = datetime.timedelta(minutes=log_interval) file_start_time = None # For logging hours since start of file interval_start_time = None web_server = subprocess.Popen( ['python', '-m', 'SimpleHTTPServer', str(web_server_port)], cwd=os.path.dirname(web_output_file)) if log_short_interval: short_output_file = None short_interval = datetime.timedelta(seconds=short_interval) short_file_start_time = None # For logging hours since start of file short_interval_start_time = None print('About to connect to %i sensors' % len(CS)) sensors = [MAX31855.MAX31855(CLK, this_CS, DO) for this_CS in CS] print('Sensors connected') while True: try: # Collect the data temps = [sensor.readAll() for sensor in sensors] for t in temps: for k in t.keys(): if k != 'state': t[k] = c_to_f(t[k]) now = datetime.datetime.now() # Stdout output if verbose: print(now.isoformat() + ' ' + '; '.join([ '%.2f,%.2f,%.2f' % (t['temp'], t['internal'], t['linearized']) for t in temps ])) # Html output # Always overwrite current file html = '<html><head><meta http-equiv="refresh" content="1"><title>Current Temps</title></head>' lines = [ '%s: %.1f F' % (name, t['linearized']) for name, t in zip(SENSOR_NAMES, temps) ] lines += ['<br>', '<br>'] lines += [ '%s: %.1f internal; errors: %s' % (name, t['internal'], str([s for s, v in t['state'].items() if v])) for name, t in zip(SENSOR_NAMES, temps) ] html += '<body><h1>%s<br><<%s></h1></body></html>' % ( '<br>'.join(lines), now.isoformat()) with open(web_output_file, 'w') as web_file: web_file.write(html) # Log file output if not interval_start_time: interval_start_time = now if log_short_interval: if not short_interval_start_time: short_interval_start_time = now if (not file_start_time) or (now - interval_start_time >= log_interval): if not file_start_time: file_start_time = now # Assemble data dictionary data_dict = OrderedDict([ ('timestamp', now.strftime('%H:%M:%S')), ('hours', format((now - file_start_time).total_seconds() / 3600.0, '06.3f')) ]) data_dict.update([('%s F' % name, format(t['linearized'], '.2f')) for name, t in zip(SENSOR_NAMES, temps)]) data_dict.update([('internal %s F' % name, format(t['internal'], '.2f')) for name, t in zip(SENSOR_NAMES, temps)]) # Write out the data if not output_file or now.date() != current_date: if output_file: output_file.close() print('Opening new output file') current_date = datetime.datetime.now().date() output_file = get_output_file( current_date.strftime(output_file_pattern), data_dict, output_separator) output_file.write( output_separator.join([str(x) for x in data_dict.values()]) + '\n') interval_start_time = now if log_short_interval: if (not short_file_start_time) or ( now - short_interval_start_time >= short_interval): if not short_file_start_time: short_file_start_time = now # Assemble data dictionary data_dict = OrderedDict([ ('timestamp', now.strftime('%H:%M:%S')), ('hours', format((now - short_file_start_time).total_seconds() / 3600.0, '07.4f')) ]) data_dict.update([('%s F' % name, format(t['linearized'], '.2f')) for name, t in zip(SENSOR_NAMES, temps)]) # Write out the data if not short_output_file or now.date() != current_date: if short_output_file: short_output_file.close() print('Opening new short output file') current_date = datetime.datetime.now().date() short_output_file = get_output_file( current_date.strftime(short_log_file_pattern), data_dict, output_separator) short_output_file.write( output_separator.join( [str(x) for x in data_dict.values()]) + '\n') short_interval_start_time = now time.sleep(interval - time.time() % interval) # corrects for drift except KeyboardInterrupt: break web_server.terminate() # Cleanup
levelAlarmSent = False # Set term and int signals to be ignored - passed to child processes signal.signal(signal.SIGINT, signal.SIG_IGN) signal.signal(signal.SIGTERM, signal.SIG_IGN) # Import multiprocess functions <enforces simple context> import ThermoPiMP # Create Thermocouple reader objects CLK = 24 SO = 10 CS1 = 9 CS2 = 11 T1 = mx3.MAX31855(CLK, CS1, SO) # Sensor 1, placed below the LN fill line T2 = mx3.MAX31855(CLK, CS2, SO) # Sensor 2, placed near the top plug # Define globals for current readings temp1 = 0 inter1 = 0 temp2 = 0 inter2 = 0 states = ['openCircuit', 'shortGND', 'shortVCC', 'fault'] state1 = [True, True, True, True] state2 = [True, True, True, True] counter = 0 linearizeTemps = True alarmCondition = 0
class Heater: desired_temp = None # Fully populated once constructed current_step = 0 # Track which iteration we are on temperature_readings = [0] # Add to list as we step errors = [0] # Add to this as we step current_temperature = 0 # Updated in step() if on_pi_hardware: # Raspberry Pi software SPI configuration. (For thermocouple) CLK = 25 CS = 24 DO = 18 sensor = MAX31855.MAX31855(CLK, CS, DO) # Raspberry Pi hardware SPI configuration. (For thermocouple) # SPI_PORT = 0 # SPI_DEVICE = 0 # sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE, max_speed_hz=5000000)) i2c = busio.I2C(board.SCL, board.SDA) dac = adafruit_mcp4725.MCP4725(i2c) # Calculates the temperature based on dni_arr and secs_per_cycle def __init__(self, dni_arr, secs_per_cycle): self.mutex = Lock() # sample every secs_per_cycle since this probably won't run every second desired_temp = dni_arr[::secs_per_cycle] # multiply by 2 for some reason desired_temp = np.multiply(desired_temp, 2) # v = (5 / 208) * (DNI) / sqrt(DNI / R)(on each element in the list) R = 15 voltage_ratio = 5 / 208 # The ratio of the analog control voltage to max voltage into the heater for i in range(0, len(desired_temp)): desired_temp[i] = voltage_ratio * desired_temp[i] / math.sqrt( desired_temp[i] / R) # desired_temp = 8.6*v^2 + 115v (on each element in the list) # Estimated calibration equation, analog voltage to Celsius for i in range(0, len(desired_temp)): desired_temp[i] = 8.6 * math.pow(desired_temp[i], 2) + 115 * desired_temp[i] self.desired_temp = desired_temp print("DEBUG: [Heater] Constructed") # public facing step method # spawns a thread and calls the synchronous step_sync helper method def step(self): print("DEBUG: [Heater] Stepping") t1 = Thread(target=self.__step_sync) t1.start() # private synchronous helper method that runs each time we need to check heater temp def __step_sync(self): # Stop stepping once we have reached the end of the desired_temp array # (for the case where the desired_temp arr is not evenly divisible by secs_per_cycle if self.current_step >= len(self.desired_temp) - 1: return else: self.current_step += 1 if not on_pi_hardware: return self.mutex.acquire() print("DEBUG: [Heater] Stepping for", self.current_step) # Read the current temperature current_temp = self.sensor.readTempC() self.current_temperature = current_temp # Calculate the control temperature kP = 1000 ki = 10 kd = 25 # control_temperature = desired_temp_c[currentsecond] + kP * error[current reading and current desired # temperature] + ki * [sum of all errors] + kd * (this error - previous error) ref_temp = self.desired_temp[self.current_step] error = ref_temp - current_temp control_temperature = ref_temp + kP * error + ki * np.sum( self.errors) + kd * self.errors[len(self.errors) - 1] self.errors.append(error) # convert control temperature to voltage control_voltage = 500 * control_temperature # actual dac output (0-4096) actual_dac_output = control_voltage / 5 * 4096 if actual_dac_output > 4096: actual_dac_output = 4096 elif actual_dac_output < 0: actual_dac_output = 0 self.dac.set_voltage(actual_dac_output) print("DEBUG: [Heater] Done stepping for", self.current_step) self.mutex.release() # returns the state of this stepper motor def get_state(self): return { "current_temperature": str(self.current_temperature), "reference_temperature": str(self.desired_temp[self.current_step]) } def get_desired_temp_arr(self): return self.desired_temp.tolist()
class ToasterController(object): loaded = False instructions = None timer = None cancel = False spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) cs = digitalio.DigitalInOut(board.D5) max31855 = adafruit_max31855.MAX31855(spi, cs) main_time = 12 cancel_time = 1 #motor1 = Motor(forward = 2, backward = 4) CLK = 11 CS = 8 DO = 9 sensor = MAX31855.MAX31855(CLK, CS, DO) btn = Button(27) button_1_channel = 22 button_2_channel = 27 button_3_channel = 17 def c_to_f(c): return c * 9.0 / 5.0 + 32.0 def __init__(self, instructions): self.instructions = instructions self.timer = CookTimer() def start(self, c, motor1): ''' Begin cooking ''' self.timer.set(self.instructions.cook_time) self.lower_platform(c, motor1) def lower_platform(self, c, motor1): try: self.loaded = True for x in range(0, self.main_time, 1): motor1.backward() if self.cancel == True: break note = 'Lowering food...' c.send(note.encode('utf-8')) print('Main: ', self.main_time) print('Cancel: ', self.cancel_time) self.cancel_time = self.cancel_time + 1 time.sleep(1) if self.cancel == False: note = 'Food Lowered' + ' ' c.sendall(note.encode('utf-8')) print("Platform is lowered") motor1.stop() self.timer.start() self.wait_time(c, self.instructions) except OSError: print("Error...") motor1.stop() def lower_platform_offline(self, motor1): try: self.loaded = True for x in range(0, self.main_time, 1): motor1.backward() if self.cancel == True: break print('Main: ', self.main_time) print('Cancel: ', self.cancel_time) self.cancel_time = self.cancel_time + 1 time.sleep(1) if self.cancel == False: print("Platform is lowered") motor1.stop() self.timer.start() self.wait_time_offline(self.instructions) except OSError: print("Error...") motor1.stop() def wait_time(self, c, instructions): '''Send data to app''' if int(self.timer.remaining_time) <= 0: self.timer.cook_time = instructions.cook_time try: for x in range(int(self.timer.remaining_time), -1, -1): if self.cancel == True: break print(self.timer.remaining_time) time_split = str(round(self.timer.remaining_time)) tempC = self.sensor.readTempC() tempF = str(tempC * 9 / 5 + 32) print('Temperature: {} C {} F '.format(tempC, tempF)) total_data = time_split + ' ' + tempF + ' ' + 'Code' c.send(total_data.encode('utf-8')) instructions.stopped.wait(timeout=1) except OSError: print("Error...") def wait_time_offline(self, instructions): '''Send data to app''' if int(self.timer.remaining_time) <= 0: self.timer.cook_time = instructions.cook_time try: for x in range(int(self.timer.remaining_time), -1, -1): if self.cancel == True: break print(self.timer.remaining_time) instructions.stopped.wait(timeout=1) except OSError: print("Error...") motor1.stop() def raise_platform(self, c, motor1): try: self.loaded = False raise_time = -1 self.cancel_time = self.cancel_time - 1 print('Main: ', self.main_time) print('Cancel: ', self.cancel_time) if self.main_time != self.cancel_time: raise_time = raise_time + self.cancel_time + 1 else: raise_time = self.main_time for x in range(0, raise_time, 1): motor1.forward() note = 'Raising food...' c.send(note.encode('utf-8')) time.sleep(1) note = 'Raised' c.send(note.encode('utf-8')) print("Platform is raised") motor1.stop() except OSError: print("Error...") motor1.stop() def raise_platform_offline(self, motor1): try: self.loaded = False raise_time = -1 print('Main: ', self.main_time) if self.main_time != self.cancel_time: raise_time = raise_time + self.cancel_time else: raise_time = self.main_time print('Raise: ', raise_time) for x in range(0, raise_time, 1): motor1.forward() time.sleep(1) print("Platform is raised") motor1.stop() except OSError: print("Error...") motor1.stop() def reset(self): '''reset timer mid cook''' self.cancel = False self.timer.clear() def end(self, c, motor1): ''' Cooking has finished ''' self.cancel = False self.timer.clear() self.instructions.clear() self.raise_platform(c, motor1) self.cancel_time = 0 def end_offline(self, motor1): ''' Cooking has finished ''' self.cancel = False self.timer.clear() self.instructions.clear() self.raise_platform_offline(motor1) self.cancel_time = 0
from device import heater from interface import APIInterface from device import thermometer import Adafruit_MAX31855.MAX31855 as MAX31855 import RPi.GPIO as GPIO # Disable the temperature probe logger because it produces annoying and useless messages maxlog = logging.getLogger('Adafruit_MAX31855.MAX31855') maxlog.disabled = True # Set up a logger for application notifications and errors log = logging.getLogger("heater") # We use rotating log files so that if there is a crash mid-run, we will lose the least amount possible. # 5120 bytes is around 50 lines of log messages handler = RotatingFileHandler('/var/log/piwarmer/heater.log', maxBytes=5120, backupCount=10000) formatter = logging.Formatter( '%(asctime)s\t%(name)s\t%(levelname)s\t\t%(message)s') handler.setFormatter(formatter) log.addHandler(handler) log.setLevel(logging.DEBUG) if __name__ == "__main__": api_interface = APIInterface() thermometer = thermometer.Thermometer(MAX31855.MAX31855(24, 23, 18)) heater = heater.Heater(GPIO) with ProgramRunner(api_interface, thermometer, heater) as program: program.run()
def __init__(self, temp_unit=DEGREES_F): BaseSensor.__init__(self, temp_unit=temp_unit) self.sensor = MAX31855.MAX31855(self.CLK, self.CS, self.DO)
import Adafruit_MAX31855.MAX31855 as MAX31855 # Define a function to convert celsius to fahrenheit. def c_to_f(c): return c * 9.0 / 5.0 + 32.0 # Uncomment one of the blocks of code below to configure your Pi or BBB to use # software or hardware SPI. # Raspberry Pi software SPI configuration. CLK = 25 CS = 24 DO = 18 sensor = MAX31855.MAX31855(CLK, CS, DO) # Raspberry Pi hardware SPI configuration. #SPI_PORT = 0 #SPI_DEVICE = 0 #sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) # BeagleBone Black software SPI configuration. #CLK = 'P9_12' #CS = 'P9_15' #DO = 'P9_23' #sensor = MAX31855.MAX31855(CLK, CS, DO) # BeagleBone Black hardware SPI configuration. #SPI_PORT = 1 #SPI_DEVICE = 0
except: result['fail'] = 'none configured' return jsonify(result) @app.route('/getaplist') def getAPList(): APlist = [] cells = wifi.Cell.all('wlan0') for cell in cells: APlist.append(cell.ssid) print(APlist) return jsonify(aplist=APlist) if __name__ == '__main__': try: SPI_PORT = 0 SPI_DEVICE = 0 sensor = MAX31855.MAX31855(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE)) controller = Controller() loadSetting() app.run(host='0.0.0.0', port=80, debug=False, threaded=True) except KeyboardInterrupt: # If CTRL+C is pressed, exit cleanly: pass finally: controller.event.set() time.sleep(2)
def __init__(self): self.sensor = thermocouple = MAX31855.MAX31855(GPIO_THERMOCOUPLE_CLK, GPIO_THERMOCOUPLE_CS, GPIO_THERMOCOUPLE_DO)
def pid_loop(dummy, state): import sys from time import sleep, time from math import isnan import Adafruit_GPIO.SPI as SPI import Adafruit_MAX31855.MAX31855 as MAX31855 import PID as PID import config as conf def c_to_f(c): return c * 9.0 / 5.0 + 32.0 sensor = MAX31855.MAX31855(spi=SPI.SpiDev(conf.spi_port, conf.spi_dev)) pid = PID.PID(conf.Pc, conf.Ic, conf.Dc) pid.SetPoint = state['settemp'] pid.setSampleTime(conf.sample_time * 5) nanct = 0 i = 0 j = 0 pidhist = [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.] avgpid = 0. temphist = [0., 0., 0., 0., 0.] avgtemp = 0. lastsettemp = state['settemp'] lasttime = time() sleeptime = 0 iscold = True iswarm = False lastcold = 0 lastwarm = 0 try: while True: # Loops 10x/second tempc = sensor.readTempC() if isnan(tempc): nanct += 1 if nanct > 100000: sys.exit continue else: nanct = 0 tempf = c_to_f(tempc) temphist[i % 5] = tempf avgtemp = sum(temphist) / len(temphist) if avgtemp < 100: lastcold = i if avgtemp > 200: lastwarm = i if iscold and (i - lastcold) * conf.sample_time > 60 * 15: pid = PID.PID(conf.Pw, conf.Iw, conf.Dw) pid.SetPoint = state['settemp'] pid.setSampleTime(conf.sample_time * 5) iscold = False if iswarm and (i - lastwarm) * conf.sample_time > 60 * 15: pid = PID.PID(conf.Pc, conf.Ic, conf.Dc) pid.SetPoint = state['settemp'] pid.setSampleTime(conf.sample_time * 5) iscold = True if state['settemp'] != lastsettemp: pid.SetPoint = state['settemp'] lastsettemp = state['settemp'] if i % 10 == 0: pid.update(avgtemp) pidout = pid.output pidhist[i / 10 % 10] = pidout avgpid = sum(pidhist) / len(pidhist) state['i'] = i state['tempf'] = round(tempf, 2) state['avgtemp'] = round(avgtemp, 2) state['pidval'] = round(pidout, 2) state['avgpid'] = round(avgpid, 2) state['pterm'] = round(pid.PTerm, 2) if iscold: state['iterm'] = round(pid.ITerm * conf.Ic, 2) state['dterm'] = round(pid.DTerm * conf.Dc, 2) else: state['iterm'] = round(pid.ITerm * conf.Iw, 2) state['dterm'] = round(pid.DTerm * conf.Dw, 2) state['iscold'] = iscold print time(), state sleeptime = lasttime + conf.sample_time - time() if sleeptime < 0: sleeptime = 0 sleep(sleeptime) i += 1 lasttime = time() finally: pid.clear