How it Works
Video Showing the Devices in Action
Design Goals
Two Versions of the Project
Building the Simple Prototypes
Custom Version
Building the Custom Version PCB
Programming the Custom Version
Signal Processing Details

Published July 13, 2020 © GPL3+

Safe Distance Protection Badge

A wearable badge that warns users if they encroach another user's safe social distance. Low cost and no infrastructure required to operate.

IntermediateFull instructions provided8 hours15,128

Things used in this project

Hardware components

nRF24L01+ module

Many vendors sell this module, some for under $2.00 each. For Simple Prototype or Custom version

Ultrasonic Sensor - HC-SR04 (Generic)

For Simple Prototype or Custom Version Desolder the piezo receiver and transmitter transducers to use in this project. They are very sensitive and cheaper than single transducers sold alone.

Piezo buzzer, 5v

For Simple Prototype

Arduino Nano R3

The Arduino Nano can be used to build a simple prototype. However, it uses too much power to be battery operated for long. A custom design is required with an Atmega 328P. For Simple Prototype

Resistor 1M ohm

For Simple Prototype

USB power pack

Source of portable power for the Arduino Nano. For Simple Prototype

Custom Board

For Custom version. See attached Eagle schematic, board design, and detailed BOM for a custom board that has additional features like vibrating motor, LIPO charge control, and on/off switches in a more compact form factor.

LiPo cell 1000mAH capacity, protected

For Custom version. A protected Lipo cell.

Brown Dog Gadgets Solar Cockroach Vibrating Disc Motor

For Custom Version 3V vibrating motor, 100mA max. With adhesive backing.

10-pin 2x5 Socket-Socket 1.27mm IDC (SWD) Cable - 150mm long

For Custom Version. In this project we modify this cable to use it to program the Atmega 328P on the Custom board.

SparkFun FTDI Basic Breakout - 3.3V

For Custom Version. You will need a USB to serial converter designed for programming an Arduino board without an FTDI chip.

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

3D Printer (generic)

Used to print an enclosure for Custom version of the device.

Story

This project is meant to help people maintain social distance to avoid spreading COVID19. In some settings and surroundings its easy for people to forget to keep a safe distance, and so this device could help remind them. For example, for younger children this device makes it clear what is safe distance and what is not. In situations like public events where strangers need to maintain a distance the device can provide consistent guidance without people having to police themselves or each other. This could be useful in schools, museums, recreational facilities, or workplaces.

The device does not require wifi and needs only minimal infrastructure to charge the device (USB 5v). It uses basic technology and can be put together using low cost readily available components.

There are two designs for flexibility- a simple one that can be made with off the shelf boards and modules in a couple hours and another that uses a custom board for a full product.

How it Works

Everyone is given a device to wear. The devices measure the time it takes for a sound to travel from one person to another. Sound travels approximately 0.340 meters per millisecond, so for a social distance of 2 meters, sound takes approximately 6ms to travel that distance. We can use high frequency sound, so that it remains inaudible to people.

To make this measurement, we need to quickly and accurately synchronize between the devices, and that's where we use radio waves, traveling at the speed of light. We use an nrf24l01+ transceiver module to send a communication between the devices. This communication occurs very quickly (under 1 ms) so can be thought of as nearly instantaneous.

The communication has the following steps:

1. One device (the 'sender') sends an RF packet to all other devices in radio frequency range. It then begins listening for an ultrasonic ping.

2. Any device that receives the RF signal immediately responds with an ultrasonic ping.

3. The ping from the closest device to the 'sender' arrives first to the 'sender'. The 'sender' measures the duration between RF send and ultrasonic receive. If this duration is less than approximately 6ms, we know the users are too close, and the RF sender alerts its user via the piezo buzzer.

4. Each device becomes a 'sender' on random occasions in order to ensure the RF channel is shared and every user has distance measurements.

Video Showing the Devices in Action

Here is a short video about the device:

Design Goals

One of the goals of the design was to minimize the component count and leverage the Arduino Nano as much as possible for the ultrasonic send and receive. For sending, two output pins are used in push-pull fashion, supplying 10v peak to peak output to the piezo ultrasonic transducer. A timer driven interrupt is used to generate the 40kHz ping signal. For receiving, the Arduino Nano's differential comparator inputs are used to detect zero crossing of the signal. The same timer driven interrupt implements a matched filter that detects the ping. It works surprisingly well at the distance ranges needed.

Simple prototype using an Arduino Nano

Unfortunately, an Arduino Nano draws significant current (30-40mA) all the time, in order to power the MCU and the USB to serial interface. This means an Arduino is great for prototyping but the finished device needs to use less power to keep it small and battery operated. The finished device also needs to be able to manage battery charging, allowing the power to be turned on and off, and have a compact build.

Two Versions of the Project

For this reason this project has two versions. There is a Simple Prototype, which allows you to easily and quickly build working devices to experiment and learn. The other version is called the CustomVersion, since it uses a custom board similar to the Nano, but with features to reduce power consumption, charge a battery, and power a vibrating motor, and in a smaller form factor. Both versions run the same Arduino code, and can be used together. The Simple Prototype is easy to build. The Custom Version is a more advanced project, and requires populating a PC board and programming the Arduino boot-loader.

Building the Simple Prototypes

You will want to build at least two prototypes so that you can see how they work together. The prototypes can be wired using jumpers with Dupont connectors. Here is the schematic.

Ultrasonic Receiver/Transmitter

I started with using the piezo transducers removed from the HC-SR04 ultrasonic/sonar distance sensor module. The receiver transducer on these modules works very well for this application. The transmitter transducer also works with slightly less sensitivity. I experimented with other parts, like the Pui Audio UT-1640K-TT-2-T transmitter, but got poorer performance than the above.

A 1 mega-ohm resistor is placed across the transducer to help bias the comparator. The value is not super critical and it will work with a value from a few hundred K ohms to a few M ohms.

Beeper

The beeper should be a 5v continuous tone beeper that contains its own tone oscillator.

nRF24L01+ Breakout Board

These breakout boards are available from a variety of sources. Below is a table that shows the hookup. Make sure the connections are tight, since loose wires will cause the transmission to fail.

Connections for the Arduino Nano

Upload the Firmware

Program the Nano with the Arduino IDE. The firmware depends on the RF24 library, which can be downloaded from the IDE's Tools->Manage Libraries... menu.

The easiest way to power the prototypes is to use cell phone portable charging battery packs. The 5v USB output can power the Nano. You can also use a single Lipo cell with built-in protection to power the Nano. Just supply the power directly to the 5V pin and GND.

Simple 3D Printed Case

For the Simple Prototype, there is a simple case design, making it possible to wear the device like a medallion.

A simple case for the simple prototype

the case can be printed out in PLA or PETG. I used.2mm layer height and 20% infill.

A shoelace can be used as a lanyard and strung through both halves to help hold them together. The halves can be pressed together.

Firmware Tweaks

The firmware has some parameters that you can play around with and change the behavior of the device. For example, the distance trip point can be adjusted, the sensitivity of the matched filter, the ultrasonic output frequency, and RF frequency and strength.

Custom Version

The custom version relies on a custom designed board for this application. It uses a Atmega 328P processor at 16MHz, just like the Arduino Nano. This was my first standalone Arduino board and I used a couple tutorials on the Arduino site that showed how to construct them:

https://www.arduino.cc/en/Main/Standalone

https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard

https://www.arduino.cc/en/Tutorial/ArduinoISP

Custom Board (front)

Custom Board (back)

The board's main differences include:

Processor powered at 3.8V, to further reduce current consumption. This is the lowest specified voltage for reliable 16MHz operation.
nRF24L01+ powered at 3.0v, to reduce current consumption.
No USB to serial converter, to reduce current consumption. We will need an off-board USB-to-serial converter to program the board.
A USB connector for charging and a single cell LiPo charge circuit to safely charge a 1000mAh cell. This will power the device for approx 40-50 hours.
On and Off push-button circuit using voltage regulator enable pins.
Another voltage regulator to drive the vibrating motor.

Building the Custom Version PCB

Below are the steps needed to complete the PCB for the custom version. This requires preparing a PC board with solder paste, placing the SMD components, and heating the boards. I assume some familiarity with these steps. If you need a refresher, check online. Here is a good one on skillet reflow soldering from Sparkfun.

1. Get the board made. I used OSH Park to have 3 boards created. Here is a link to the project on their site.

2. You can go to OSH Stencils and make an inexpensive stencil for applying the solder paste. Choose the 3 mil Polyimide film to put down a thin layer of paste. You will need to upload the attached eagle.brd file to order the stencil. You may want to purchase their acrylic jig set, if you do not have a way to hold the stencil and board in alignment.

3. Order the parts on the attached BOM. I ordered them from Mouser electronics.

4. I like to organize all my parts on double-stick tape, in order to minimize the chance or error when populating the boards.

Use double stick carpet tape and a piece of cardboard to organize and label your parts.

6. Once you get the boards, clean them with acetone and make a jig to hold the board and stencil to allow you to spread the solder paste. You will want to make sure you have good alignment of the stencil with the board.

Board and stencil aligned in the jig

7. Apply the lead free solder paste. Below are the results of my solder spreading. I used 5 mil polyimide, rather than 3 mil, and ended up with too much paste in spots. I recommend the 3 mil for this project.

Boards ready for component placement

8. Place the components on the board. You can use a tweezers or a vacuum system. I use both, depending on the component size. For the vacuum system I use an old aquarium airpump, airhose, bic pen, paste needle, and heat shrink tubing on the needle.

Home grown vacuum placer

9. Here we use a skillet that is no longer used for food prep. Carefully transfer the boards to your skillet. Heat the skillet and reflow the boards. I use an infrared thermometer to check the temperature as I visually check for solder melting. Pull the boards off and let them cool.

Skillet Reflow

10. Inspect the solder for shorts and do some tests with an ohmmeter to make sure there are no shorts (check the point where the battery is connected, as one example). Make any fixes using solder wick.

Wait with soldering the through-hole parts until the bootloader is installedand tested. Installing the bootloader requires 5v power, and uses the same pins as the nRF24L01+ which could damage this part if its installed.

11. Solder only the J2 ICSP/Serial header to the board. Do not solder any other through-hole parts at this time

12. First power up - Use a 5v supply instead of a LiPo cell to initially power up the board. Use a 100 ohm resistor in series with the supply to limit the current to a low level. Monitor the current and make sure its only a few microamps. Press the 'on' button and check for proper voltage of the voltage regulators on C10 and C11. Press the 'off' button and the voltage should shut off. If this checks out you are ready to program.

Programming the Custom Version

This board needs a bootloader installed for it to behave like a typical Arduino board. We will be programming the Arduino bootloader using the technique in the Arduino tutorial here, which requires using another Arduino as an ISP. To do this we first need to make the proper connections to the board. The board has a 2x5 pin header labelled ICSP/Serial that exposes all the pins required for programming the bootloader as well as Arduino program uploads.

Programming header

You need to hack the Adafruit 10-pin 2x5 Socket-Socket 1.27mm IDC (SWD) Cable to make the connections. The picture below shows one approach - using a male pin header as a adapter to simplify the connections. Pin 1 is the GND pin and is the red wire in the ribbon cable.

When connecting the cable to the board, please ensure all the pins align appropriately. The pins are small and it can be hard to tell all 10 pins match up.

As shown on the Arduino Tutorial, you need to connect to the MOSI, MISO, SCK, RESET, GND, and power. Its OK to connect 5v to the pin marked 3.8v on the programming header since everything is 5 volt tolerant and we did not install the nRF24L01+ yet.

Once connected follow the tutorial on programming the bootloader. When programming the bootloader, select Arduino Nano as the board type for the bootloader image. This way the custom board will be recognized as a Nano by the Arduino IDE.

Arduino Programming

Now that the bootloader is programmed, you will want to test Arduino programming with a small program. Choose the blink program and if you like change the LED pin in the program to pin 4, so that the board LED will blink. In this step we want to go through the mechanics of programming and make sure we can land a program successfully on this board.

Since the custom board does not have an FTDI chip on it to translate USB to Serial communication, we need to attach the FTDI breakout board to program it. The Custom Board is like the Arduino Pro Mini, except it runs at 3.8V and 16MHz, rather than 3.3v and 8MHz. We will use the same wire hookup to program as the Pro Mini 3.3v, but in the IDE we will select Nano since we used the Nano bootloader.

The first step is to wire the FTDI breakout board with the Adafruit 10-pin 2x5 Socket-Socket 1.27mm IDC (SWD) Cable, to connect to the serial TX and RX ports, GND, and 3.3V. For this first programming we will want to power the board through the cable at 3.3v. We will be using the reset button on the board (S1) at the appropriate moment to allow programming.

Once the blink program loads successfully, the covid12.ino file can be uploaded to the board.

Subsequent programming can be done with battery power. In this case the positive power lead from the FTDI breakout board should be left disconnected. Don't forget to press the on button (S3) on the board to supply power. Also need to press the Reset button (S1) at the appropriate time to allow programming.

Solder remaining Through-hole Components

Once programming checks out you can solder the remaining through-hole components. You will need to cut the male pin header leads on the nRF24LS01+ so they do not protrude too far when soldered on the board. The Lipo cell wires can be soldered directly to the board or attached with a connector plug as shown.

3D printedEnclosure

The enclosure holds the board and battery and allows charging through the micro USB port, user control of the power buttons, and visibility of the LEDs indicating RF transmission/receive and charge state. A standard badge strap can be used to attach it to clothing. A lanyard can also be used.

The enclosure has 3 parts - the case front, case back, and 2 switch buttons.

Enclosure parts

Print in PETG using 0.2mm layer height, 20% infill. You will need support for the case back for the bar that attaches to the badge strap. The picture below shows where the support is needed.

The case back needs support around the attachment bar.

The switch buttons press fit in the holes in the back case, from the inside of the case. They have a lip that holds them in place so they should not fall out.

The circuit board and Lipo cell fit side by side in the back case. the vibrating motor can be stuck on the PC board as shown.

Placement of PC board and Lipo cell in the case

Operation

Power on by pressing the on button momentarily. You will see the blue LED flashing dimly when sending an RF signal and flashing more brightly when it receives an RF signal from another unit. Power off by pressing the off button. When off, the devices only uses a few microamps of power. To charge the device, use any 5v USB power source. Charging takes approximately 4 hrs for a fully depleted cell. A red LED will indicate charging and a green LED indicates the charge is complete. The device should run 50 hrs on a charge.

LED indicators Blue - ON, Red- Charging, Green - Charge Complete

Signal Processing Details

Push Pull Output

We use a push-pull output to generate 10v peak to peak pulses from a 5v source in the Simple Prototype, and the Custom version generates a 7.6v peak to peak pulse from a 3.8v source. This is done using 2 output pins that alternatively swing in opposite directions. This way we can drive the ultrasonic transducer with a stronger signal.

Since we use the same 2 pins as analog inputs, we need to ensure the signals on the pins settle down to microvolt levels quickly in order to measure any received ping. This is done by first setting both pins low, so that the voltage across the ultrasonic transducer is reduced. Then each pin is set as an input, and allowed some settling time as well.

Matched Filter

Matched filtering is a common way to detect return echos in radar and sonar systems. The matched filter is the optimallinear filter for maximizing the signal-to-noise ratio in the presence of additive random noise. It works by measuring the correlation between the incoming signal and a template signal (the ping). A high correlation means the signals match.

At each time point the correlation (sum of products) is calculated between the match filter waveform and the input waveform. For example, the sum below calculates the first cross correlation point.

Calculation of correlation for one time point (y0)

As new input data comes in, the data is shifted, and a new correlation point is calculated.

The closer the match between the waveforms, the higher the (positive or negative) magnitude of the correlation. If the signals are out of phase, the correlation is negative. By taking the absolute value and using a threshold we can detect the ping in the presence of noise.

A threshold is used on the absolute value of the cross correlation to detect the ping.

The longer the ping, the larger the match filter, and the more sensitive the detection becomes. The example above shows a period of 5, but the firmware uses a ping of 2 miliseconds, which corresponds to 80 periods of the 40kHz square wave.

In general this type of signal processing usually requires more processing power than an 8-bit Arduino and is done in the frequency domain using the Fast Fourier Transform (FFT). However, in this case we take advantage of a a few aspects of this problem to pull it off in the time domain on an 8 bit processor. First, we are dealing with a 1 bit input signal from the Arduino's input comparator. Also, our ping signal has a repeating pattern since it has a constant frequency. Finally we are sampling the signal right at the Nyquist frequency (80kHz) for the 40kHz ping. This simplifies the math and the memory requirements for the processing.

Simple recursion to calculate the matched filter for 1 bit signals

In the firmware interrupt, the matched filter calculation is done using a circular buffer the size of the match filter (ping length). This allows us to efficiently keep track of the start and end samples.

Schematics

Code

covid12.ino

/***************************************************************************
    Covid Safe Distance Badge Firmware v1.0

    Copyright (C) 2020 Filip Mulier

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses></http:>.

 ***********************************************************************/



#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
#include "LowPower.h"


unsigned char txmessage;  //written to rf
unsigned char rxmessage;  //read from rf

volatile unsigned char send_mode;  //if  0 we are off, 1 is in receive mode, 2 we are in send mode
volatile unsigned int send_count;  //  count down for number of pulses to send
volatile unsigned char pwm_out;


// Times in microseconds, converted to timer ticks
//  ticks depend on 16 MHz clock, so ticks = 62.5 ns
//  prescaler can divide that, but we're running fast enough to not need it

#define TIMER1_PRESCALE   1     // clock prescaler value
#define TCCR1B_CS20       0x01  // CS2:0 bits = prescaler selection
#define PERIOD_US   25.0  // 25 is 40khz
#define PERIOD_TICKS (microsecondsToClockCycles(PERIOD_US / 2) / TIMER1_PRESCALE)

//Speed of sound calculations
//  Speed of sound is 343m/s at 20 deg C, that is 343mm/ms
//  Timer 1 interrupt 12.5 usec per period, since it occurs 2x every 25 us
//  12.5 us/p * 1/1000 ms/us * 343mm/ms  =  4.2875 mm/p  = .42875 cm/p
// Convert this to something that calculates fast
//
//  .42875 is 55/128.
//  The max value for time measurement in unsigned int is 65535, so 65535/55 = 1191 is the max LISTEN_TIME

#define CONV_NUM 55
#define CONV_DENOM 128

#define SAFE_DISTANCE_BEEP 150 //Safe distance in cm
#define SAFE_DISTANCE_VIBRATE 200
#define BEEP_DURATION 10
#define VIBRATE_DURATION 70
#define LISTEN_MAX_RANGE 250 //Max range in cm , max is 510cm
#define LISTEN_TIME (LISTEN_MAX_RANGE * CONV_DENOM / CONV_NUM)


#define SEND_TIME 80*2 //number if interrupt cycles to send ultrasonic tone  2ms

#define SWITCH_TO_INPUT 2*80 // output is set to input at this time  1ms
#define OUTPUT_BLANK 5*80 // output is held off for this time after the signal is sent 3ms

#define BATTMINMV 3300  // minimum voltage for battery


//Matched filtering settings

#define CN 80 //Circular buffer size, should be length of 1 bit
#define HI_THRESH 5 //threshold used for detection half of CN divuded  by 2
#define DELAY_COMPENSATION (2*(HI_THRESH)) //amount of delay introduced due to matching a signal.
volatile signed char circ_buff[CN];
volatile signed char y_current = 0;
volatile signed char y_last = 0;
volatile unsigned char tnow = 0;

volatile unsigned int tm = 0;
volatile unsigned int tm_detect = 0;

unsigned long time_now = 0;
unsigned long next_time = 0;
unsigned long beep_time = 0;
unsigned long vibrate_time = 0;

#define SPI_SS   10   // OCR1B - low-active primary drive
#define INDICATOR_OUT 4  //pin used to light indicator LED
#define VIBRATE_OUT 3  //pin indicates matched output found
#define BEEPER_OUT 2 //pin used to turn on beeper

RF24 radio(5, 8);  // CE, CSN Set up nRF24L01 radio on SPI bus plus pins 5,8
// interrupt output pin is not used.

//Radio address
uint8_t address[][6] = {"0Node","1Node"};

void config_pwm() {

    noInterrupts();

    TCCR1B = 0x00;                 // stop Timer1 clock for register updates

    DDRB = DDRB &(~_BV(DDB1) & ~_BV(DDB2));  // set data direction to input

    // set the period and duty cycle
    ICR1 = PERIOD_TICKS;           // PWM period
    OCR1A = PERIOD_TICKS / 2;      // ON duration = drive pulse width = 50% duty cycle
    OCR1B = PERIOD_TICKS/2;      //  ditto - use separate load due to temp buffer reg


    //Switch to Compare Output Mode, non-PWM to set initial conditions of pins  per datasheet:
    //The easiest way of setting the OC1x value is to use the Force Output Compare (FOC1x) strobe bits in Normal mode.
    //The OC1x Register keeps its value even when changing between Waveform Generation modes.

    pwm_out = 1;
    TCCR1C = _BV(FOC1A) | _BV(FOC1B); //force output compare with strobe bits to initialize

    TCNT1 = OCR1A -1;             // force immediate OCR1x compare on next tick
    DDRB = DDRB | (_BV(DDB1) | _BV(DDB2));  // set data direction to output

    TIMSK1 |= ( _BV(OCF1A) );   //enable overflow interrupt


    // TIMSK1 |= (_BV(TOIE1) |  _BV(ICIE1));   //enable other interrupts


    TCCR1B = _BV(WGM13) | TCCR1B_CS20;  //turn on clock source with /8 prescaler to start timer.

    interrupts();

}


#define PIN_AIN0 6
#define PIN_AIN1 7


void config_comparator() {
    pinMode(PIN_AIN0,INPUT);
    pinMode(PIN_AIN1,INPUT);

    ADCSRB = ADCSRB & 0b10111111;           // (Disable) ACME: Analog Comparator Multiplexer Enable
    DIDR1 = 0x03; //disable digital input buffer on the analog inputs

    //read the comparator output by using bit 5 (ACO) of ACSR register.

}

inline void make_output() {

    DDRD = DDRD | (_BV(DDD6) | _BV(DDD7));
    // Above is to set data direction to output for pin 6 and 7 - equivalent to :
    //pinMode(PIN_AIN0,OUTPUT);
    //pinMode(PIN_AIN1,OUTPUT);
    // but less cycles

    PORTD = PORTD & (~_BV(PORTD6));
    PORTD = PORTD | _BV(PORTD7);
    //Above is equivalent to below, but takes less cycles.
    //digitalWrite(PIN_AIN0,LOW);
    //digitalWrite(PIN_AIN1,HIGH);


}

inline void make_input() {
    DDRD = DDRD & (~_BV(DDD6))&( ~_BV(DDD7));  // set data direction to input
    PORTD = PORTD & (~_BV(PORTD6)) & (~_BV(PORTD7));  //turn off pullup

}

//Set the compiler to high optimization for speed of code in the interrupt
#pragma GCC optimize ("-O3")
#pragma GCC push_options

ISR(TIMER1_COMPA_vect)  {

    unsigned char a_in;
    signed char y_abs;

// since interrupt time is an issue, we have logic to toggle between send and receive code

    if(send_mode == 1) {

        //input detection and updating circular buffer


        a_in = (ACSR & _BV(ACO)) >> (ACO);  //get comparator output and put in least significant bit

        y_current = (-y_last-a_in)+ circ_buff[tnow];
        y_last = y_current;
        circ_buff[tnow] = a_in;

        if ( tnow<(CN-1) )
            tnow = tnow +1;
        else
            tnow = 0;


        //update overall time
        tm = tm - 1;

        if(tm==0  || tm_detect > 0)
        {
            send_mode = 0;  //shut off listening
        }


        else {


            //test circular buffer for capture of signal
            if(y_current>HI_THRESH  || y_current <-HI_THRESH)  //check if abs value is greater than hi threshold
            {
                tm_detect = tm;
            }
        }

    } else if (send_mode == 2) { //send mode

        if(pwm_out) {
            PIND= 0b11000000;  //toggle pin 6 and 7 to generate a signal
        }
        send_count = send_count -1;
        // multiple byte output

        if(send_count == (OUTPUT_BLANK + SWITCH_TO_INPUT)) {
            // Set both output pins low
            PORTD = PORTD & (~(_BV(PORTD6) | _BV(PORTD7)));
            //shut down pwm output
            pwm_out = 0;

        } else if(send_count == SWITCH_TO_INPUT) {
            DDRD = DDRD & (~_BV(DDD6))&( ~_BV(DDD7));  // set data direction to input
            PORTD = PORTD & (~_BV(PORTD6)) & (~_BV(PORTD7));  //turn off pullup
        }
        else if (send_count == 0)
            send_mode = 0; //shut off send mode


    }  //end send mode

}

#pragma GCC pop_options




void setup() {
    noInterrupts();
    Serial.begin(115200);
    Serial.println("Covid badge Sonar");
    printf_begin();  //needed for debugging output


    pinMode(SPI_SS, OUTPUT);  //must set as output for SPI to work
    pinMode(INDICATOR_OUT, OUTPUT);
    pinMode(VIBRATE_OUT, OUTPUT);
    pinMode(BEEPER_OUT, OUTPUT);


    config_comparator();
    config_pwm();
    interrupts();

    radio.begin();
    radio.setChannel(100);
    radio.setDataRate(RF24_2MBPS);  //RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps
    radio.setPALevel(RF24_PA_MIN); //RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH and RF24_PA_MAX
    radio.setRetries(0,0);  //minimal delay, no retries
    radio.setPayloadSize(sizeof(txmessage));

    radio.openWritingPipe(address[0]);
    radio.openReadingPipe(1,address[0]);

    radio.startListening();
    radio.printDetails();

    delay(50);
    prep_read_ultrasonic();
    time_now = millis();
    next_time = time_now + random(50, 75);


}


long readVcc() {
    // Read 1.1V reference against AVcc
    // set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
    ADMUX = _BV(MUX5) | _BV(MUX0);
#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
    ADMUX = _BV(MUX3) | _BV(MUX2);
#else
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif

    delay(2); // Wait for Vref to settle
    ADCSRA |= _BV(ADSC); // Start conversion
    while (bit_is_set(ADCSRA,ADSC)); // measuring

    uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
    uint8_t high = ADCH; // unlocks both

    long result = (high<<8) | low;

    result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
    return result; // Vcc in millivolts
}


unsigned char checkVcc() {
    // Read 1.1V reference against AVcc
    // set the reference to Vcc and the measurement to the internal 1.1V reference
    // return 0 if voltage less than the limit for battery

#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
    ADMUX = _BV(MUX5) | _BV(MUX0);
#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
    ADMUX = _BV(MUX3) | _BV(MUX2);
#else
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif

    delay(2); // Wait for Vref to settle
    ADCSRA |= _BV(ADSC); // Start conversion
    while (bit_is_set(ADCSRA,ADSC)); // measuring

    uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH
    uint8_t high = ADCH; // unlocks both

    long result = (high<<8) | low;

    if (result > (1125300/BATTMINMV))  // check limit
        return 0;  // return 0 if voltage below limit
    else
        return 1;  //return 1 if voltage above limit


}

//Ultrasonic Routines

void prep_read_ultrasonic(void) {
    tnow = 0;
    tm_detect=0;
    y_last = 0;

    //zero circular buffer
    for( int i = 0; i < CN; i = i + 1 )
        circ_buff[i] = 0;
    make_input();  // go back to no output
}

unsigned int read_ultrasonic(unsigned int tm_listen_time) {

    tm = tm_listen_time;
    send_mode = 1; //start listening
    while(send_mode);  // listen for allotted time

    return(tm_listen_time - tm_detect);
}



void prep_write_ultrasonic(unsigned int duration) {

    send_count = duration + OUTPUT_BLANK + SWITCH_TO_INPUT;

}

void write_ultrasonic(void) {
    // Write Ultrasonics
    make_output();  // turn input pins to output //debug

    // set this flag to start the output
    pwm_out = 1;
    send_mode = 2;
    while (send_mode); //wait until send complete
}

bool write_status;

int count = 0;
unsigned int travel_time;

void loop() {

// Listen for RF
    if (radio.available()) { //Heard RF
        digitalWrite(INDICATOR_OUT,HIGH);
        radio.read(&rxmessage, sizeof(rxmessage));
        radio.stopListening();
        prep_write_ultrasonic(SEND_TIME);
        write_ultrasonic();
        prep_read_ultrasonic();
        radio.startListening();
        time_now = millis();
        next_time = time_now + random(50, 75);

    }

    else if ( millis() > next_time) {

        if(checkVcc() == 0) {
            Serial.println("Low Battery");
            digitalWrite(BEEPER_OUT,HIGH);
        }

        txmessage = 1 ; // we don't use the message for anything
        radio.stopListening();
        digitalWrite(INDICATOR_OUT,HIGH);
        write_status = radio.write(&txmessage, sizeof(txmessage));
        digitalWrite(INDICATOR_OUT,LOW);
        travel_time = read_ultrasonic(LISTEN_TIME);

        //Serial.println(readVcc());

        travel_time = (travel_time - DELAY_COMPENSATION)*CONV_NUM/CONV_DENOM;  //calculate in cm
        if (travel_time >0 && travel_time <SAFE_DISTANCE_VIBRATE)
        {
            digitalWrite(VIBRATE_OUT,HIGH);
            time_now = millis();
            vibrate_time = time_now + VIBRATE_DURATION;
            Serial.print("Danger:");
            Serial.println(travel_time);
        }
        else
        {
            Serial.print("Safe-v:");
            Serial.println(travel_time);
        }

        if (travel_time >0 && travel_time <SAFE_DISTANCE_BEEP)
        {
            digitalWrite(BEEPER_OUT,HIGH);
            time_now = millis();
            beep_time = time_now + BEEP_DURATION;
            Serial.print("Danger:");
            Serial.println(travel_time);
        }
        else {


            Serial.print("Safe-b:");
            Serial.println(travel_time);
        }


        prep_read_ultrasonic();
        time_now = millis();
        next_time = time_now + random(100, 150);
        radio.startListening();

    }

    // limit the time for vibration and beep
    if (digitalRead(BEEPER_OUT)) {
        if(  millis() > beep_time)
            digitalWrite(BEEPER_OUT,LOW);
    }

    if (digitalRead(VIBRATE_OUT)) {
        if(  millis() > vibrate_time)
            digitalWrite(VIBRATE_OUT,LOW);
    }


}

Credits

filipmu

2 projects • 12 followers

Engineer since the age of 10. In that time let the smoke out of many components and had many burned fingers while soldering.

Thanks to TMRh20 and Scott Daniels.

Safe Distance Protection Badge