Kits / Starter Kit: Hardware Hacking / Examples / Read out Smoke Detectors / Using Ruby

Read out Smoke Detectors using Ruby¶

For this project we are assuming, that you have a Ruby development environment set up and that you have a rudimentary understanding of the Ruby language.

If you are totally new to Ruby 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.

Goals¶

We are setting the following goal for this project:

Read out the alarm status of a smoke detector
and react on its alarm signal.

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

Bricklets are exchanged (i.e. we don't rely on UIDs),
Brick Daemon isn't running or is restarted,
WIFI Extension is out of range or
Brick is restarted (power loss or accidental USB removal).

In the following we will show step-by-step how this can be achieved.

Step 1: Discover Bricks and Bricklets¶

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:

ipcon = IPConnection.new
ipcon.connect HOST, PORT

ipcon.register_callback(IPConnection::CALLBACK_ENUMERATE) do |uid, connected_uid, position,
                                                              hardware_version, firmware_version,
                                                              device_identifier, enumeration_type|
end

ipcon.register_callback(IPConnection::CALLBACK_CONNECTED) do |connected_reason|
end

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:

ipcon.register_callback(IPConnection::CALLBACK_CONNECTED) do |connected_reason|
  if connected_reason == IPConnection::CONNECT_REASON_AUTO_RECONNECT
    ipcon.enumerate
  end
end

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:

HOST = 'localhost'
PORT = 4223

ipcon = IPConnection.new
ipcon.connect HOST, PORT

ipcon.register_callback(IPConnection::CALLBACK_ENUMERATE) do |uid, connected_uid, position,
                                                              hardware_version, firmware_version,
                                                              device_identifier, enumeration_type|
end

ipcon.register_callback(IPConnection::CALLBACK_CONNECTED) do |connected_reason|
  if connected_reason == IPConnection::CONNECT_REASON_AUTO_RECONNECT
    ipcon.enumerate
  end
end

ipcon.enumerate

Step 2: Initialize Bricklet on Enumeration¶

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):

ipcon.register_callback(IPConnection::CALLBACK_ENUMERATE) do |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 CALLBACK_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 == BrickletIndustrialDigitalIn4::DEVICE_IDENTIFIER
  idi4 = BrickletIndustrialDigitalIn4.new uid, ipcon
  idi4.set_debounce_period 10000
  idi4.set_interrupt 15
  idi4.register_callback(BrickletIndustrialDigitalIn4::CALLBACK_INTERRUPT) do |interrupt_mask, value_mask|
  end
end

Step 2 put together:

ipcon.register_callback(IPConnection::CALLBACK_ENUMERATE) do |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 == BrickletIndustrialDigitalIn4::DEVICE_IDENTIFIER
      idi4 = BrickletIndustrialDigitalIn4.new uid, ipcon
      idi4.set_debounce_period 10000
      idi4.set_interrupt 15
      idi4.register_callback(BrickletIndustrialDigitalIn4::CALLBACK_INTERRUPT) do |interrupt_mask, value_mask|
      end
    end
  end
end

Step 3: Handle the alarm signal¶

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.

idi4.register_callback(BrickletIndustrialDigitalIn4::CALLBACK_INTERRUPT) do |interrupt_mask, value_mask|
  if value_mask > 0
    puts 'Fire! Fire!'
  end
end

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!

Step 4: Error handling and Logging¶

On startup, we need to try to connect until the connection works:

while true
  begin
    ipcon.connect HOST, PORT
    break
  rescue Exception => e
    puts 'Connection Error: ' + e
    sleep 1
  end
end

and we need to try enumerating until the message goes through:

while true
  begin
    ipcon.enumerate
    break
  rescue Exception => e
    puts 'Enumerate Error: ' + e
    sleep 1
  end
end

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 == BrickletIndustrialDigitalIn4::DEVICE_IDENTIFIER
  begin
    idi4 = BrickletIndustrialDigitalIn4.new uid, ipcon
    idi4.set_debounce_period 10000
    idi4.set_interrupt 15
    idi4.register_callback(BrickletIndustrialDigitalIn4::CALLBACK_INTERRUPT) do |interrupt_mask, value_mask|
      if value_mask > 0
        puts 'Fire! Fire!'
      end
    end
    puts 'Industrial Digital In 4 initialized'
  rescue Exception => e
    idi4 = nil
    puts 'Industrial Digital In 4 init failed: ' + e
  end
end

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.

Step 5: Everything put together¶

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 ruby
# -*- ruby encoding: utf-8 -*-

require 'tinkerforge/ip_connection'
require 'tinkerforge/bricklet_industrial_digital_in_4'

include Tinkerforge

HOST = 'localhost'
PORT = 4223

idi4 = nil

ipcon = IPConnection.new
while true
  begin
    ipcon.connect HOST, PORT
    break
  rescue Exception => e
    puts 'Connection Error: ' + e
    sleep 1
  end
end

ipcon.register_callback(IPConnection::CALLBACK_ENUMERATE) do |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 == BrickletIndustrialDigitalIn4::DEVICE_IDENTIFIER
      begin
        idi4 = BrickletIndustrialDigitalIn4.new uid, ipcon
        idi4.set_debounce_period 10000
        idi4.set_interrupt 15
        idi4.register_callback(BrickletIndustrialDigitalIn4::CALLBACK_INTERRUPT) do |interrupt_mask, value_mask|
          if value_mask > 0
            puts 'Fire! Fire!'
          end
        end
        puts 'Industrial Digital In 4 initialized'
      rescue Exception => e
        idi4 = nil
        puts 'Industrial Digital In 4 init failed: ' + e
      end
    end
  end
end

ipcon.register_callback(IPConnection::CALLBACK_CONNECTED) do |connected_reason|
  if connected_reason == IPConnection::CONNECT_REASON_AUTO_RECONNECT
    puts 'Auto Reconnect'
    while true
      begin
        ipcon.enumerate
        break
      rescue Exception => e
        puts 'Enumerate Error: ' + e
        sleep 1
      end
    end
  end
end

while true
  begin
    ipcon.enumerate
    break
  rescue Exception => e
    puts 'Enumerate Error: ' + e
    sleep 1
  end
end

puts 'Press key to exit'
$stdin.gets
ipcon.disconnect