payIOTA - Internet of Public Transport Payments

payIOTA is the stepping stone proof-of-concept for a seamless and universal public transport payment system.

IntermediateWork in progress1.5 hours916

payIOTA - Internet of Public Transport Payments

Things used in this project

Hardware components

Android device

Personal Computer with BLE support

Software apps and online services

Node.js

Android Studio

Story

We live in an increasingly rushed world were every minute counts. We "fast forward" in the "road" of life using more and more services to improve our efficiency at work, our success in sports or our overall enjoyment of life.

It comes as no surprise that smartphones increasingly capture our attention and are becoming the "natural" way of interacting with services. We use them for checking the weather, calling a cab/Uber, communicating with our loved ones and for so many other things.

So, why not use it to pay for public transportation? Well... there are already plenty of applications allowing paying transports via Smartphone App. Numerous cities and public transportation companies have adopted some variation of electronic payment, e.g., using QR codes, Bluetooth beacons, or embedded NFC communications. So, where is the challenge?

"The difficult is what takes a little time; the impossible is what takes a little longer" - Fridtjof Nansen

A London bus passes a telephone box on Haymarket, Westminster, London, UK.

Actually, there are two key challenges:

Existing systems are not transparent, i.e., the user is required to explicitly interact with the transport payment system (e.g., read a QR code, access an App or show the smartphone screen to some reader). In busy transports, having to spend time in this process can congest the access and significantly degrade the user experience.
Existing systems rely on bank transactions for rapid payments, which encompass non-negligible costs. If the payments are conducted using pre-charged credit, the user is putting forward his/her money in benefit of the operator without having consumed any service. Conversely, if the payment is done after the service provision in a regular basis, the operator has to support the upfront costs and charge only after a (typically) long period of service use (e.g., monthly).

The idea is simple: install Bluetooth (IOTA) Beacons in public transports and use them together with a smartphone App on the passenger's smartphone to detect their entry/exit, and automatically pay for the trip.

payIOTA's envisaged operation scheme

This project provides a proof-of-concept of the idea by implementing both the smartphone (Andoid) App and a Beacon simulator. The App "sees" all the advertising beacons installed in the public transports and can fetch specific information from them, namely the associated transaction hash, which stores relevant information in the Tangle (e.g., fee, bus zone, address to pay).

Currently, as a demonstration, the payment process in the Andoid App is done manually, initiated when the user selects an IOTA beacon followed by tapping the IOTABeacon BLE characteristic.

The Android App was developed in Android Studio using the programming language Kotlin. The app source code is a modified project taken from the base project:

https://github.com/objectsyndicate/Kotlin-BluetoothLeGatt

The IOTA API library used in the app is the IOTA's JOTA Java library 1.0.0-beta1.

The beacon itself is implemented on Node.js using the Bleno library. The source code is a modified version of Bleno's "echo" example:

https://github.com/noble/bleno/tree/master/examples/echo

It only advertises the transaction hash containing the payment information. The code

To run the beacon node, Bluetooth must be on, Node.js installed and root permissions must be granted to the node. To run the node:

sudo node main.js

The beacon only advertises a transaction hash which contains the payment data. In our example, the data is stored in:9GQPJQWSIRCKQZG9VGXMPVYVSWUDEIULRQPIHHQSBHXTSQTSFCKYPD9EWFQKMGOGUVJXBIYRXBBUA9999

The app reads the transaction hash and fetches the payment data from the Tangle. If there are any changes that need to be made to the payment data, the operator issues another transactions and changes the transaction hash that the beacons emit.

* In our app, currently, the payment is done only through a dummy transaction, no actual exchange of IOTAs is made. A transaction is added to the Tangle under the address stored in the data of the advertised transaction.

var bleno = require('bleno');

var BlenoPrimaryService = bleno.PrimaryService;

var EchoCharacteristic = require('./characteristic');

const beacon_name = 'IOTABeacon ' + Math.random().toString(36).substring(2,8)

console.log(beacon_name);

bleno.on('stateChange', function(state) {
  console.log('on -> stateChange: ' + state);

  if (state === 'poweredOn') {
    bleno.startAdvertising(beacon_name , ['107a']);
  } else {
    bleno.stopAdvertising();
  }
});

bleno.on('advertisingStart', function(error) {
  console.log('on -> advertisingStart: ' + (error ? 'error ' + error : 'success'));

  if (!error) {
    bleno.setServices([
      new BlenoPrimaryService({
        uuid: '107a',
        characteristics: [
          new EchoCharacteristic()
        ]
      })
    ]);
  }
});

var util = require('util');

var bleno = require('bleno');

var BlenoCharacteristic = bleno.Characteristic;

var EchoCharacteristic = function() {
  EchoCharacteristic.super_.call(this, {
    uuid: '107a',
    properties: ['read'],
    value: null
  });

  this._value = Buffer.from("9GQPJQWSIRCKQZG9VGXMPVYVSWUDEIULRQPIHHQSBHXTSQTSFCKYPD9EWFQKMGOGUVJXBIYRXBBUA9999");
  this._updateValueCallback = null;
};

util.inherits(EchoCharacteristic, BlenoCharacteristic);

EchoCharacteristic.prototype.onReadRequest = function(offset, callback) {
  console.log('IOTABeacon Address = ' + this._value.toString('hex'));

  callback(this.RESULT_SUCCESS, this._value);
};

module.exports = EchoCharacteristic;