Refining Automated Contact Tracing

 The Australian Government launched a contact tracing App, COVIDSafe, that records "close contacts" - people who have been close to each other for 15 minutes. 

This type of contact tracing will miss contacts where infection is acquired from a contaminated surface several hours after an infected person has left a location. 

From "How long does the novel coronavirus live on different surfaces?" - 

An example may be a bus where surfaces become contaminated by an infected passenger early in the morning, then passengers who travel on the same bus in the afternoon become infected due to contact with contaminated surfaces. 

The bus could have a bluetooth beacon device that uniquely identifies the bus. Passengers' phones running the COVIDSafe App could record the fact that they have travelled on the bus as they get on. 

If anyone who was on the bus tests positive to Covid-19, the COVIDSafe App data will show not only who they have been near for 15 minutes, but also places they have been where they may have acquired the infection - or where they may have contaminated surfaces where other people may later become infected. 

Finding 3 or 4 people who test positive for Covid-19 who have been on the same bus, even if not at the same time, will provide evidence of transmission via contaminated surfaces - which is more informative than the existing COVIDSafe App that can only identify contacts who have been near to each other. 

These "bluetooth beacon devices" could be placed anywhere: in elevators in apartment blocks and offices, near ATMs and at the entrances of cafes, restaurants and bars, etc. 

Suitable microprocessors for building "bluetooth beacon devices" are readily available, easy to program, and are inexpensive. 

The development and construction of the "bluetooth beacon devices" would create jobs. 

See for example -

"ESP32 BLE + Android + Arduino IDE = AWESOME" 

and this tutorial video on YouTube -

Robots go faster with Interrupt Service Routines

Example of an Arduino Uno sketch that uses an interrupt service routine to measure distance with an ultrasonic sensor.

JSN-SR04T DC5V Waterproof Ultrasonic Module Distance Measuring Sensor

A small modification allows the sketch to use both the interrupt service routine and the blocking "pulseIn()" statement that causes the processor to wait for the measurement to be completed. Notice the number of times the loop() subroutine is executed while waiting for each measurement to be completed.

Sample output - 
Measurement obtained by interrupt service routine only
======================================================
Number of times loop() executed while measurement being taken: 228
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from interrupt service routine 28   cm

Number of times loop() executed while measurement being taken: 1360
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from interrupt service routine 149   cm


Sample output - 
Measurement obtained by both 
interrupt service routine and "pulseIn()" statement
===================================================
Number of times loop() executed while measurement being taken: 1
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from pulseIn() statement 27   cm
distance from interrupt service routine 28   cm


Number of times loop() executed while measurement being taken: 1
isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
distance from pulseIn() statement 148   cm
distance from interrupt service routine 149   cm

Click on the button below to copy the sample sketch.

// JSN-SR04T-2.0 ultrasonic distance measurement module can provide 
// 20cm-600cm non-contact distance sensing function.
// Distance in centimetres is calculated from the duration of 
// a pulse that lasts for the time in microseconds till the 
// device detects an echo from a short burst of ultrasonic pulses.

// Distance (centimetres) = duration / 58
// Distance (inches) = duration / 148

// For the maximum distance of 600 cms, 
// duration is 600 * 58 = 34800 microseconds.
// If there is no obstacle within 600 cms, 
// the sensor's processor terminates the pulse after 38000 microseconds.
// Reference: 
//           JSN-SR04T-2.0 
//           20-600 cm Ultrasonic Waterproof Range Finder

// Initial sample sketch using pulseIn statment from 
// "Weather-proof Ultrasonic Sensor" at -
// https://www.dfrobot.com/wiki/index.php/Weather-proof_Ultrasonic_Sensor_SKU_:_SEN0207


// Rewritten to use an interrupt service routine (ISR) to calculate distances
// Use an interrupt pin for digital input 
// See https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/ 
#define ECHOPIN 2// Pin to receive echo pulse on an interrupt pin for Arduino Uno
#define TRIGPIN 3// Pin to send trigger pulse

// Use volatile variables for processing ISR result from echopin
// See https://www.arduino.cc/reference/en/language/variables/variable-scope--qualifiers/volatile/
#include <util/atomic.h> // this library includes the ATOMIC_BLOCK macro.

const unsigned int max_valid_value = 35000;

unsigned int echo_value_from_pulseIn;
unsigned int echo_value_from_ISR;
int distance_value_from_pulseIn;
int distance_value_from_ISR;

int loopcounter = 0;

unsigned long last_distance_measure_time;

volatile unsigned long time_start_for_echo_wait;
volatile unsigned long time_end_of_echo_wait;

unsigned long from_isr_time_start_for_echo_wait;
unsigned long from_isr_time_end_of_echo_wait;
volatile unsigned long time_of_echo_change; // only used inside the ISR 
                                            // to temporarily hold time of entry to ISR

volatile byte isr_start_occurred = 0;
volatile byte isr_end_occurred = 0;
volatile byte isr_change_occurred = 0;

boolean measurement_inflight = false;  // Set to true when a measurement is commenced
boolean measurement_ready = false;     // Set to true when a measurement is completed 
                                       // and ready to print and/or save

void setup() {
  Serial.begin(115200);
  pinMode(ECHOPIN, INPUT_PULLUP); // enable internal pullup resistor
  pinMode(TRIGPIN, OUTPUT);
  last_distance_measure_time = millis();
  // attach interrupt handler
  attachInterrupt (digitalPinToInterrupt (ECHOPIN), EchoChange, CHANGE);  
}

void loop() {
  loopcounter++; // Keep track of how many times the loop is executed. 
                 // There are no program delays when using the
                 // interrupt service routine to measure distance.
  if (millis() - last_distance_measure_time > 1000) { // Start a new measurement, 
                                                      // clearing any indication of previous ones
    last_distance_measure_time = millis();
    measurement_inflight = true;
    measurement_ready = false;
    loopcounter = 1;  // The first time in loop() for this measurement
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
       // code with interrupts blocked (consecutive atomic operations will not get interrupted)
       isr_start_occurred = 0;
       isr_end_occurred = 0;    
       isr_change_occurred = 0;
    }
    digitalWrite(TRIGPIN, LOW); // Set the trigger pin to low for 2uS
    delayMicroseconds(2);
    digitalWrite(TRIGPIN, HIGH); // Send a 10uS high to trigger ranging
    delayMicroseconds(10);
    digitalWrite(TRIGPIN, LOW); // Send pin low again 
    
    // To compare accuracy of the measurment techniques, comment out next line and uncomment line below it.
    echo_value_from_pulseIn = 0;
    //echo_value_from_pulseIn = pulseIn(ECHOPIN, HIGH, 40000); // timeout for JSN-SR04T-2.0 sensor is 38mSecs 
                                                               // if no pulse received (ie 38000 microSeconds)
    // To obtain measurements with only the Interrupt Service Routine 
    // and have no delays in the loop() leave the above commenting as is.
    
    Serial.println("");
    Serial.print("Echopin high. Result: ");
    Serial.println(echo_value_from_pulseIn);
  }

  if (measurement_inflight) { // If a measurement has been started, 
                              // check values set in the ISR to see if it has completed.
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
      // code with interrupts blocked (consecutive atomic operations will not get interrupted)
      // int result = input_from_interrupt; // example
      if (isr_end_occurred == 1) { // Copy end time stored by interrupt service routine
        from_isr_time_end_of_echo_wait = time_end_of_echo_wait;
        measurement_inflight = false; // The measurement has now been completed
        measurement_ready = true;      // The measurement is ready to be calculated, printed and saved
        if (isr_start_occurred == 1) { // Copy start time stored by interrupt service routine
          from_isr_time_start_for_echo_wait = time_start_for_echo_wait;
        }
      }              
    }
  } //end if measurement_inflight

  if (measurement_ready) {
    Serial.println("");
    Serial.print("Number of times loop() executed while measurement being taken: ");
    Serial.println(loopcounter);
    Serial.print("isr_start_occurred = ");
    Serial.print(isr_start_occurred);
    Serial.print(", isr_end_occurred = ");
    Serial.print(isr_end_occurred);   
    Serial.print(", isr_change_occurred = ");
    Serial.println(isr_change_occurred);  
    if (echo_value_from_pulseIn > 0 && echo_value_from_pulseIn < max_valid_value) {
      distance_value_from_pulseIn = echo_value_from_pulseIn / 58;
      Serial.print("distance from pulseIn() statement ");
      Serial.print(distance_value_from_pulseIn);
      Serial.println("   cm");
    } else {
      Serial.println("No valid measurement obtained by pulseIn statement.");
    }
    echo_value_from_ISR = from_isr_time_end_of_echo_wait - from_isr_time_start_for_echo_wait;
    if (echo_value_from_ISR > 0 && echo_value_from_ISR < max_valid_value) {
      distance_value_from_ISR = echo_value_from_ISR / 58;
      Serial.print("distance from interrupt service routine ");
      Serial.print(distance_value_from_ISR);
      Serial.println("   cm");  
    } else {
      Serial.println("No valid measurement obtained by interrupt service routine.");
    }
   measurement_ready = false; // Don't redo this process until a new measurement is made.
  } // end if measurement_ready

  // Any other processing ...
}

// Interrupt Service Routine that is executed when the echo pin changes (from low to high and high to low).
void EchoChange() {
  time_of_echo_change = micros(); // Save the time in microseconds when the ISR is entered
  isr_change_occurred++;
  if (digitalRead(ECHOPIN) == HIGH) { // Start of timing pulse  
    time_start_for_echo_wait = time_of_echo_change;
    isr_start_occurred = 1;    
  } else { // End of timing pulse
    time_end_of_echo_wait = time_of_echo_change;
    isr_end_occurred = 1;
  }
}

// Sample output - measurement obtained by interrupt service routine only
// ======================================================================
//  Echopin high. Result: 0
//  
//  Number of times loop() executed while measurement being taken: 228
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from interrupt service routine 28   cm
//  
//  Echopin high. Result: 0
//  
//  Number of times loop() executed while measurement being taken: 1360
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from interrupt service routine 149   cm


// Sample output - measurement obtained by both interrupt service routine and "pulseIn()" statement
// ===============================================================================================
//  Echopin high. Result: 1619
//  
//  Number of times loop() executed while measurement being taken: 1
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from pulseIn() statement 27   cm
//  distance from interrupt service routine 28   cm
//  
//  Echopin high. Result: 8617
//  
//  Number of times loop() executed while measurement being taken: 1
//  isr_start_occurred = 1, isr_end_occurred = 1, isr_change_occurred = 2
//  distance from pulseIn() statement 148   cm
//  distance from interrupt service routine 149   cm