def print_temperature_ext(conn, settings, uid):
from tinkerforge.bricklet_ptc import BrickletPTC
br = BrickletPTC(uid, conn)
print_generic(
settings,
"temperature.ext",
br.get_identity(),
0.01,
"\N{DEGREE SIGN}C",
br.get_temperature(),
)
def print_temperature_ext(conn, settings, uid):
from tinkerforge.bricklet_ptc import BrickletPTC # type: ignore[import] # pylint: disable=import-error,import-outside-toplevel
br = BrickletPTC(uid, conn)
print_generic(settings, "temperature.ext", br.get_identity(), 0.01, u"\N{DEGREE SIGN}C",
br.get_temperature())
HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your PTC Bricklet
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ptc import BrickletPTC
# Callback function for temperature callback
def cb_temperature(temperature):
print("Temperature: " + str(temperature / 100.0) + " °C")
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
ptc = BrickletPTC(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Register temperature callback to function cb_temperature
ptc.register_callback(ptc.CALLBACK_TEMPERATURE, cb_temperature)
# Set period for temperature callback to 1s (1000ms)
# Note: The temperature callback is only called every second
# if the temperature has changed since the last call!
ptc.set_temperature_callback_period(1000)
input("Press key to exit\n") # Use raw_input() in Python 2
ipcon.disconnect()
def cb_enumerate(cls, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
#global self.led
found = False
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
# Enumeration for LED
if device_identifier == LEDStrip.DEVICE_IDENTIFIER:
cls.LEDs.append(LEDStrip(uid, cls.ipcon))
temp_uid = str(cls.LEDs[-1].get_identity()[1]) + "." + str(
cls.LEDs[-1].get_identity()[0])
cls.LEDList.addLED(cls.LEDs[-1], temp_uid)
cls.LEDs[-1].set_frame_duration(200)
if settings.LEDs.get(temp_uid) <> None:
cls.LEDs[-1].set_chip_type(settings.LEDs.get(temp_uid)[0])
cls.LEDs[-1].set_frame_duration(
settings.LEDs.get(temp_uid)[1])
found = True
#self.led.register_callback(self.led.CALLBACK_FRAME_RENDERED,
# lambda x: __cb_frame_rendered__(self.led, x))
#self.led.set_rgb_values(0, self.NUM_LEDS, self.r, self.g, self.b)
#self.led.set_rgb_values(15, self.NUM_LEDS, self.r, self.g, self.b)
#self.led.set_rgb_values(30, self.NUM_LEDS, self.r, self.g, self.b)
if device_identifier == IO16.DEVICE_IDENTIFIER:
cls.io.append(IO16(uid, cls.ipcon))
temp_uid = str(cls.io[-1].get_identity()[1]) + "." + str(
cls.io[-1].get_identity()[0])
cls.io16list.addIO(cls.io[-1], temp_uid, 16)
cls.io[-1].set_debounce_period(100)
if settings.IO16.get(temp_uid) <> None:
cls.io[-1].set_port_interrupt(
'a',
settings.IO16.get(temp_uid)[0])
cls.io[-1].set_port_interrupt(
'b',
settings.IO16.get(temp_uid)[1])
cls.io[-1].set_port_configuration(
'a',
settings.IO16.get(temp_uid)[0], 'i', True)
cls.io[-1].set_port_configuration(
'b',
settings.IO16.get(temp_uid)[1], 'i', True)
cls.io[-1].set_port_configuration(
'a',
settings.IO16.get(temp_uid)[2], 'o', False)
cls.io[-1].set_port_configuration(
'b',
settings.IO16.get(temp_uid)[3], 'o', False)
#self.io[-1].set_port_monoflop('a', tifo_config.IO16.get(temp_uid)[4],0,tifo_config.IO16.get(temp_uid)[6])
#self.io[-1].set_port_monoflop('b', tifo_config.IO16.get(temp_uid)[5],0,tifo_config.IO16.get(temp_uid)[6])
cls.io[-1].register_callback(
cls.io[-1].CALLBACK_INTERRUPT,
partial(cls.cb_interrupt,
device=cls.io[-1],
uid=temp_uid))
found = True
if device_identifier == AmbientLight.DEVICE_IDENTIFIER:
cls.al.append(AmbientLight(uid, cls.ipcon))
cls.al[-1].set_illuminance_callback_threshold('o', 0, 0)
cls.al[-1].set_debounce_period(10)
#self.al.set_illuminance_callback_threshold('<', 30, 30)
#self.al.set_analog_value_callback_period(10000)
#self.al.set_illuminance_callback_period(10000)
#self.al.register_callback(self.al.CALLBACK_ILLUMINANCE, self.cb_ambLight)
#self.al.register_callback(self.al.CALLBACK_ILLUMINANCE_REACHED, self.cb_ambLight)
args = cls.al[-1]
#self.al[-1].register_callback(self.al[-1].CALLBACK_ILLUMINANCE_REACHED, lambda event1, event2, event3, args=args: self.cb_ambLight(event1, event2, event3, args))
cls.al[-1].register_callback(
cls.al[-1].CALLBACK_ILLUMINANCE_REACHED,
partial(cls.cb_ambLight, device=args))
temp_uid = str(cls.al[-1].get_identity()[1]) + "." + str(
cls.al[-1].get_identity()[0])
thread_cb_amb = Timer(60, cls.thread_ambLight, [cls.al[-1]])
thread_cb_amb.start()
if device_identifier == BrickletCO2.DEVICE_IDENTIFIER:
cls.co2.append(BrickletCO2(uid, cls.ipcon))
temp_uid = str(cls.co2[-1].get_identity()[1]) + "." + str(
cls.co2[-1].get_identity()[0])
thread_co2_ = Timer(5, cls.thread_CO2, [cls.co2[-1]])
thread_co2_.start()
cls.threadliste.append(thread_co2_)
if device_identifier == BrickletDualRelay.DEVICE_IDENTIFIER:
cls.drb.append(BrickletDualRelay(uid, cls.ipcon))
#
# if device_identifier == Moisture.DEVICE_IDENTIFIER:
# self.moist = Moisture(uid, self.ipcon)
# self.moist.set_moisture_callback_period(10000)
# self.moist.register_callback(self.moist.CALLBACK_MOISTURE, self.cb_moisture)
if device_identifier == BrickletMotionDetector.DEVICE_IDENTIFIER:
cls.md.append(BrickletMotionDetector(uid, cls.ipcon))
temp_uid = str(cls.md[-1].get_identity()[1]) + "." + str(
cls.md[-1].get_identity()[0])
cls.md[-1].register_callback(
cls.md[-1].CALLBACK_MOTION_DETECTED,
partial(cls.cb_md, device=cls.md[-1], uid=temp_uid))
cls.md[-1].register_callback(
cls.md[-1].CALLBACK_DETECTION_CYCLE_ENDED,
partial(cls.cb_md_end, device=cls.md[-1], uid=temp_uid))
if device_identifier == BrickletSoundIntensity.DEVICE_IDENTIFIER:
cls.si.append(BrickletSoundIntensity(uid, cls.ipcon))
temp_uid = str(cls.si[-1].get_identity()[1]) + "." + str(
cls.si[-1].get_identity()[0])
cls.si[-1].set_debounce_period(1000)
cls.si[-1].register_callback(
cls.si[-1].CALLBACK_INTENSITY_REACHED,
partial(cls.cb_si, device=cls.si[-1], uid=temp_uid))
cls.si[-1].set_intensity_callback_threshold('>', 200, 0)
if device_identifier == BrickletPTC.DEVICE_IDENTIFIER:
cls.ptc.append(BrickletPTC(uid, cls.ipcon))
temp_uid = str(cls.ptc[-1].get_identity()[1]) + "." + str(
cls.ptc[-1].get_identity()[0])
thread_pt_ = Timer(5, cls.thread_pt, [cls.ptc[-1]])
thread_pt_.start()
cls.threadliste.append(thread_pt_)
if device_identifier == BrickletTemperature.DEVICE_IDENTIFIER:
cls.temp.append(BrickletTemperature(uid, cls.ipcon))
temp_uid = str(cls.temp[-1].get_identity()[1]) + "." + str(
cls.temp[-1].get_identity()[0])
thread_pt_ = Timer(5, cls.thread_pt, [cls.temp[-1]])
thread_pt_.start()
cls.threadliste.append(thread_pt_)
if device_identifier == BrickMaster.DEVICE_IDENTIFIER:
cls.master.append(BrickMaster(uid, cls.ipcon))
thread_rs_error = Timer(60, cls.thread_RSerror, [])
#thread_rs_error.start()
if settings.inputs.get(uid) <> None:
found = True
if not found:
toolbox.log(connected_uid, uid, device_identifier)
print connected_uid, uid, device_identifier
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your PTC Bricklet
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ptc import BrickletPTC
# Callback function for temperature reached callback
def cb_temperature_reached(temperature):
print("Temperature: " + str(temperature/100.0) + " °C")
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
ptc = BrickletPTC(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Get threshold callbacks with a debounce time of 10 seconds (10000ms)
ptc.set_debounce_period(10000)
# Register temperature reached callback to function cb_temperature_reached
ptc.register_callback(ptc.CALLBACK_TEMPERATURE_REACHED, cb_temperature_reached)
# Configure threshold for temperature "greater than 30 °C"
ptc.set_temperature_callback_threshold(">", 30*100, 0)
raw_input("Press key to exit\n") # Use input() in Python 3
ipcon.disconnect()
HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your PTC Bricklet
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ptc import BrickletPTC
# Callback function for temperature reached callback (parameter has unit °C/100)
def cb_temperature_reached(temperature):
print("Temperature: " + str(temperature / 100.0) + " °C")
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
ptc = BrickletPTC(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Get threshold callbacks with a debounce time of 10 seconds (10000ms)
ptc.set_debounce_period(10000)
# Register temperature reached callback to function cb_temperature_reached
ptc.register_callback(ptc.CALLBACK_TEMPERATURE_REACHED,
cb_temperature_reached)
# Configure threshold for temperature "greater than 30 °C" (unit is °C/100)
ptc.set_temperature_callback_threshold(">", 30 * 100, 0)
raw_input("Press key to exit\n") # Use input() in Python 3
def create_instance(self, uid, ipcon):
return BrickletPTC(uid, ipcon)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your PTC Bricklet
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ptc import BrickletPTC
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
ptc = BrickletPTC(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Get current temperature (unit is °C/100)
temperature = ptc.get_temperature()
print("Temperature: " + str(temperature/100.0) + " °C")
raw_input("Press key to exit\n") # Use input() in Python 3
ipcon.disconnect()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your PTC Bricklet
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ptc import BrickletPTC
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
ptc = BrickletPTC(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Get current temperature (unit is °C/100)
temperature = ptc.get_temperature()
print("Temperature: " + str(temperature / 100.0) + " °C")
raw_input("Press key to exit\n") # Use input() in Python 3
ipcon.disconnect()
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your PTC Bricklet
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_ptc import BrickletPTC
# Callback function for temperature callback (parameter has unit °C/100)
def cb_temperature(temperature):
print("Temperature: " + str(temperature/100.0) + " °C")
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
ptc = BrickletPTC(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Register temperature callback to function cb_temperature
ptc.register_callback(ptc.CALLBACK_TEMPERATURE, cb_temperature)
# Set period for temperature callback to 1s (1000ms)
# Note: The temperature callback is only called every second
# if the temperature has changed since the last call!
ptc.set_temperature_callback_period(1000)
raw_input("Press key to exit\n") # Use input() in Python 3
ipcon.disconnect()
