def temperature(connection, table):
ipcon = IPConnection()
t = Temperature(TEMPERATURE_UID, ipcon)
ipcon.connect(HOST, PORT)
value = t.get_temperature() / 100.0
insert(connection, table, time.time(), value)
ipcon.disconnect()
def humidity(connection, table):
ipcon = IPConnection()
h = Humidity(HUMIDITY_UID, ipcon)
ipcon.connect(HOST, PORT)
value = h.get_humidity() / 10.0
insert(connection, table, time.time(), value)
ipcon.disconnect()
class PressureSensor():
def __init__(self, uid, host):
self._host = host
self._port = 4223
self._uid = uid # Change XYZ to the UID of your Load Cell Bricklet 2.0
self._connect()
def _connect(self):
print(self._host)
print(self._port)
print(self._uid)
self._ipcon = IPConnection() # Create IP connection
self._lc = BrickletLoadCellV2(self._uid,
self._ipcon) # Create device object
self._ipcon.connect(self._host, self._port) # Connect to brickd
def disconnect(self):
self._ipcon.disconnect()
def get(self):
return self._lc.get_weight()
def ambient(connection, table):
ipcon = IPConnection()
al = AmbientLight(AMBIENT_UID, ipcon)
ipcon.connect(HOST, PORT)
value = al.get_illuminance() / 10.0 # Get current illuminance (unit is Lux/10)
insert(connection, table, time.time(), value)
ipcon.disconnect()
def SetBrickletRGB(self, r, g, b):
Domoticz.Debug("SetBrickletRGB: R=%d,G=%d,B=%d" % (r, g, b))
try:
# Create IP connection
ipConn = IPConnection()
# Create device object
rgbDev = BrickletRGBLEDV2(Parameters["Mode1"], ipConn)
# Connect to brickd using Host and Port
ipConn.connect(Parameters["Address"], int(Parameters["Port"]))
# Assign the color and update the domoticz dimmer switches
state = 1
self.r = r
Devices[UNITCHANNELR].Update(nValue=state, sValue=str(self.r))
self.g = g
Devices[UNITCHANNELG].Update(nValue=state, sValue=str(self.g))
self.b = b
Devices[UNITCHANNELB].Update(nValue=state, sValue=str(self.b))
# Update the tinkerforge rgbled device with mapped values
rm = MapRange(self.r, 0, 100, 0, 255)
gm = MapRange(self.g, 0, 100, 0, 255)
bm = MapRange(self.b, 0, 100, 0, 255)
Domoticz.Debug("Bricklet Update: R=%d,G=%d,B=%d" % (rm, gm, bm))
rgbDev.set_rgb_value(rm, gm, bm)
# Disconnect
ipConn.disconnect()
Domoticz.Debug("SetBrickletRGB: OK")
except:
Domoticz.Error("[ERROR] SetBrickletRGB failed. Check bricklet.")
return
def SetLCDText(self, line1, line2, line3, line4):
Domoticz.Debug("SetLCDText - UID:" + self.UIDList[UIDINDEXLCD])
try:
# Create IP connection
ipcon = IPConnection()
# Create device object
lcd = BrickletLCD20x4(self.UIDList[UIDINDEXLCD], ipcon)
# Connect to brickd
ipcon.connect(Parameters["Address"], int(Parameters["Port"]))
# Don't use device before ipcon is connected
## write to the lcd: line (int,0-3),pos(int,0-19),text
lcd.clear_display()
lcd.write_line(0, 0, line1)
lcd.write_line(1, 0, line2)
lcd.write_line(2, 0, line3)
lcd.write_line(3, 0, line4)
ipcon.disconnect()
return 1
except:
# Error
Domoticz.Log("[ERROR] Can not set Master Status LED.")
return 0
def SetAirQualityStatusLed(self, state):
Domoticz.Debug("SetAirQualityStatusLed - UID:" +
self.UIDList[UIDINDEXAIRQUALITY])
try:
# Create IP connection
ipcon = IPConnection()
# Create device object
aq = BrickletAirQuality(self.UIDList[UIDINDEXAIRQUALITY], ipcon)
# Connect to brickd
ipcon.connect(Parameters["Address"], int(Parameters["Port"]))
# Don't use device before ipcon is connected
if state == 0:
aq.set_status_led_config(state)
Domoticz.Log("Air Quality Status LED disabled.")
if state == 1:
aq.set_status_led_config(state)
Domoticz.Log("Air Quality Status LED enabled.")
ipcon.disconnect()
return 1
except:
# Error
Domoticz.Log("[ERROR] Can not set Air Quality Status LED.")
return 0
def start_app():
# Create Tinkerforge instances
ip_con = IPConnection()
ip_con.set_timeout(10)
ip_con.connect('localhost', 4223)
controller.BrickletHandler.monitor_ip_connection(ip_con=ip_con)
bricklet_factory = controller.BrickletFactory()
quad_relay_1 = bricklet_factory. \
create_and_configure_bricklet('quad_relay', 'BC8', ip_con)
quad_relay_2 = bricklet_factory. \
create_and_configure_bricklet('quad_relay', 'BCE', ip_con)
rs232 = bricklet_factory. \
create_and_configure_bricklet('rs232', 'Cvu', ip_con)
analog_in = bricklet_factory. \
create_and_configure_bricklet('analog_in', 'CNA', ip_con)
# controller Setup
channel = controller.ChannelController(quad_relay_1, quad_relay_2)
co2flow = controller.Co2FlowController(rs232)
airflow = controller.AirFlowController(analog_in)
sensor = controller.SensorController(analog_in)
concentration = controller.ConcentrationController(sensor, airflow, co2flow)
sequence = controller.SequenceController(concentration, channel)
# logging
data_logger = data.DataLogger()
log_dir = 'log'
if not os.path.exists(log_dir):
os.mkdir(log_dir)
prefix = time.strftime('%y%m%d_%H%M%S')
data_file_path = os.path.join(log_dir, f'{prefix}_data.csv')
log_file_path = os.path.join(log_dir, f'{prefix}_log.txt')
logger.set_log_file(log_file_path)
data_logger.set_file(data_file_path)
# main components
main_controller = controller.MainController(
channel_controller=channel,
co2_flow_controller=co2flow,
air_flow_controller=airflow,
sensor_controller=sensor,
concentration_controller=concentration,
sequence_controller=sequence,
data_logger=data_logger
)
gui = tk_gui.MainFrame()
main_controller.set_gui(gui)
# Start app
main_controller.initialize()
gui.mainloop()
# Wrap up
main_controller.set_co2_flow(flow_rate=0)
main_controller.set_channel(data.Channels.NONE)
ip_con.disconnect()
def setPins(mcuReset, pcuReset, mcuBoot, pcuBoot):
ipcon = IPConnection() # Create IP connection
relay = BrickletIndustrialQuadRelay(UID_RELAY,
ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
relayValue = 0
if mcuReset:
relayValue |= (1 << 0)
if mcuBoot:
relayValue |= (1 << 1)
if pcuReset:
relayValue |= (1 << 2)
if pcuBoot:
relayValue |= (1 << 3)
relay.set_value(relayValue)
ipcon.disconnect()
def SetLCDBacklight(self, state):
Domoticz.Debug("SetLCDBacklight - UID:" + self.UIDList[UIDINDEXLCD])
try:
# Create IP connection
ipcon = IPConnection()
# Create device object
lcd = BrickletLCD20x4(self.UIDList[UIDINDEXLCD], ipcon)
# Connect to brickd
ipcon.connect(Parameters["Address"], int(Parameters["Port"]))
# Don't use device before ipcon is connected
if state == 'Off':
lcd.backlight_off()
Domoticz.Log("LCD Backlight OFF.")
if state == 'On':
lcd.backlight_on()
Domoticz.Log("LCD Backlight ON.")
ipcon.disconnect()
return 1
except:
# Error
Domoticz.Log("[ERROR] Can not set Master Status LED.")
return 0
def relay_flash(baudrate, tty, firmware, uid_iqr, uid_master):
ipcon = IPConnection()
iqr = BrickletIndustrialQuadRelay(uid_iqr, ipcon)
master = BrickMaster(uid_master, ipcon)
ipcon.connect('localhost', 4223)
# reset_usb()
# time.sleep(1)
i = 10
while True:
if i == 10:
master.get_chibi_error_log()
iqr.set_value(MASK_DATA)
time.sleep(0.2)
iqr.set_value(MASK_POWER | MASK_DATA)
i = 0
i += 1
try:
time.sleep(0.01)
xmc_flash(baudrate, tty, firmware)
break
except Exception as e:
print(str(e))
iqr.set_value(MASK_POWER)
master.reset()
ipcon.disconnect()
class Window(QtGui.QWidget):
qtcb_temperature = QtCore.pyqtSignal(int)
def __init__(self):
QtGui.QWidget.__init__(self)
self.button = QtGui.QPushButton('Refresh', self)
self.button.clicked.connect(self.handle_button)
self.label = QtGui.QLabel('TBD')
layout = QtGui.QVBoxLayout(self)
layout.addWidget(self.button)
layout.addWidget(self.label)
self.ipcon = IPConnection()
self.temperature = Temperature(UID_TEMPERATURE, self.ipcon)
self.ipcon.connect(HOST, PORT)
# We send the callback through the Qt signal/slot
# system to make sure that we can change the label
self.qtcb_temperature.connect(self.cb_temperature)
self.temperature.register_callback(Temperature.CALLBACK_TEMPERATURE, self.qtcb_temperature.emit)
# Refresh every second
self.temperature.set_temperature_callback_period(1000)
# Refresh once on startup
self.handle_button()
# Refresh by hand
def handle_button(self):
self.cb_temperature(self.temperature.get_temperature())
def cb_temperature(self, temperature):
# Show temperature
self.label.setText(u"Temperature: {0} °C".format(temperature/100.0))
def barometer(connection, table):
ipcon = IPConnection()
b = Barometer(BAROMETER_UID, ipcon)
ipcon.connect(HOST, PORT)
value = b.get_air_pressure() / 1000.0 # Get current air pressure (unit is mbar/1000)
insert(connection, table, time.time(), value)
ipcon.disconnect()
def main(host, port, uid):
ipcon = IPConnection()
rs485 = BrickletRS485(uid, ipcon)
ipcon.connect(host, port)
# rs485.set_buffer_config(5*1024, 5*1024)
print(rs485.get_buffer_status())
def collect_data(suffix):
global SAMPLE_RATE
global w1
global row
print "Now recording " + suffix
ipcon = IPConnection() # Create IP connection
imu = IMU(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Set period for quaternion callback to 1s
imu.set_all_data_period(SAMPLE_RATE)
imu.set_orientation_period(SAMPLE_RATE)
imu.set_quaternion_period(SAMPLE_RATE)
f1 = open('data/letters/all_data_'+suffix+'.csv', 'wb')
w1 = csv.writer(f1)
row = []
# Register quaternion callback
imu.register_callback(imu.CALLBACK_ALL_DATA, cb_all_data)
imu.register_callback(imu.CALLBACK_ORIENTATION, cb_orientation_data)
imu.register_callback(imu.CALLBACK_QUATERNION, cb_quaternion_data)
raw_input('Press key to quit recording ' + suffix + ' \n') # Use input() in Python 3
ipcon.disconnect()
class Window(QtGui.QWidget):
qtcb_temperature = QtCore.pyqtSignal(int)
def __init__(self):
QtGui.QWidget.__init__(self)
self.button = QtGui.QPushButton('Refresh', self)
self.button.clicked.connect(self.handle_button)
self.label = QtGui.QLabel('TBD')
layout = QtGui.QVBoxLayout(self)
layout.addWidget(self.button)
layout.addWidget(self.label)
self.ipcon = IPConnection()
self.temperature = Temperature(UID_TEMPERATURE, self.ipcon)
self.ipcon.connect(HOST, PORT)
# We send the callback through the Qt signal/slot
# system to make sure that we can change the label
self.qtcb_temperature.connect(self.cb_temperature)
self.temperature.register_callback(Temperature.CALLBACK_TEMPERATURE,
self.qtcb_temperature.emit)
# Refresh every second
self.temperature.set_temperature_callback_period(1000)
# Refresh once on startup
self.handle_button()
# Refresh by hand
def handle_button(self):
self.cb_temperature(self.temperature.get_temperature())
def cb_temperature(self, temperature):
# Show temperature
self.label.setText(u"Temperature: {0} °C".format(temperature / 100.0))
def SetMasterStatusLed(self, state):
Domoticz.Debug("SetMasterStatusLed - UID:" + self.UIDList[UIDINDEXMASTER])
try:
# Create IP connection
ipcon = IPConnection()
# Create device object
master = BrickMaster(self.UIDList[UIDINDEXMASTER], ipcon)
# Connect to brickd
ipcon.connect(Parameters["Address"], int(Parameters["Port"]))
# Don't use device before ipcon is connected
if state == 0:
master.disable_status_led()
Domoticz.Log("Master Status LED disabled.")
if state == 1:
master.enable_status_led()
Domoticz.Log("Master Status LED enabled.")
ipcon.disconnect()
return 1
except:
# Error
Domoticz.Log("[ERROR] Can not set Master Status LED.")
return 0
class MotorPoti:
UID = "DCx"
HOST = "localhost"
PORT = 4223
def __init__(self):
self.ipconnection = IPConnection()
self.mlp = BrickletMotorizedLinearPoti(UID, self.ipconnection)
self.ipconnection.connect(HOST, PORT)
self.mlp.register_callback(self.mlp.CALLBACK_POSITION_REACHED,
self.position_reached)
def position_reached(self, position):
print("Position: ", position)
def open_door(self, callback):
self.mlp.set_motor_position(0, self.mlp.DRIVE_MODE_SMOOTH, False)
callback("opened")
print("Opened door")
def close_door(self, callback):
self.mlp.set_motor_position(100, self.mlp.DRIVE_MODE_SMOOTH, False)
callback("closed")
print("Closed door")
class sound_activated(modes.standard.abstractMode):
_ipcon = None
_si = None
def __init__(self):
'''
Constructor
'''
modes.standard.abstractMode.__init__(self)
config = ConfigParser.ConfigParser()
config.read("config.ini")
if config.has_section("Tinkerforge") and config.has_option('Tinkerforge', 'HOST') and config.has_option('Tinkerforge', 'PORT') and config.has_option('Tinkerforge', 'UID'):
HOST = config.get('Tinkerforge', 'HOST')
PORT = config.getint('Tinkerforge', 'PORT')
UID = config.get('Tinkerforge', 'UID')
else:
print "Can't load Tinkerforge Settings from config.ini"
self._ipcon = IPConnection() # Create IP connection
self._si = SoundIntensity(UID, self._ipcon) # Create device object
self._ipcon.connect(HOST, PORT) # Connect to brickd
def __del__(self):
self._ipcon.disconnect()
def myround(self, x, base=5):
return int(base * round(float(x) / base))
def start(self):
high = 0.0
count = 0
while True:
intensity = self._si.get_intensity()
# reset high_level after a Song
if count > 100:
high = intensity
count = 0
if intensity > high:
high = intensity
else:
count += 1
if high > 0:
level = self.myround((100 / float(high)) * float(intensity))
else:
level = 0
RED = BLUE = GREEN = 0
if level <= 33:
BLUE = 100
elif level <= 66:
GREEN = 100
else:
RED = 100
self.setRGB([RED, GREEN, BLUE])
time.sleep(self._DELAY)
def getName(self):
return "Sound Activated"
def ConfigAirQuality(self):
Domoticz.Debug("ConfigAirQuality - UID:" +
self.UIDList[UIDINDEXAIRQUALITY])
try:
# Create IP connection
ipcon = IPConnection()
# Create device object
aq = BrickletAirQuality(self.UIDList[UIDINDEXAIRQUALITY], ipcon)
# Connect to brickd
ipcon.connect(Parameters["Address"], int(Parameters["Port"]))
# Don't use device before ipcon is connected
# Turn off status led
aq.set_status_led_config(0)
Domoticz.Log("Air Quality Status LED disabled.")
# Set temperature offset with resolution 1/100°C. Offset 10 = decrease measured temperature by 0.1°C, 100 = 1°C.
# offset - int
# Test with 2°C = 200
aq.set_temperature_offset(200)
# The Air Quality Bricklet uses an automatic background calibration mechanism to calculate the IAQ Index.
# This calibration mechanism considers a history of measured data. Duration history = 4 days (0) or 28 days (1).
# duration - int 0 | 1
# Test with 0 = 4 days
aq.set_background_calibration_duration(0)
ipcon.disconnect()
return 1
except:
# Error
Domoticz.Log("[ERROR] Can not set Air Quality Status LED.")
return 0
class RedBrickResource:
def connect(self, uid, host, port):
self.ipcon = IPConnection()
self.ipcon.connect(host, port)
self.rb = BrickRED(uid, self.ipcon)
def disconnect(self):
self.ipcon.disconnect()
def main(host, port, uid):
ipcon = IPConnection()
rs485 = BrickletRS485(uid, ipcon)
ipcon.connect(host, port)
rs485.set_status_led_config(0)
rs485.set_error_led_config(0)
rs485.set_communication_led_config(0)
def main(host, port, uid_rs485, uid_master):
ipcon = IPConnection()
rs485 = BrickletRS485(uid_rs485, ipcon)
master = BrickMaster(uid_master, ipcon)
ipcon.connect(host, port)
print("get: " + str(rs485.get_bootloader_mode()))
print("set 1: " + str(rs485.set_bootloader_mode(1)))
def main(host, port, uid_rs485, uid_master):
ipcon = IPConnection()
rs485 = BrickletRS485(uid_rs485, ipcon)
master = BrickMaster(uid_master, ipcon)
ipcon.connect(host, port)
print('Baudrate before: ' + str(master.get_spitfp_baudrate('c')))
master.set_spitfp_baudrate('c', 2000000)
print('Baudrate after: ' + str(master.get_spitfp_baudrate('c')))
def connect():
ipcon = IPConnection() # Create IP connection
gps = GPS(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
print('GPS Bricklet connected...')
return gps, ipcon
def connect():
ipcon = IPConnection() # Create IP connection
gps = GPS(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
print('GPS Bricklet connected...')
return gps, ipcon
def main(host, port, uid):
ipcon = IPConnection()
rs485 = BrickletRS485(uid, ipcon)
ipcon.connect(host, port)
t = time.time()
for _ in range(10000):
rs485.write("1" * 60, 60)
print(time.time() - t)
def setup_connection(self, host):
ipcon = IPConnection()
try:
ipcon.connect(host['name'], host['port'])
self.log.info("connection to '%s:%s' established", host['name'],
host['port'])
except ConnectionError:
self.log.error("connection to '%s:%s' failed", host['name'],
host['port'])
self.__connections__.append(ipcon)
return ipcon
class TinkerforgeConnection(object):
# Connection to the Brick Daemon on localhost and port 4223
ipcon = None
current_entries = dict()
# noinspection PyUnusedLocal
def cb_enumerate(self, uid, connected_uid, position, hardware_version, firmware_version, device_identifier,
enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_DISCONNECTED:
del self.current_entries[uid]
else:
if device_identifier == 13:
self.current_entries.update({uid: "Master Brick"})
elif device_identifier == 21:
self.current_entries.update({uid: "Ambient Light Bricklet"})
elif device_identifier == 229:
self.current_entries.update({uid: "Distance US Bricklet"})
elif device_identifier == 235:
self.current_entries.update({uid: "RemoteSwitchBricklet"})
else:
self.current_entries.update(
{uid: "device_identifier = {0}".format(device_identifier)})
def switch_socket(self, uid, address, unit, state):
rs = BrickletRemoteSwitch(uid, self.ipcon)
rs.switch_socket_b(address, unit, state)
def dim_socket(self, uid, address, unit, value):
rs = BrickletRemoteSwitch(uid, self.ipcon)
rs.dim_socket_b(address, unit, value)
def get_illuminance(self, uid):
try:
al = BrickletAmbientLight(uid, self.ipcon)
return al.get_illuminance() / 10
except Exception:
log.warn(uid + " not connected")
return -1
def get_distance(self, uid):
try:
dus = BrickletDistanceUS(uid, self.ipcon)
return dus.get_distance_value()
except Exception:
log.warn(uid + " not connected")
return -1
def __init__(self, ip_address):
self.ipcon = IPConnection()
self.ipcon.connect(ip_address, 4223)
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, self.cb_enumerate)
self.ipcon.enumerate()
def main():
if len(sys.argv) != 3:
fail("Usage: {} [UID] [path to firmware.zbin]".format(sys.argv[0]))
_, uid, plugin_path = sys.argv
ipcon = IPConnection()
ipcon.connect("localhost", 4223)
bricklet = BrickletUnknown(uid, ipcon)
if write_bricklet_plugin_comcu(plugin_path, bricklet):
print("Done")
class CheckTFTemperature(object):
def __init__(self, host='localhost', port=4223):
self.host = host
self.port = port
self.ipcon = IPConnection()
def connect(self, type, uid):
self.ipcon.connect(self.host, self.port)
self.connected_type = type
if self.connected_type == TYPE_PTC:
ptc = PTC(uid, self.ipcon)
self.func = ptc.get_temperature
elif self.connected_type == TYPE_TEMPERATURE:
temperature = Temperature(uid, self.ipcon)
self.func = temperature.get_temperature
def disconnect(self):
self.ipcon.disconnect()
def read_temperature(self):
return self.func()/100.0
def read(self, warning, critical, mode='none', warning2=0, critical2=0):
temp = self.read_temperature()
if mode == 'none':
print "temperature %s °C" % temp
else:
if mode == 'low':
warning2 = warning
critical2 = critical
if temp >= critical and (mode == 'high' or mode == 'range'):
print "CRITICAL : temperature too high %s °C" % temp
return CRITICAL
elif temp >= warning and (mode == 'high' or mode == 'range'):
print "WARNING : temperature is high %s °C" % temp
return WARNING
elif temp <= critical2 and (mode == 'low' or mode == 'range'):
print "CRITICAL : temperature too low %s °C" % temp
return CRITICAL
elif temp <= warning2 and (mode == 'low' or mode == 'range'):
print "WARNING : temperature is low %s °C" % temp
return WARNING
elif (temp < warning and mode == 'high') or \
(temp > warning2 and mode == 'low') or \
(temp < warning and temp > warning2 and mode == 'range'):
print "OK : %s°C " % temp
return OK
else:
print "UNKNOWN : can't read temperature"
return UNKNOWN
def index():
ipcon = IPConnection() # Create IP connection
t = Temperature(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 = t.get_temperature()/100.0
ipcon.disconnect()
return PAGE.format(temperature)
class volt_cur:
def __init__(self):
self.vc = None
# Create IP Connection
self.ipcon = IPConnection()
# Register IP Connection callbacks
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
# Connect to brickd, will trigger cb_connected
self.ipcon.connect(constants.ownIP, PORT)
#self.ipcon.enumerate()
def cb_reached_vc(self):
voltage = self.vc.get_voltage()
dicti = {}
dicti['value'] = str(voltage)
dicti['name'] = 'Voltage'
mySocket.sendto(str(dicti),(constants.server1,constants.broadPort))
mySocket.sendto(str(dicti),(constants.server1,constants.broadPort))
current = self.vc.get_current()
dicti = {}
dicti['value'] = str(current)
dicti['name'] = 'Current'
mySocket.sendto(str(dicti),(constants.server1,constants.broadPort))
mySocket.sendto(str(dicti),(constants.server1,constants.broadPort))
thread_cb_reached = Timer(60, self.cb_reached_vc, [])
thread_cb_reached.start()
# Callback handles device connections and configures possibly lost
# configuration of lcd and temperature callbacks, backlight etc.
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
# Enumeration for V/C
if device_identifier == BrickletVoltageCurrent.DEVICE_IDENTIFIER:
self.vc = BrickletVoltageCurrent(uid, self.ipcon)
self.cb_reached_vc()
def cb_connected(self, connected_reason):
# Enumerate devices again. If we reconnected, the Bricks/Bricklets
# may have been offline and the configuration may be lost.
# In this case we don't care for the reason of the connection
self.ipcon.enumerate()
class volt_cur:
def __init__(self):
self.vc = None
# Create IP Connection
self.ipcon = IPConnection()
# Register IP Connection callbacks
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
# Connect to brickd, will trigger cb_connected
self.ipcon.connect(constants.ownIP, PORT)
#self.ipcon.enumerate()
def cb_reached_vc(self):
voltage = self.vc.get_voltage()
dicti = {}
dicti['value'] = str(voltage)
dicti['name'] = 'Voltage'
mySocket.sendto(str(dicti), (constants.server1, constants.broadPort))
mySocket.sendto(str(dicti), (constants.server1, constants.broadPort))
current = self.vc.get_current()
dicti = {}
dicti['value'] = str(current)
dicti['name'] = 'Current'
mySocket.sendto(str(dicti), (constants.server1, constants.broadPort))
mySocket.sendto(str(dicti), (constants.server1, constants.broadPort))
thread_cb_reached = Timer(60, self.cb_reached_vc, [])
thread_cb_reached.start()
# Callback handles device connections and configures possibly lost
# configuration of lcd and temperature callbacks, backlight etc.
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
# Enumeration for V/C
if device_identifier == BrickletVoltageCurrent.DEVICE_IDENTIFIER:
self.vc = BrickletVoltageCurrent(uid, self.ipcon)
self.cb_reached_vc()
def cb_connected(self, connected_reason):
# Enumerate devices again. If we reconnected, the Bricks/Bricklets
# may have been offline and the configuration may be lost.
# In this case we don't care for the reason of the connection
self.ipcon.enumerate()
def lies_temp(host, port, uid):
temp = None
try:
ipcon = IPConnection()
b = BrickletTemperature(uid, ipcon)
ipcon.connect(host, port)
temp = b.get_temperature() / 100.0
ipcon.disconnect()
except:
print("Temperaturabfrage fehlgeschlagen")
return temp
def run(self):
global ipcon
isexception = False
try:
ipcon = IPConnection()
if ipcon.get_connection_state(
) != IPConnection.CONNECTION_STATE_CONNECTED:
ipcon.connect("localhost", 4223)
ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
cb_enumerate)
ipcon.time_out = 0.5
ipcon.enumerate()
time.sleep(0.3)
except:
logging.debug("Tinkerforge:failed connecting to IP Connection")
pass
def __init__(self):
#uinput Bereich
self.events = (
uinput.BTN_A, #Es wird mindestens ein Button benötigt (seltsam)
uinput.ABS_Z + (-150, 150, 0, 0), #Erstellt Joystick Achse Z, kleinster Wert des Potis ist -150, größter Wert ist +150
)
self.device = uinput.Device(self.events, "TF Virutal HID Joystick")
#TinkerForge Bereich
ipcon = IPConnection()
self.poti = RotaryPoti("aBQ", ipcon) #UID ändern!
ipcon.connect("127.0.0.1", 4223) #IP / Port anpassen
self.poti.set_position_callback_period(50)
self.poti.register_callback(self.poti.CALLBACK_POSITION, self.poti_cb) #Sobald der Callback auslöst wird die Funktion poti_cb aufgerufen
def getTFconn( HOST=TF_HOST, PORT=TF_PORT ):
try:
ipcon = IPConnection()
except Exception as e:
errmsg = str(traceback.format_exception( *sys.exc_info() ));
Logger.info( 'Tinkerforge IPConnection failed ... ' + errmsg );
sendEmail(admin,'getPower.py', 'Tinkerforge IPConnection failed ... ' + errmsg )
sys.exit(-1) # should cause rPi to reboot
try:
ipcon.connect(HOST, PORT)
except Exception as e:
errmsg = str(traceback.format_exception( *sys.exc_info() ));
Logger.info( 'Tinkerforge unable to connect! ' + errmsg );
sendEmail(admin,'getPower.py', 'Tinkerforge unable to connect! ' + errmsg )
sys.exit(-1) # should cause rPi to reboot
return ipcon
def index():
ipcon = IPConnection() # Create IP connection
humidity_bricklet = BrickletHumidityV2(HUMIDITY_UID, ipcon) # Create device object
barometer_bricklet = BrickletBarometer(BAROMETER_UID, ipcon)
ambient_light_bricklet = BrickletAmbientLightV2(AMBIENT_LIGHT_UID, ipcon)
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
temperature = humidity_bricklet.get_temperature()/100.0
humidity = humidity_bricklet.get_humidity()/100.0
air_pressure = barometer_bricklet.get_air_pressure()/1000.0
illuminance = ambient_light_bricklet.get_illuminance()/100.0
ipcon.disconnect()
return render_template('index.html', temperature=temperature, humidity=humidity, illuminance=illuminance, air_pressure=air_pressure)
def main(host, port, uid1, uid2, uid3, uid_master):
ipcon = IPConnection()
rs4851 = BrickletRS485(uid1, ipcon)
rs4852 = BrickletRS485(uid2, ipcon)
rs4853 = BrickletRS485(uid3, ipcon)
master = BrickMaster(uid_master, ipcon)
ipcon.connect(host, port)
while True:
print('RS485-1: ' + str(rs4851.get_spitfp_error_count()))
print('RS485-2: ' + str(rs4852.get_spitfp_error_count()))
print('RS485-3: ' + str(rs4853.get_spitfp_error_count()))
print('Master-a: ' + str(master.get_spitfp_error_count('a')))
print('Master-b: ' + str(master.get_spitfp_error_count('b')))
print('Master-c: ' + str(master.get_spitfp_error_count('c')))
time.sleep(1)
class dist_us:
def __init__(self):
self.dus = None
# Create IP Connection
self.ipcon = IPConnection()
# Register IP Connection callbacks
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
# Connect to brickd, will trigger cb_connected
self.ipcon.connect(constants.ownIP, PORT)
#self.ipcon.enumerate()
def cb_distance(self, distance):
dicti = {}
dicti['value'] = str(distance)
dicti['name'] = str(self.dus.get_identity()[0]) + "_" + str(self.dus.get_identity()[5])
mySocket.sendto(str(dicti),(constants.server1,constants.broadPort))
mySocket.sendto(str(dicti),(constants.server1,constants.broadPort))
# Callback handles device connections and configures possibly lost
# configuration of lcd and temperature callbacks, backlight etc.
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
# Enumeration for Distance US
if device_identifier == BrickletDistanceUS.DEVICE_IDENTIFIER:
self.dus = BrickletDistanceUS(uid, self.ipcon)
self.dus.register_callback(self.dus.CALLBACK_DISTANCE, self.cb_distance)
self.dus.set_distance_callback_period(10000)
def cb_connected(self, connected_reason):
# Enumerate devices again. If we reconnected, the Bricks/Bricklets
# may have been offline and the configuration may be lost.
# In this case we don't care for the reason of the connection
self.ipcon.enumerate()
def main(host, port, uid):
ipcon = IPConnection()
rs485 = BrickletRS485(uid, ipcon)
ipcon.connect(host, port)
t = time.time()
i = 0
while True:
i += 1
nt = time.time()
if nt - t >= 1.0:
print(i)
i = 0
t = nt
rs485.get_chip_temperature()
print(time.time() - t)
def read_data(fake=None):
""" Reads data from all weather sensors and returns it as Dictionary.
In case of an error or outlier None is returned"""
if fake:
return weather_data
try:
ipcon = IPConnection()
temp_bricklet = Temperature('qnk', ipcon)
humidity_bricklet = Humidity('nLC', ipcon)
barometer_bricklet = Barometer('k5g', ipcon)
ipcon.connect(cfg['weather']['host'], int(cfg['weather']['port']))
temp_bricklet.set_i2c_mode(Temperature.I2C_MODE_SLOW)
temp = temp_bricklet.get_temperature() / 100.0
if 45 < temp < -30:
weather_data['temperature'] = None
logger.warn(
'Got temperature value of %s Grade which is out of range' %
temp)
else:
weather_data['temperature'] = temp
humidity = humidity_bricklet.get_humidity() / 10.0
if humidity < 5:
weather_data['humidity'] = None
logger.warn('Got humidity value of %s RH which is out of range' %
humidity)
else:
weather_data['humidity'] = humidity
pressure = barometer_bricklet.get_air_pressure() / 1000.0
if 1080 < pressure < 930:
weather_data['pressure'] = None
logger.warn('Got pressure value of %s mbar which is out of range' %
pressure)
else:
weather_data['pressure'] = pressure
ipcon.disconnect()
return weather_data
except Exception as e:
logger.error('Cloud not connect to weather sensors: %s' % str(e))
return
class dist_us:
def __init__(self):
self.dus = None
# Create IP Connection
self.ipcon = IPConnection()
# Register IP Connection callbacks
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
# Connect to brickd, will trigger cb_connected
self.ipcon.connect(constants.ownIP, PORT)
#self.ipcon.enumerate()
def cb_distance(self, distance):
dicti = {}
dicti['value'] = str(distance)
dicti['name'] = str(self.dus.get_identity()[0]) + "_" + str(
self.dus.get_identity()[5])
mySocket.sendto(str(dicti), (constants.server1, constants.broadPort))
mySocket.sendto(str(dicti), (constants.server1, constants.broadPort))
# Callback handles device connections and configures possibly lost
# configuration of lcd and temperature callbacks, backlight etc.
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
# Enumeration for Distance US
if device_identifier == BrickletDistanceUS.DEVICE_IDENTIFIER:
self.dus = BrickletDistanceUS(uid, self.ipcon)
self.dus.register_callback(self.dus.CALLBACK_DISTANCE,
self.cb_distance)
self.dus.set_distance_callback_period(10000)
def cb_connected(self, connected_reason):
# Enumerate devices again. If we reconnected, the Bricks/Bricklets
# may have been offline and the configuration may be lost.
# In this case we don't care for the reason of the connection
self.ipcon.enumerate()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.initialized = False
self.altitude_error_i = 0
self.acc_scale = 0.0
self.start_time = time.time()
self.altitude_error = 0
self.inst_acceleration = 0.0
self.delta = 0
self.estimated_velocity = 0.0
self.estimated_altitude = 0.0
self.last_time = time.time()
self.last_orig_altitude = 0
self.last_estimated_altitude = 0
ipcon = IPConnection()
self.imu = IMU(UID_IMU, ipcon)
self.barometer = Barometer(UID_BAROMETER, ipcon)
ipcon.connect(HOST, PORT)
# Turn leds and orientation calculation off, to save calculation time
# for the IMU Brick. This makes sure that the measurements are taken
# in equidistant 2ms intervals
self.imu.leds_off()
self.imu.orientation_calculation_off()
# Turn averaging of in the Barometer Bricklet to make sure that
# the data is without delay
self.barometer.set_averaging(0, 0, 0)
red_pen = QPen(Qt.red)
red_pen.setWidth(5)
plot_list = [#['', Qt.blue, self.get_orig_value],
['', red_pen, self.get_estimated_value]
]
self.plot_widget = PlotWidget('Height [m]', plot_list)
self.plot_widget.stop = False
self.setCentralWidget(self.plot_widget)
self.timer = QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(6)
def get_airpressure(id):
cfg = configparser.ConfigParser()
cfg.read(cfg_filename) # open config file to read from
if cfg.has_section("Barometer") == True:
port = cfg.getint('Connection', 'Port') # get port entry from config file
host = cfg.get('Connection', 'Host') # get host entry from config file
uid = cfg.get('Barometer', 'bricklet_uid') # uid port entry from config file
ipcon = IPConnection() # Create IP connection
ipcon.connect(host, port) # Connect to brickd
b = Barometer(uid, ipcon) # Create device object
air_pressure = b.get_air_pressure()/1000.0 # Get current air pressure (unit is mbar/1000)
altitude = b.get_altitude()/100.0
db = sqlite3.connect(local_db) # build connection to local database
c = db.cursor() # create cursor
c.execute(wd_table) # create weatherdata table
c.execute('''INSERT INTO weatherdata(uid , value, keyword, date_id, device_name) VALUES(?,?,?,?,?)''', (uid,air_pressure,'air_pressure',id,'barometer',))
# insert the uid, device name the id from the date table an die humdity value into the weather table
c.execute('''INSERT INTO weatherdata(uid , value, keyword, date_id, device_name) VALUES(?,?,?,?,?)''', (uid,altitude,'altitude',id,'barometer',))
db.commit() # save creates and inserts permanent
ipcon.disconnect()
return({"air_pressure": air_pressure, "altitude": altitude})
def discover():
HOST = "localhost"
PORT = 4223
global ipcon
ipcon = IPConnection()
ipcon.register_callback(IPConnection.CALLBACK_CONNECTED, cb_connected)
ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, cb_enumerate)
try:
ipcon.connect(HOST, PORT)
w = threading.Thread(target=wait)
w.start()
w.join()
print("baromenter id: " + str(barometerid))
print("humidity id: " + str(humidityid))
print("ambient id: " + str(ambientid))
print("lcd id: " + str(lcdid))
ipcon.disconnect()
except socket.error, e:
global discovery_timed_out
discovery_timed_out = True
print("Error: ipconnection failed " + str(e))
def get_humidity(id):
cfg = configparser.ConfigParser()
cfg.read(cfg_filename) # open config file to read from
port = cfg.getint('Connection', 'Port') # get port entry from config file
host = cfg.get('Connection', 'Host') # get host entry from config file
uid = cfg.get('Humidity', 'bricklet_uid') # uid port entry from config file
ipcon = IPConnection() # Create IP connection
ipcon.connect(host, port) # Connect to brickd
h = Humidity(uid, ipcon) # Create device object
rh = h.get_humidity()/10.0 # Get current humidity (unit is %RH/10)
db = sqlite3.connect(local_db) # build connection to local database
c = db.cursor() # create cursor
c.execute(wd_table) # create weatherdata table
c.execute('''INSERT INTO weatherdata(uid , value, keyword, date_id, device_name) VALUES(?,?,?,?,?)''', (uid,rh,'rel. humidity', id,'humidity',))
# insert the uid, device name the id from the date table an die humdity value into the weather table
db.commit() # save creates and inserts permanent
print()
print('Relative Humidity: ' + str(rh) + ' %RH')
print()
ipcon.disconnect()
return(rh)
def read_data():
try:
ipcon = IPConnection()
temp_bricklet = Temperature('qnk', ipcon)
humidity_bricklet = Humidity('nLC', ipcon)
barometer_bricklet = Barometer('k5g', ipcon)
ipcon.connect(cfg['weather']['host'], int(cfg['weather']['port']))
temp_bricklet.set_i2c_mode(Temperature.I2C_MODE_SLOW)
temp = temp_bricklet.get_temperature() / 100.0
if 45 < temp < -30:
weather_data['temperature'] = None
logger.warn('Got temperature value of %s Grade which is out of range' % temp)
else:
weather_data['temperature'] = temp
humidity = humidity_bricklet.get_humidity() / 10.0
if humidity < 5:
weather_data['humidity'] = None
logger.warn('Got humidity value of %s RH which is out of range' % humidity)
else:
weather_data['humidity'] = humidity
pressure = barometer_bricklet.get_air_pressure() / 1000.0
if 1090 < pressure < 920:
weather_data['pressure'] = None
logger.warn('Got pressure value of %s mbar which is out of range' % pressure)
else:
weather_data['pressure'] = pressure
ipcon.disconnect()
return weather_data
except Exception as e:
logger.error('Cloud not connect to weather sensors: %s' % str(e))
return
class WeatherStation(QApplication):
HOST = "localhost"
PORT = 4223
ipcon = None
lcd = None
al = None
hum = None
baro = None
projects = []
active_project = None
error_msg = None
def __init__(self, args):
super(QApplication, self).__init__(args)
self.error_msg = QErrorMessage()
self.ipcon = IPConnection()
signal.signal(signal.SIGINT, self.exit_demo)
signal.signal(signal.SIGTERM, self.exit_demo)
timer = QTimer(self)
timer.setSingleShot(True)
timer.timeout.connect(self.connect)
timer.start(1)
def exit_demo(self, signl=None, frme=None):
try:
self.ipcon.disconnect()
self.timer.stop()
self.tabs.destroy()
except:
pass
sys.exit()
def open_gui(self):
self.main = MainWindow(self)
self.main.setFixedSize(730, 430)
self.main.setWindowIcon(QIcon(os.path.join(ProgramPath.program_path(), "demo-icon.png")))
self.tabs = QTabWidget()
widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.tabs)
widget.setLayout(layout)
self.main.setCentralWidget(widget)
self.projects.append(ProjectEnvDisplay(self.tabs, self))
self.projects.append(ProjectStatistics(self.tabs, self))
self.projects.append(ProjectXively(self.tabs, self))
self.tabs.addTab(self.projects[0], "Display Environment Measurements")
self.tabs.addTab(self.projects[1], "Show Statistics with Button Control")
self.tabs.addTab(self.projects[2], "Connect to Xively")
self.active_project = self.projects[0]
self.tabs.currentChanged.connect(self.tabChangedSlot)
self.main.setWindowTitle("Starter Kit: Weather Station Demo " + config.DEMO_VERSION)
self.main.show()
def connect(self):
try:
self.ipcon.connect(WeatherStation.HOST, WeatherStation.PORT)
except Error as e:
self.error_msg.showMessage('Connection Error: ' + str(e.description) + "\nBrickd installed and running?")
return
except socket.error as e:
self.error_msg.showMessage('Socket error: ' + str(e) + "\nBrickd installed and running?")
return
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
try:
self.ipcon.enumerate()
except Error as e:
self.error_msg.showMessage('Enumerate Error: ' + str(e.description))
return
self.open_gui()
def tabChangedSlot(self, tabIndex):
if self.lcd is not None:
self.lcd.clear_display()
self.active_project = self.projects[tabIndex]
def cb_illuminance(self, illuminance):
for p in self.projects:
p.update_illuminance(illuminance)
def cb_humidity(self, humidity):
for p in self.projects:
p.update_humidity(humidity)
def cb_air_pressure(self, air_pressure):
for p in self.projects:
p.update_air_pressure(air_pressure)
try:
temperature = self.baro.get_chip_temperature()
except Error as e:
print('Could not get temperature: ' + str(e.description))
return
for p in self.projects:
p.update_temperature(temperature)
def configure_custom_chars(self):
c = [[0x00 for x in range(8)] for y in range(8)]
c[0] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff]
c[1] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff]
c[2] = [0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff]
c[3] = [0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]
c[4] = [0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff]
c[5] = [0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]
c[6] = [0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]
c[7] = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]
for i in range(len(c)):
self.lcd.set_custom_character(i, c[i]);
def cb_button_pressed(self, button):
for p in self.projects:
p.button_pressed(button)
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
if device_identifier == LCD20x4.DEVICE_IDENTIFIER:
try:
self.lcd = LCD20x4(uid, self.ipcon)
self.lcd.clear_display()
self.lcd.backlight_on()
self.lcd.register_callback(self.lcd.CALLBACK_BUTTON_PRESSED, self.cb_button_pressed)
self.configure_custom_chars()
except Error as e:
self.error_msg.showMessage('LCD 20x4 init failed: ' + str(e.description))
self.lcd = None
elif device_identifier == AmbientLight.DEVICE_IDENTIFIER:
try:
self.al = AmbientLight(uid, self.ipcon)
self.al.set_illuminance_callback_period(1000)
self.al.register_callback(self.al.CALLBACK_ILLUMINANCE,
self.cb_illuminance)
except Error as e:
self.error_msg.showMessage('Ambient Light init failed: ' + str(e.description))
self.al = None
elif device_identifier == Humidity.DEVICE_IDENTIFIER:
try:
self.hum = Humidity(uid, self.ipcon)
self.hum.set_humidity_callback_period(1000)
self.hum.register_callback(self.hum.CALLBACK_HUMIDITY,
self.cb_humidity)
except Error as e:
self.error_msg.showMessage('Humidity init failed: ' + str(e.description))
self.hum = None
elif device_identifier == Barometer.DEVICE_IDENTIFIER:
try:
self.baro = Barometer(uid, self.ipcon)
self.baro.set_air_pressure_callback_period(1000)
self.baro.register_callback(self.baro.CALLBACK_AIR_PRESSURE,
self.cb_air_pressure)
except Error as e:
self.error_msg.showMessage('Barometer init failed: ' + str(e.description))
self.baro = None
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
self.error_msg.showMessage('Enumerate Error: ' + str(e.description))
time.sleep(1)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your Current12 Bricklet
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_current12 import BrickletCurrent12
if __name__ == "__main__":
ipcon = IPConnection() # Create IP connection
c = BrickletCurrent12(UID, ipcon) # Create device object
ipcon.connect(HOST, PORT) # Connect to brickd
# Don't use device before ipcon is connected
# Get current current (unit is mA)
current = c.get_current()
print("Current: " + str(current / 1000.0) + " A")
raw_input("Press key to exit\n") # Use input() in Python 3
ipcon.disconnect()
class master():
"""docstring for master"""
def __init__(self):
#super(master, self).__init__()
print 'init...'
self.PORT = 4223
self.MENU_running = False
self.BOARD_running = False
### Connection for Menu
self.MENU_HOST = "192.168.0.150" # Manually Set IP of Controller Board
self.MENU_lcdUID = "gFt" # LCD Screen
self.MENU_jskUID = "hAP" # Joystick
### END MENU CONNECTION
### Connection for Board
self.BOARD_HOST = "192.168.0.111"
self.BOARD_mstUID = "62eUEf" # master brick
self.BOARD_io1UID = "ghh" # io16
self.BOARD_lcdUID = "9ew" # lcd screen 20x4
self.BOARD_iqrUID = "eRN" # industrial quad relay
#### END BOARD CONNECTION
return
def start(self):
if self.BOARD_running: print 'Board already running!'
else: self.startBoard(); print 'Board Started!'
if self.MENU_running: print 'Menu already running!'
else: self.startMenu(); print 'Menu Started!'
return 'Started!'
def status(self):
return 'Board: '+str(self.BOARD_running)+'\nMenu: '+str(self.MENU_running)
def startBoard(self):
if self.BOARD_running: return 'Board already running!'
if isOpen(self.BOARD_HOST, self.PORT):
self.BOARD_running = True
self.BOARD_ipcon = IPConnection() # Create IP connection
self.mst = Master(self.BOARD_mstUID, self.BOARD_ipcon) # Master Brick
self.io1 = IO16(self.BOARD_io1UID, self.BOARD_ipcon) # io16
self.lcd1 = LCD20x4(self.BOARD_lcdUID, self.BOARD_ipcon) # lcd20x4
self.iqr = IndustrialQuadRelay(self.BOARD_iqrUID, self.BOARD_ipcon) # Create device object
self.BOARD_ipcon.connect(self.BOARD_HOST, self.PORT) # Connect to brickd
# create Board instance
self.BB = B(self.mst, self.io1, self.lcd1, self.iqr, self.BOARD_ipcon)
else:
return 'Board is offline'
return "Hello, Board successfully started!"
def startMenu(self):
if self.MENU_running: return 'Menu already running!'
if isOpen(self.MENU_HOST, self.PORT):
self.MENU_running = True
# Connect to WLAN Controller
self.MENU_ipcon = IPConnection() # Create IP connection
self.lcd = LCD20x4(self.MENU_lcdUID, self.MENU_ipcon) # Create device object LCD
self.jsk = Joystick(self.MENU_jskUID, self.MENU_ipcon) # Create device object JOYSTICK
# Don't use device before ipcon is connected
self.MENU_ipcon.connect(self.MENU_HOST, self.PORT) # Connect to brickd
# create Menu instance with the nessesary Hardware # IPCON to close Tinker Connection
self.MM = M(self.jsk, self.lcd, self.MENU_ipcon)
else:
return 'Menu is offline'
return "Hello, Menu successfully started!"
def stop(self):
print 'stopping devices...'
if self.MENU_running:
self.MENU_running = False
self.MM.quit()
if self.BOARD_running:
self.BOARD_running = False
self.BB.quit() # Stop Board
#quit()
return 'successfully stopped'
except:
break
else:
try:
self.led_strip.set_led_values(0, frame)
except:
return
def frame_prepare_next(self):
if len(self.images) == 0:
return
self.leds = self.images[self.image_position]
self.image_position = (self.image_position + 1) % len(self.images)
if __name__ == "__main__":
# Create IP Connection and connect it
ipcon = IPConnection()
ipcon.connect(config.HOST, config.PORT)
# Create Images object and start rendering
images = Images(ipcon)
images.set_new_images(sys.argv[1:])
images.frame_rendered(0)
raw_input('Press enter to exit\n') # Use input() in Python 3
ipcon.disconnect()
class tiFo:
r = [0]*16
g = [0]*16
b = [0]*16
def __init__(self):
self.led = None
self.io = []
self.io16list = io16Dict()
self.LEDs = []
self.LEDList = LEDStrips()
self.al = []
self.drb = []
self.master = []
self.md = []
self.si = []
self.ptc = []
self.co2 = []
self.moist = None
# Create IP Connection
self.ipcon = IPConnection()
# Register IP Connection callbacks
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
# Connect to brickd, will trigger cb_connected
self.ipcon.connect(constants.ownIP, PORT)
self.unknown = []
self.threadliste = []
#self.ipcon.enumerate()
def thread_RSerror(self):
for mastr in self.master:
print mastr.get_rs485_error_log()
thread_rs_error = Timer(60, self.thread_RSerror, [])
thread_rs_error.start()
def cb_ambLight(self, illuminance,device):
thresUp = illuminance * 4/3
thresDown = illuminance * 4 / 5
if thresDown == 0:
thresDown = 0
thresUp = 3
if thresUp > 9000:
thresUp = 9000
#print illuminance, thresDown, thresUp
device.set_illuminance_callback_threshold('o', thresDown, thresUp)
dicti = {}
name = tifo_config.inputs.get(str(device.get_identity()[1]) +"."+ str(device.get_identity()[0]))
name = str(device.get_identity()[1]) +"."+ str(device.get_identity()[0])
dicti['Value'] = str(illuminance)
dicti['Name'] = 'TiFo.' + name
#print dicti
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
def thread_ambLight(self, device):
illuminance = device.get_illuminance()
dicti = {}
name = tifo_config.inputs.get(str(device.get_identity()[1]) +"."+ str(device.get_identity()[0]))
name = str(device.get_identity()[1]) +"."+ str(device.get_identity()[0])
dicti['Value'] = str(illuminance)
dicti['Name'] = 'TiFo.' + name
#print dicti
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
thread_cb_amb = Timer(60, self.thread_ambLight, [device])
thread_cb_amb.start()
def thread_CO2(self, device):
value = device.get_co2_concentration()
dicti = {}
name = tifo_config.inputs.get(str(device.get_identity()[1]) +"."+ str(device.get_identity()[0]))
name = str(device.get_identity()[1]) +"."+ str(device.get_identity()[0])
dicti['Value'] = str(value)
dicti['Name'] = 'TiFo.' + name
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
thread_co2_ = Timer(60, self.thread_CO2, [device])
thread_co2_.start()
def thread_pt(self, device):
value = device.get_temperature()
dicti = {}
name = tifo_config.inputs.get(str(device.get_identity()[1]) +"."+ str(device.get_identity()[0]))
name = str(device.get_identity()[1]) +"."+ str(device.get_identity()[0])
dicti['Value'] = str(float(value)/100)
dicti['Name'] = 'TiFo.' + name
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
thread_pt_ = Timer(60, self.thread_pt, [device])
thread_pt_.start()
def cb_interrupt(self, port, interrupt_mask, value_mask, device, uid):
#print('Interrupt on port: ' + port + str(bin(interrupt_mask)))
#print('Value: ' + str(bin(value_mask)))
namelist = []
temp_uid = uid #str(device.get_identity()[1]) +"."+ str(device.get_identity()[0])
bit_list = [(1 << bit) for bit in range(7, -1, -1)]
for wert in bit_list:
if interrupt_mask & wert > 0:
name = tifo_config.IO16i.get(temp_uid).get(port + str(bin(wert)))
name = temp_uid + "." + port + str(bin(wert))
if name <> None:
namelist.append(name)
if port == 'a':
nc_mask = tifo_config.IO16.get(temp_uid)[7]
else:
nc_mask = tifo_config.IO16.get(temp_uid)[8]
value = (value_mask&interrupt_mask)/interrupt_mask
nc_pos = (nc_mask&interrupt_mask)/interrupt_mask
dicti = {}
# dicti['Name'] = name
# dicti['temp_uid'] = temp_uid
# dicti['name'] = port + str(bin(interrupt_mask))
#print name, value
self.io16list.setValues(device,value_mask,port)
#print self.io16list.getTimeDiff(device,interrupt_mask, port)
if value == nc_pos:
dicti['Value'] = self.io16list.getTimeDiff(device,interrupt_mask, port)
else:
dicti['Value'] = 0
self.io16list.setTime(device,interrupt_mask, port)
#print dicti
for name in namelist:
dicti['Name'] = 'TiFo.' + name
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
def cb_md(self, device, uid):
dicti = {'Name':tifo_config.inputs.get(uid),'Value':1}
dicti = {'Name':'TiFo.' + str(device.get_identity()[1]) +"."+ str(device.get_identity()[0]),'Value':1}
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
def cb_md_end(self, device, uid):
dicti = {'Name':tifo_config.inputs.get(uid),'Value':0}
dicti = {'Name':'TiFo.' + str(device.get_identity()[1]) +"."+ str(device.get_identity()[0]),'Value':0}
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
def cb_si(self,value, device, uid):
dicti = {'Name':tifo_config.inputs.get(uid),'Value':value}
dicti = {'Name':'TiFo.' + str(device.get_identity()[1]) +"."+ str(device.get_identity()[0]),'Value':value}
mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort))
def set_io16_sub(self,cmd,io,value):
port = cmd.get('Port')
if port == 'A':
flopmask = tifo_config.IO16.get(io.get('addr'))[4]
if flopmask & cmd.get('Pin') > 0:
if value == 1:
normpos = tifo_config.IO16.get(io.get('addr'))[7]
io.get('IO').set_port_monoflop('a', cmd.get('Pin'),((~normpos)&0b11111111),tifo_config.IO16.get(io.get('addr'))[6])
else:
if value == 1:
mask = io.get('valueA') | cmd.get('Pin')
else:
mask = io.get('valueA') & (0b11111111 & ~ cmd.get('Pin'))
self.io16list.setValues(io.get('IO'),mask,'a')
io.get('IO').set_port('a',mask)
else:
flopmask = tifo_config.IO16.get(io.get('addr'))[5]
if flopmask & cmd.get('Pin') > 0:
if value == 1:
#working but gets overwritten but other commands
# normpos = tifo_config.IO16.get(io.get('addr'))[8]
# io.get('IO').set_port_monoflop('b', cmd.get('Pin'),((~normpos)&0b11111111),tifo_config.IO16.get(io.get('addr'))[6])
mask = io.get('IO').get_port('b') | cmd.get('Pin')
io.get('IO').set_port('b',mask)
time.sleep(float(tifo_config.IO16.get(io.get('addr'))[6])/1000)
mask = io.get('IO').get_port('b') & (0b11111111 & ~ cmd.get('Pin'))
io.get('IO').set_port('b',mask)
else:
if value == 1:
mask = io.get('IO').get_port('b') | cmd.get('Pin')
else:
mask = io.get('IO').get_port('b') & (0b11111111 & ~ cmd.get('Pin'))
self.io16list.setValues(io.get('IO'),mask,'b')
io.get('IO').set_port('b',mask)
def set_io16(self,device,value):
#koennte noch auch .set_selected_values(port, selection_mask, value_mask) umgeschrieben werden
#monoflop tut nicht
cmd_lsts = tifo_config.IO16o.get(device)
for cmd in cmd_lsts:
if cmd.get('Value') == value:
cmds = cmd.get('Commands')
#print cmds
if type(cmds) in (list,tuple):
for cmd in cmds:
#print cmd
if cmd.get('Value') == 0: #erst alle auf Null setzen
addr = cmd.get('UID')
for io in self.io16list.liste:
if io.get('addr') == addr:
self.set_io16_sub(cmd,io,cmd.get('Value'))
for cmd in cmds:
if cmd.get('Value') == 1: #erst alle auf Null setzen
addr = cmd.get('UID')
for io in self.io16list.liste:
if io.get('addr') == addr:
self.set_io16_sub(cmd,io,cmd.get('Value'))
else:
cmd = cmds
addr = cmd.get('UID')
for io in self.io16list.liste:
if io.get('addr') == addr:
self.set_io16_sub(cmd,io,cmd.get('Value'))
return True
def _set_LED_zusammen(self,LED,start,ende,red,green,blue,transitiontime):
laenge = (ende-start)
o_r, o_g, o_b = LED.get('LED').get_rgb_values(start, 1)
steps = abs(red-o_r) + abs(green-o_g) + abs(blue-o_b)
wartezeit = float(transitiontime) / steps
while o_r <> red or o_g <> green or o_b <> blue:
while (laenge) > 16:
laenge = 16
if (red-o_r) > 0:
o_r = o_r + 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
elif (red-o_r) < 0:
o_r = o_r - 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
if (green-o_g) > 0:
o_g = o_g + 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
elif (green-o_g) < 0:
o_g = o_g - 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
if (blue-o_b) > 0:
o_b = o_b + 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
elif (blue-o_b) < 0:
o_b = o_b - 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
start += laenge
laenge = (ende-start)
else:
if (red-o_r) > 0:
o_r = o_r + 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
elif (red-o_r) < 0:
o_r = o_r - 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
if (green-o_g) > 0:
o_g = o_g + 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
elif (green-o_g) < 0:
o_g = o_g - 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
if (blue-o_b) > 0:
o_b = o_b + 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
elif (blue-o_b) < 0:
o_b = o_b - 1
LED.get('LED').set_rgb_values(start, laenge, o_r, o_g, o_b)
time.sleep(wartezeit)
def set_LED(self, **kwargs):
# device, rot, gruen, blau, transitiontime, transition=ANSTEIGEND
device = kwargs.get('Device')
# range check kwargs
try:
for varia in ['red','green','blue']:
if int(kwargs.get(varia)) > 255:
kwargs[varia] = 255
if int(kwargs.get(varia)) < 0:
kwargs[varia] = 0
green = int(kwargs.get('red',0))
blue = int(kwargs.get('green',0))
red = int(kwargs.get('blue',0))
transitiontime = kwargs.get('transitiontime')
transition = kwargs.get('transition',ANSTEIGEND)
proc = kwargs.get('percentage',None)
red_1 = kwargs.get('blue_1','None')
green_1 = kwargs.get('red_1','None')
blue_1 = kwargs.get('green_1','None')
red_2 = int(kwargs.get('blue_2',0))
green_2 = int(kwargs.get('red_2',0))
blue_2 = int(kwargs.get('green_2',0))
except:
print(kwargs)
return False
# gradient
# lauflicht
LEDDict = tifo_config.LEDsOut.get(device)
uid = LEDDict.get('UID')
start = LEDDict.get('Start')
ende = LEDDict.get('Ende')
# TODO vectorize
delta_r = 0
delta_g = 0
delta_b = 0
if str(red_1) == 'None' and str(green_1) == 'None' and str(blue_1) == 'None':
red = [int(red)]*16
green = [int(green)]*16
blue = [int(blue)]*16
gradient = False
else:
laenge = (ende-start)
if not str(red_1) == 'None':
delta_r = int(red_1) - int(red)
delta_pr = float(delta_r) / laenge
else:
delta_pr = 0
if not str(green_1) == 'None':
delta_g = (int(green_1) -int(green))
delta_pg = float(delta_g) / laenge
else:
delta_pg = 0
if not str(blue_1) == 'None':
delta_b = (int(blue_1) - int(blue))
delta_pb = float(delta_b) / laenge
else:
delta_pb = 0
gradient = True
for LED in self.LEDList.liste:
if LED.get('addr') == uid:
laenge = (ende-start)
if proc <> None and 0 <= proc <= 100:
laenge = int(float(proc)/100 * laenge)
elif proc <> None and proc < 0:
laenge = 0
if (transitiontime == None or transitiontime <= 0) and not gradient:
while (laenge) > 16:
laenge = 16
# TODO check that command is executed
# while not (red, green, blue) == LED.get('LED').get_rgb_values(start, laenge):
LED.get('LED').set_rgb_values(start, laenge, red, green, blue)
start += laenge
laenge = (ende-start)
else:
LED.get('LED').set_rgb_values(start, laenge, red, green, blue)
elif not (transitiontime == None or transitiontime <= 0):
# Ansteigend
if transition == ANSTEIGEND:
wartezeit = float(transitiontime) / (ende-start)
for birne in range(start,ende):
LED.get('LED').set_rgb_values(birne, 1, red, green, blue)
time.sleep(wartezeit)
elif transition == ABSTEIGEND:
wartezeit = float(transitiontime) / (ende-start)
for birne in list(reversed(range(start,ende))):
LED.get('LED').set_rgb_values(birne, 1, red, green, blue)
time.sleep(wartezeit)
elif transition == ZUSAMMEN:
self._set_LED_zusammen(LED,start,ende,red,green,blue,transitiontime)
else:
for birne in range(start,(start+laenge)):
LED.get('LED').set_rgb_values(birne, 1, [int(red)]*16, [int(green)]*16, [int(blue)]*16)
red += delta_pr
green += delta_pg
blue += delta_pb
for birne in range((start+laenge),ende):
LED.get('LED').set_rgb_values(birne, 1, [int(red_2)]*16, [int(green_2)]*16, [int(blue_2)]*16)
# TODO Transition, 4 types
# von links nach rechts (ansteigend), von rechts nach links (absteigend)
# alle zusammen, beides
return True
def set_drb(self, device, value):
uid_cmds = tifo_config.DualRelay.get(device)
uid = ''
for cmd in uid_cmds:
if (cmd.get('Value')) == float(value):
uid = cmd.get('UID')
state = cmd.get('state')
relaynr = cmd.get('relay')
for relay in self.drb:
temp_uid = str(relay.get_identity()[1]) +"."+ str(relay.get_identity()[0])
if temp_uid == uid:
relay.set_selected_state(relaynr, state)
return True
return False
def set_device(self, data_ev):
# TODO do threaded with stop criteria
if tifo_config.outputs.get(data_ev.get('Device')) == 'IO16o':
return self.set_io16(data_ev.get('Device'),data_ev.get('Value'))
elif tifo_config.outputs.get(data_ev.get('Device')) == 'IO16o':
return self.set_io16(data_ev.get('Device'),data_ev.get('Value'))
elif tifo_config.outputs.get(data_ev.get('Device')) == 'LEDs':
return self.set_LED(**data_ev) #data_ev.get('Device'),data_ev.get('red'),data_ev.get('green'),data_ev.get('blue'),data_ev.get('transitiontime'))
elif tifo_config.outputs.get(data_ev.get('Device')) == 'DualRelay':
return self.set_drb(data_ev.get('Device'),data_ev.get('Value'))
else:
return False
def cb_enumerate(self, 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:
self.LEDs.append(LEDStrip(uid, self.ipcon))
temp_uid = str(self.LEDs[-1].get_identity()[1]) +"."+ str(self.LEDs[-1].get_identity()[0])
self.LEDList.addLED(self.LEDs[-1],temp_uid)
self.LEDs[-1].set_frame_duration(200)
if tifo_config.LEDs.get(temp_uid) <> None:
self.LEDs[-1].set_chip_type(tifo_config.LEDs.get(temp_uid)[0])
self.LEDs[-1].set_frame_duration(tifo_config.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:
self.io.append(IO16(uid, self.ipcon))
temp_uid = str(self.io[-1].get_identity()[1]) +"."+ str(self.io[-1].get_identity()[0])
self.io16list.addIO(self.io[-1],temp_uid,16)
self.io[-1].set_debounce_period(100)
if tifo_config.IO16.get(temp_uid) <> None:
self.io[-1].set_port_interrupt('a', tifo_config.IO16.get(temp_uid)[0])
self.io[-1].set_port_interrupt('b', tifo_config.IO16.get(temp_uid)[1])
self.io[-1].set_port_configuration('a', tifo_config.IO16.get(temp_uid)[0],'i',True)
self.io[-1].set_port_configuration('b', tifo_config.IO16.get(temp_uid)[1],'i',True)
self.io[-1].set_port_configuration('a', tifo_config.IO16.get(temp_uid)[2],'o',False)
self.io[-1].set_port_configuration('b', tifo_config.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])
self.io[-1].register_callback(self.io[-1].CALLBACK_INTERRUPT, partial( self.cb_interrupt, device = self.io[-1], uid = temp_uid ))
found = True
if device_identifier == AmbientLight.DEVICE_IDENTIFIER:
self.al.append(AmbientLight(uid, self.ipcon))
self.al[-1].set_illuminance_callback_threshold('o', 0, 0)
self.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 = self.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))
self.al[-1].register_callback(self.al[-1].CALLBACK_ILLUMINANCE_REACHED, partial( self.cb_ambLight, device=args))
temp_uid = str(self.al[-1].get_identity()[1]) +"."+ str(self.al[-1].get_identity()[0])
found = True
thread_cb_amb = Timer(60, self.thread_ambLight, [self.al[-1]])
thread_cb_amb.start()
if device_identifier == BrickletCO2.DEVICE_IDENTIFIER:
self.co2.append(BrickletCO2(uid, self.ipcon))
temp_uid = str(self.co2[-1].get_identity()[1]) +"."+ str(self.co2[-1].get_identity()[0])
found = True
thread_co2_ = Timer(5, self.thread_CO2, [self.co2[-1]])
thread_co2_.start()
self.threadliste.append(thread_co2_)
if device_identifier == BrickletDualRelay.DEVICE_IDENTIFIER:
self.drb.append(BrickletDualRelay(uid, self.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:
self.md.append(BrickletMotionDetector(uid, self.ipcon))
temp_uid = str(self.md[-1].get_identity()[1]) +"."+ str(self.md[-1].get_identity()[0])
self.md[-1].register_callback(self.md[-1].CALLBACK_MOTION_DETECTED, partial( self.cb_md, device = self.md[-1], uid = temp_uid ))
self.md[-1].register_callback(self.md[-1].CALLBACK_DETECTION_CYCLE_ENDED, partial( self.cb_md_end, device = self.md[-1], uid = temp_uid ))
found = True
if device_identifier == BrickletSoundIntensity.DEVICE_IDENTIFIER:
self.si.append(BrickletSoundIntensity(uid, self.ipcon))
temp_uid = str(self.si[-1].get_identity()[1]) +"."+ str(self.si[-1].get_identity()[0])
# TODO: remove all ifs
found = True
self.si[-1].set_debounce_period(1000)
self.si[-1].register_callback(self.si[-1].CALLBACK_INTENSITY_REACHED, partial( self.cb_si, device = self.si[-1], uid = temp_uid ))
self.si[-1].set_intensity_callback_threshold('>', 200, 0)
if device_identifier == BrickletPTC.DEVICE_IDENTIFIER:
self.ptc.append(BrickletPTC(uid, self.ipcon))
temp_uid = str(self.ptc[-1].get_identity()[1]) +"."+ str(self.ptc[-1].get_identity()[0])
found = True
thread_pt_ = Timer(5, self.thread_pt, [self.ptc[-1]])
thread_pt_.start()
self.threadliste.append(thread_pt_)
if device_identifier == BrickMaster.DEVICE_IDENTIFIER:
self.master.append(BrickMaster(uid, self.ipcon))
thread_rs_error = Timer(60, self.thread_RSerror, [])
#thread_rs_error.start()
if tifo_config.inputs.get(uid) <> None:
found = True
if not found:
print connected_uid, uid, device_identifier
def cb_connected(self, connected_reason):
# Enumerate devices again. If we reconnected, the Bricks/Bricklets
# may have been offline and the configuration may be lost.
# In this case we don't care for the reason of the connection
self.ipcon.enumerate()
class readTFsensors:
def __init__(self):
self.tmpHW = None
self.tmpFR = None
self.tmpMain = None
self.tmpHWval = 0
self.tmpFRval = 0
self.tmpMainval = 0
# Create IP Connection
self.ipcon = IPConnection()
# Register IP Connection callbacks
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED, self.cb_connected)
# Connect to brickd, will trigger cb_connected
self.ipcon.connect( HOST, PORT )
self.ipcon.enumerate()
# wait until all values are being received
Logger.debug('waiting for all sensors to send values ...')
while self.tmpHWval==0 or self.tmpFRval==0 or self.tmpMainval==0:
now = round( datetime.datetime.timestamp(datetime.datetime.now()) )
Logger.debug( str(now) + ' (HW, FR, main) ' + str(self.tmpHWval)+', '+str(self.tmpFRval)+', '+str(self.tmpMainval) )
time.sleep(15) # wait 15 seconds
Logger.debug( 'all sensors found: (HW, FR, main)' + str(self.tmpHWval)+', '+str(self.tmpFRval)+', '+str(self.tmpMainval) )
# loop to check if source code was changed,
# then exit the python program in order to get it restarted by the shell script
while True:
time.sleep(120) # wait 2 minutes
# check if script source code has changed
newScrChgDate = os.path.getmtime(__file__)
if ( scriptChangeDate != newScrChgDate ):
Logger.info("Source code changed, (ending script). Old: "+str(scriptChangeDate) + ", New: " + str(newScrChgDate) )
sys.exit(9) # means 'reload and restart'
# check if debugging is requested
if os.path.isfile('debug_off'):
Logger.setLevel(logging.INFO)
# check if debugging is requested
if os.path.isfile('debug_on'):
Logger.setLevel(logging.DEBUG)
# Callback updates temperature
# - for heatwater temperature
def cb_tempHW(self, temperature):
self.tmpHWval = temperature/100.0
writeSensFile("HW", self.tmpHWval, self.tmpHWval, self.tmpFRval, self.tmpMainval)
# - for front room temperature
def cb_tempFR( self, temperature):
self.tmpFRval = temperature/100.0
writeSensFile("FR", self.tmpFRval, self.tmpHWval, self.tmpFRval, self.tmpMainval)
# - for main room temperature
def cb_tempMain(self, temperature):
self.tmpMainval = temperature/100.0
writeSensFile("Main", self.tmpMainval, self.tmpHWval, self.tmpFRval, self.tmpMainval)
# Callback handles device connections and configures possibly lost
# configuration of lcd and temperature callbacks, backlight etc.
def cb_enumerate(self, uid, connected_uid, position, hardware_version, firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
# Enumeration is for Temperature Bricklets
if device_identifier == Temperature.DEVICE_IDENTIFIER:
# Create individual temperature device objects for each sensor
if uid==HW_ID:
self.tmpHW = Temperature(uid, self.ipcon)
self.tmpHWval = self.tmpHW.get_temperature()/100.0 # read initial value
writeSensFile("HW", self.tmpHWval, self.tmpHWval, self.tmpFRval, self.tmpMainval)
self.tmpHW.register_callback( self.tmpHW.CALLBACK_TEMPERATURE, self.cb_tempHW )
self.tmpHW.set_temperature_callback_period(500)
elif uid==FR_ID:
self.tmpFR = Temperature(uid, self.ipcon)
self.tmpFRval = self.tmpFR.get_temperature()/100.0 # read initial value
writeSensFile("FR", self.tmpFRval, self.tmpHWval, self.tmpFRval, self.tmpMainval)
self.tmpFR.register_callback( self.tmpFR.CALLBACK_TEMPERATURE, self.cb_tempFR )
self.tmpFR.set_temperature_callback_period(500)
elif uid==MAIN_ID:
self.tmpMain = Temperature(uid, self.ipcon)
self.tmpMainval = self.tmpMain.get_temperature()/100.0 # read initial value
writeSensFile("Main", self.tmpMainval, self.tmpHWval, self.tmpFRval, self.tmpMainval)
self.tmpMain.register_callback( self.tmpMain.CALLBACK_TEMPERATURE, self.cb_tempMain )
self.tmpMain.set_temperature_callback_period(500)
# Callback handles reconnection of IP Connection
def cb_connected(self, connected_reason):
# Enumerate devices again. If we reconnected, the Bricks/Bricklets
# may have been offline and the configuration may be lost.
# In this case we don't care for the reason of the connection
self.ipcon.enumerate()
from tinkerforge.bricklet_piezo_speaker import PiezoSpeaker
if __name__ == "__main__":
try:
host = sys.argv[1]
port = int(sys.argv[2])
uid = sys.argv[3]
frequency = int(sys.argv[4])
trigger = int(sys.argv[5])
wait = int(sys.argv[6])
except:
print("usage: {0} <host> <port> <ps-uid> <frequency> <trigger-duration> <wait-duration>".format(sys.argv[0]))
sys.exit(1)
ipcon = IPConnection()
ps = PiezoSpeaker(uid, ipcon)
sema = Semaphore(0)
ipcon.connect(host, port)
def beep_finished():
sema.release()
ps.register_callback(ps.CALLBACK_BEEP_FINISHED, beep_finished)
ps.beep(trigger, frequency)
sema.acquire()
sleep(wait / 1000.0)
ipcon.disconnect()
class Blinkenlights(QApplication):
HOST = "localhost"
PORT = 4223
ipcon = None
projects = []
active_project = None
error_msg = None
def __init__(self, args):
super(QApplication, self).__init__(args)
self.error_msg = QErrorMessage()
self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION)
signal.signal(signal.SIGINT, self.exit_demo)
signal.signal(signal.SIGTERM, self.exit_demo)
self.make_gui()
self.connect()
def exit_demo(self, signl=None, frme=None):
try:
self.ipcon.disconnect()
self.timer.stop()
self.tabs.destroy()
except:
pass
sys.exit()
def make_gui(self):
self.main = MainWindow(self)
self.main.setWindowIcon(QIcon(os.path.join(ProgramPath.program_path(), "demo-icon.png")))
self.tabs = QTabWidget()
widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.tabs)
widget.setLayout(layout)
self.main.setCentralWidget(widget)
self.setup = SetupWidget(self.tabs, self)
self.tetris = TetrisWidget(self.tabs, self)
self.pong = PongWidget(self.tabs, self)
self.fire = FireWidget(self.tabs, self)
self.text = TextWidget(self.tabs, self)
self.images = ImagesWidget(self.tabs, self)
self.rainbow = RainbowWidget(self.tabs, self)
self.projects.append(self.setup)
self.projects.append(self.tetris)
self.projects.append(self.pong)
self.projects.append(self.fire)
self.projects.append(self.text)
self.projects.append(self.images)
self.projects.append(self.rainbow)
self.tabs.addTab(self.setup, "Setup")
self.tabs.addTab(self.tetris, "Tetris")
self.tabs.addTab(self.pong, "Pong")
self.tabs.addTab(self.fire, "Fire")
self.tabs.addTab(self.text, "Text")
self.tabs.addTab(self.images, "Images")
self.tabs.addTab(self.rainbow, "Rainbow")
self.active_project = self.projects[0]
self.tabs.currentChanged.connect(self.tab_changed_slot)
self.main.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION)
self.main.show()
def connect(self):
config.UID_LED_STRIP_BRICKLET = None
self.setup.label_led_strip_found.setText('No')
self.setup.label_led_strip_uid.setText('None')
config.UID_MULTI_TOUCH_BRICKLET = None
self.setup.label_multi_touch_found.setText('No')
self.setup.label_multi_touch_uid.setText('None')
config.UID_DUAL_BUTTON_BRICKLET = (None, None)
self.setup.label_dual_button1_found.setText('No')
self.setup.label_dual_button1_uid.setText('None')
self.setup.label_dual_button2_found.setText('No')
self.setup.label_dual_button2_uid.setText('None')
config.UID_PIEZO_SPEAKER_BRICKLET = None
self.setup.label_piezo_speaker_found.setText('No')
self.setup.label_piezo_speaker_uid.setText('None')
config.UID_SEGMENT_DISPLAY_4X7_BRICKLET = None
self.setup.label_segment_display_found.setText('No')
self.setup.label_segment_display_uid.setText('None')
if self.ipcon != None:
try:
self.ipcon.disconnect()
except:
pass
self.ipcon = IPConnection()
host = self.setup.edit_host.text()
port = self.setup.spinbox_port.value()
try:
self.ipcon.connect(host, port)
except Error as e:
self.error_msg.showMessage('Connection Error: ' + str(e.description) + "<br><br>Brickd installed and running?")
return
except socket.error as e:
self.error_msg.showMessage('Socket error: ' + str(e) + "<br><br>Brickd installed and running?")
return
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
# Wait for a second to give user visual feedback
timer = QTimer(self)
timer.setSingleShot(True)
timer.timeout.connect(self.ipcon.enumerate)
timer.start(250)
def tab_changed_slot(self, tabIndex):
self.active_project.stop()
self.active_project = self.projects[tabIndex]
self.active_project.start()
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
if device_identifier == LEDStrip.DEVICE_IDENTIFIER:
config.UID_LED_STRIP_BRICKLET = uid
self.setup.label_led_strip_found.setText('Yes')
self.setup.label_led_strip_uid.setText(uid)
elif device_identifier == MultiTouch.DEVICE_IDENTIFIER:
config.UID_MULTI_TOUCH_BRICKLET = uid
self.setup.label_multi_touch_found.setText('Yes')
self.setup.label_multi_touch_uid.setText(uid)
elif device_identifier == DualButton.DEVICE_IDENTIFIER:
if config.UID_DUAL_BUTTON_BRICKLET[0] == None:
config.UID_DUAL_BUTTON_BRICKLET = (uid, None)
self.setup.label_dual_button1_found.setText('Yes')
self.setup.label_dual_button1_uid.setText(uid)
else:
config.UID_DUAL_BUTTON_BRICKLET = (config.UID_DUAL_BUTTON_BRICKLET[0], uid)
self.setup.label_dual_button2_found.setText('Yes')
self.setup.label_dual_button2_uid.setText(uid)
elif device_identifier == PiezoSpeaker.DEVICE_IDENTIFIER:
config.UID_PIEZO_SPEAKER_BRICKLET = uid
self.setup.label_piezo_speaker_found.setText('Yes')
self.setup.label_piezo_speaker_uid.setText(uid)
elif device_identifier == SegmentDisplay4x7.DEVICE_IDENTIFIER:
config.UID_SEGMENT_DISPLAY_4X7_BRICKLET = uid
self.setup.label_segment_display_found.setText('Yes')
self.setup.label_segment_display_uid.setText(uid)
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
self.error_msg.showMessage('Enumerate Error: ' + str(e.description))
time.sleep(1)