For this project we are assuming, that you have a Python development environment set up and that you have a rudimentary understanding of the Python language.
If you are totally new to Python itself you should start here. If you are new to the Tinkerforge API, you should start here.
We are also assuming that you have a smoke detector connected to an Industrial Digital In 4 Bricklet as described here.
We are setting the following goal for this project:
Since this project will likely run 24/7, we will also make sure that the application is as robust towards external influences as possible. The application should still work when
In the following we will show step-by-step how this can be achieved.
To start off, we need to define where our program should connect to:
HOST = "localhost"
PORT = 4223
If the WIFI Extension is used or if the Brick Daemon is running on a different PC, you have to exchange "localhost" with the IP address or hostname of the WIFI Extension or PC.
When the program is started, we need to register the CALLBACK_ENUMERATE
callback and the CALLBACK_CONNECTED
callback and trigger a first
enumerate:
def __init__(self):
self.ipcon = IPConnection()
self.ipcon.connect(SmokeDetector.HOST, SmokeDetector.PORT)
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
self.ipcon.enumerate()
The enumerate callback is triggered if a Brick gets connected over USB or if
the enumerate()
function is called. This allows to discover the Bricks and
Bricklets in a stack without knowing their types or UIDs beforehand.
The connected callback is triggered if the connection to the WIFI Extension or to the Brick Daemon got established. In this callback we need to trigger the enumerate again, if the reason is an auto reconnect:
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
self.ipcon.enumerate()
An auto reconnect means, that the connection to the WIFI Extension or to the Brick Daemon was lost and could subsequently be established again. In this case the Bricklets may have lost their configurations and we have to reconfigure them. Since the configuration is done during the enumeration process (see below), we have to trigger another enumeration.
Step 1 put together:
class SmokeDetector:
HOST = "localhost"
PORT = 4223
def __init__(self):
self.ipcon = IPConnection()
self.ipcon.connect(SmokeDetector.HOST, SmokeDetector.PORT)
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
self.ipcon.enumerate()
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
self.ipcon.enumerate()
During the enumeration we want to configure the Industrial Digital In 4 Bricklet. Doing this during the enumeration ensures that the Bricklet gets reconfigured if the Brick was disconnected or there was a power loss.
The configurations should be performed on first startup
(ENUMERATION_TYPE_CONNECTED
) as well as whenever the enumeration is
triggered externally by us (ENUMERATION_TYPE_AVAILABLE
):
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:
We configure the Industrial Digital In 4 Bricklet to call the cb_interrupt
callback if a change of the voltage level on any input pin is detected. The
debounce period is set to 10s (10000ms) to avoid being spammed with callbacks.
Interrupt detection is enabled for all inputs (15 = 0b1111).
if device_identifier == IndustrialDigitalIn4.DEVICE_IDENTIFIER:
self.idi4 = IndustrialDigitalIn4(uid, self.ipcon)
self.idi4.set_debounce_period(10000)
self.idi4.set_interrupt(15)
self.idi4.register_callback(IndustrialDigitalIn4.CALLBACK_INTERRUPT,
self.cb_interrupt)
Step 2 put together:
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 == IndustrialDigitalIn4.DEVICE_IDENTIFIER:
self.idi4 = IndustrialDigitalIn4(uid, self.ipcon)
self.idi4.set_debounce_period(10000)
self.idi4.set_interrupt(15)
self.idi4.register_callback(IndustrialDigitalIn4.CALLBACK_INTERRUPT,
self.cb_interrupt)
Now we need to react on the alarm signal of the smoke detector. But we want to
react only if the LED is turned on, not if it is turn off. This is done by
checking value_mask
for being > 0
. In that case there is a voltage
applied to at least one input, therefore, the LED is on.
def cb_interrupt(self, interrupt_mask, value_mask):
if value_mask > 0:
log.warn('Fire! Fire!')
That's it. If we would copy these three steps together in one file and execute it, we would have a working program that reads the alarm status of a hacked smoke detector and reacts on its alarm signal!
Currently the program just outputs a warning. There are several ways to extend this. For example, the program could send an email or a text message to notify someone about the alarm.
However, we do not meet all of our goals yet. The program is not yet robust enough. What happens if it can't connect on startup? What happens if the enumerate after an auto reconnect doesn't work?
What we need is error handling!
On startup, we need to try to connect until the connection works:
while True:
try:
self.ipcon.connect(SmokeDetector.HOST, SmokeDetector.PORT)
break
except Error as e:
log.error('Connection Error: ' + str(e.description))
time.sleep(1)
except socket.error as e:
log.error('Socket error: ' + str(e))
time.sleep(1)
and we need to try enumerating until the message goes through:
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
log.error('Enumerate Error: ' + str(e.description))
time.sleep(1)
With these changes it is now possible to first start the program and connect the Master Brick afterwards.
We also have to deal with errors during the initialization:
if device_identifier == IndustrialDigitalIn4.DEVICE_IDENTIFIER:
try:
self.idi4 = IndustrialDigitalIn4(uid, self.ipcon)
self.idi4.set_debounce_period(10000)
self.idi4.set_interrupt(15)
self.idi4.register_callback(IndustrialDigitalIn4.CALLBACK_INTERRUPT,
self.cb_interrupt)
log.info('Industrial Digital In 4 initialized')
except Error as e:
log.error('Industrial Digital In 4 init failed: ' + str(e.description))
self.idi4 = None
Additionally we added some logging. With the logging we can later find out what exactly caused a potential problem.
For example, if we connect to the Master Brick via Wi-Fi and we have regular auto reconnects, it likely means that the Wi-Fi connection is not very stable.
That's it! We are already done with our hacked smoke detector and all of the goals should be met.
Now all of the above put together (download):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import socket
import sys
import time
import math
import logging as log
log.basicConfig(level=log.INFO)
from tinkerforge.ip_connection import IPConnection
from tinkerforge.ip_connection import Error
from tinkerforge.bricklet_industrial_digital_in_4 import IndustrialDigitalIn4
class SmokeDetector:
HOST = 'localhost'
PORT = 4223
ipcon = None
idi4 = None
def __init__(self):
self.ipcon = IPConnection()
while True:
try:
self.ipcon.connect(SmokeDetector.HOST, SmokeDetector.PORT)
break
except Error as e:
log.error('Connection Error: ' + str(e.description))
time.sleep(1)
except socket.error as e:
log.error('Socket error: ' + str(e))
time.sleep(1)
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
log.error('Enumerate Error: ' + str(e.description))
time.sleep(1)
def cb_interrupt(self, interrupt_mask, value_mask):
if value_mask > 0:
log.warn('Fire! Fire!')
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 == IndustrialDigitalIn4.DEVICE_IDENTIFIER:
try:
self.idi4 = IndustrialDigitalIn4(uid, self.ipcon)
self.idi4.set_debounce_period(10000)
self.idi4.set_interrupt(15)
self.idi4.register_callback(IndustrialDigitalIn4.CALLBACK_INTERRUPT,
self.cb_interrupt)
log.info('Industrial Digital In 4 initialized')
except Error as e:
log.error('Industrial Digital In 4 init failed: ' + str(e.description))
self.idi4 = None
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
log.info('Auto Reconnect')
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
log.error('Enumerate Error: ' + str(e.description))
time.sleep(1)
if __name__ == "__main__":
log.info('Smoke Detector: Start')
smoke_detector = SmokeDetector()
if sys.version_info < (3, 0):
input = raw_input # Compatibility for Python 2.x
input('Press key to exit\n')
if smoke_detector.ipcon != None:
smoke_detector.ipcon.disconnect()
log.info('Smoke Detector: End')