Video Trailer
Background
The Project
Theory of Operation
Operational Use
Beeper Instead of Vibro Motor
Software
Testing with Various RF Devices
Enclosure
Future Improvements

Published October 10, 2016 © GPL3+

Hexiwear RF Energy Detector

Adapts the Hexiwear to become glasses that can see the radio frequency energy around you, showing strength and frequency.

IntermediateFull instructions provided2 hours1,102

Things used in this project

Hardware components

NXP Hexiwear

Hexiwear Unit and Docking Station

RF Meter Click MIKROE-2034

1 MHz-8 GHz RF Power Meter, using Analog Devices AD8318

Coax Cable

Any coax to connect the RF splitters. The two paths on each splitter should have a 3 inch difference in length between them in order to estimate frequency

Antenna, Rubber duck style, or a wire

Any antenna to pick up signals

Audio Indicator

Optional Beeper instead of using Hexiwear Vibro

RF Splitter

Any wideband RF splitter, including TV splitters can be substituted, Like Walmart Monoprice 110013

Software apps and online services

ARM mbed.org Online Compiler

Putty

For serial com monitor

Hexi Blinky Example

Hexi OLED Text Example

Hexi Vibro Example

Hand tools and fabrication machines

RF Signal Generator

Optional, to calibrate frequency and power

Soldering iron (generic)

Optional, to solder in beeper instead of using Hexiwear Vibro motor

Oscilloscope

For troubleshooting & verification

Story

Video Trailer

Hexiwear RF Environment Monitor

Background

Radio Frequency (RF) Energy is all around us. There is a LOT of money in industry behind the RF devices that are filling our lives. RF has been added to home utility meters, never mind the myriads of cell phones, WiFi devices, appliance remotes, car remotes, .. the list is just growing....

There are some studies out there indicating all this RF may have biological effects. Some people are traveling cross country to the town in the USA where radio frequency energy free-zones have been established!

People being attacked by RF Energy!

Wouldn't it be revealing to have glasses to see all this energy floating around us? What devices in our homes are putting out this energy? When are they transmitting? What frequency is the radiation?

The Hexiwear platform with the myriad of Click boards offers a rapid prototyping of any concept. This project uses the RF Click modules in the HexiWear docking station to produce a sensing platform to reveal the Radio Frequency (RF) energy around us.

The Project

Even though it would be great to use the built-In Hexiwear Blue Tooth connection to monitor this platform to your smart phone, we can't, as all this is an example of the RF energy we are talking about!

During this project, it was also discovered that the RF Clicks must be read as rapidly as possible, as many RF sources have short transmissions that if the code is busy doing something else, like updating displays, you missed the brief presence of RF energy!

The platform consists of:

1. Hexiwear in the docking station with with two RF Click modules

2. An antenna, that is connected to an RF splitter

3. Two RF splitters that are combined using unequal cable lengths

4. Optionally: We added a beeper wired in place of the internal Vibro motor to alarm for High RF energy levels

Assembly Photo

Theory of Operation

Th RF Click module converts RF energy into an ADC word value over the broad frequency band of 1 MHz to 8 GHz.

See this link for an overview of the RF Spectrum

The first RF splitter splits the energy captured by the antenna to one RF click module. This module measures the power present. The user can set a threshold at which an alarm (Red LED) occurs.

The other half of the first splitter goes to another pair of splitters that recombine the signal again after is has traveled across two different paths. The unequal paths create a phase difference that creates a cancellation pattern, imparting an amplitude difference Vs frequency. This pattern is used in a look up table to estimate the frequency of the RF energy. If the frequency is between 700 MHz and 1.4 GHz, an estimate is provided to the user.

Different path differences will create different RF responses Vs frequency. A third channel could be added to cover a larger band, or a different path difference between the two coaxes could be used to move the optimal frequency detection coverage to a different part of the spectrum.

Operational Use

Power up system. The threshold for alarm can be set by pressing buttons T1 and T2 on the docking station. Note the alarm may still beep even though the display indicated power is still below the threshold. This is because the displayed power is an average value, and many of the RF signals are short duration. The RF Monitor captures these short duration pulses and sounds the alarm.

Operational View of System

The HexiWear LED will glow red if it has detected energy above the threshold set by the buttons. It glows green when the levels are above the system noise floor, but not large enough to trigger a major (Red) alarm.

The serial monitor also shows the min/max/average ADC counts from the sensors.

HexiWear Serial Port Information

The display and serial port are only updates every few seconds, as we discovered much of the RF environment consists of short pulses, so the HexiWear must spend its time reading the ADC's as any other activities risk missing the RF energy.

Beeper Instead of Vibro Motor

The RF environment is so congested, that the vibro motor was vibrating the Hexiwear off the docking station, so we modified the Hexiwear to have a beeper sound instead of the vibrating motor. Just detach one of the motor leads and solder the beeper indicator in the parts list in its place. See photo below:

Wiring in a beeper in place of the Vibro Motor

Beeper hot glued on top of HexiWear module

Software

There were several key hurdles during software development:

1) We used mBed.org compiler, as the FreeRTos was something we would have needed more time to become familiar with

2) Also found the spi.frequency() command would not change the clock rate on the SPI lines. Not sure if this was a bug or something we were doing wrong, but the RF Click can't be read much faster than 100KS/s, and we measured teh Hexiwear clock on the SPI line at over 15 MHz, and it would not change withissuing different spi.frequency() commands. This resulted in ocassionally WRONG readings from the RF Click modules. Therefore, we wrote a bit-bang version of the SPI code, so the timing could be compliant.

3) Updating the display takes a lot of time away from reading the RF Click Modules, and we discovered modern RF devices are communicating in short pulses. If you aren't reading them constantly, you miss these bursts. Therefore, the main loop must be kept lean, dominating the time reading the modules. We therefore only update the displays only every few seconds. The alarms and LED warnings happen immediately, however.

4) On power up, we discovered the RF environment is FULL of energy. We needed to add a user adjustable threshold to ignore below some threshold, otherwise the unit would ring continuously!

Testing with Various RF Devices

Below is a video, testing the system with various RF devices. It's amazing how much a WiFi routers and phone put out into the environment. The phones even transmit when they are turning off!

Final Testing

Enclosure

The RF Splitters can be replaced by three resistors, so conceptually the HexiWear main body could be mounted on a board in a smaller form factor than the Docking Station. This board would have the RF splitters and RF Click Boards(or the integrated circuits soldered directly to the board) integrating the concept in a sleek form factor. An antenna is needed as well. This was sketched in Fusion 360 to illustrate the concept.

Concept Sketch of Packaging

Future Improvements

Custom Package

Add a 3rd channel for better frequency estimation

An a low noise amplifier to the antenna to make it even more sensitive.

Schematics

Code

main

#include "mbed.h"
#include "Hexi_OLED_SSD1351.h"
#include "Hexi_KW40Z.h"
#include "string.h"
#include "math.h"

 DigitalOut cs1(PTC4); // Dock 1
 DigitalOut greenLed(LED2,1); // To indicate some signals present
 DigitalOut redLed(LED1,1);  // To indicate siganls above alarm threshold
 DigitalOut spi_clk(PTC5);  // CLK Coms to RF Click
 DigitalIn spi_dat(PTC7);   // DATA Coms to RF Click
 DigitalOut vibro(PTB9);    // TO indicate signals above alarm threshold
 DigitalIn up_btn(PTA12,PullDown);
 DigitalIn down_btn(PTA13,PullDown);
 DigitalOut cs2(PTC3); // Dock 2

Serial pc(USBTX,USBRX);
 /* Instantiate the Hexi KW40Z Driver (UART TX, UART RX) */ 
KW40Z kw40z_device(PTE24, PTE25);

/* Instantiate the SSD1351 OLED Driver */ 
SSD1351 oled(PTB22,PTB21,PTC13,PTB20,PTE6, PTD15); /* (MOSI,SCLK,POWER,CS,RST,DC) */

int main() {
    unsigned int i;
    unsigned int mydata1,mydata2;
    unsigned int max1,max2;
    unsigned int min1,min2;
    unsigned int mysum1,mysum2;
    unsigned int ave1,ave2;
    unsigned int lut[]={0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 1024, 2048};
    unsigned int ave_samples1[10];
    unsigned int ave_samples2[10];
    unsigned int icount;
    unsigned int j;
    unsigned int num_ave;
    unsigned char trigger_vibro;
    unsigned int vibro_count;
    unsigned int loop_count;
    float pwr1;
    float frq;
    int delta;
    unsigned int longterm_ave;
    unsigned long longterm_sum;
    int threshold;
    float threshold_dbm;
    
     char text[20];  /* Text Buffer */ 
     vibro=0;
     greenLed=0;
     wait(0.25);
     greenLed=1;
     wait(0.25);
     greenLed=0;
     wait(0.25);
     greenLed=1;
   
   
     
 printf("\n\r--------------------\n\rProgram Started!\n\r---------------------------\n\r");    
    /* Get OLED Class Default Text Properties */
    oled_text_properties_t textProperties = {0};
    oled.GetTextProperties(&textProperties);    

    /* Turn on the backlight of the OLED Display */
    oled.DimScreenON();
    
    /* Fills the screen with solid black */         
    oled.FillScreen(COLOR_BLACK);

    /* Display Text at (x=7,y=0) */
    strcpy((char *) text,"Radio Energy");
    oled.Label((uint8_t *)text,7,0);
        
    /* Change font color to blue */ 
    textProperties.fontColor   = COLOR_BLUE;
    oled.SetTextProperties(&textProperties);

    /* Set text properties to white and right aligned for the dynamic text */
    textProperties.fontColor = COLOR_WHITE;
    textProperties.alignParam = OLED_TEXT_ALIGN_RIGHT;
    oled.SetTextProperties(&textProperties);    

    num_ave=10;
    min1=9999;
    min2=9999;
    max1=0;
    max2=0;
    icount=0;
    trigger_vibro=0;
    loop_count=0;
    threshold=3000;  // Default Red LED threshold
    
    while (true) {
       loop_count++;
       // Process Statistics
       min1=9999;
       min2=9999;
       max1=0;
       max2=0;
       mysum1=0;
       mysum2=0;
       for(j=0;j<num_ave;j++)
       {
         mysum1=mysum1+ave_samples1[j];
         mysum2=mysum2+ave_samples2[j];
         if(ave_samples1[j]<min1)min1=ave_samples1[j];
         if(ave_samples2[j]<min2)min2=ave_samples2[j];
         if(ave_samples1[j]>max1)max1=ave_samples1[j];
         if(ave_samples2[j]>max2)max2=ave_samples2[j];
        }         
        ave1=mysum1/num_ave;
        ave2=mysum2/num_ave;
        if(icount>=num_ave) icount=0;
         
         if (min1<2400)// Hard coded threshold for green LED
         {
             greenLed=0;
         }else
         {
             greenLed=1;
         }

        if (min1<threshold)
        {
            redLed=0;
            greenLed=1;
            trigger_vibro=1;
        }else
        {
            trigger_vibro=0;
        }

    if(trigger_vibro)
    {
        vibro_count=1;
        redLed=0;
        vibro=1;
    }
    else
    {
        vibro_count++;
        if(vibro_count>200)
        {
            vibro=0;
            redLed=1;
        }
    }
        


// We are doing a Bit Bang SPIbecause mbed.org spi.frequency(F) runs clock at >15 MHz, regardless of F
// RF Click can not sampel at that speed
// Clock 2 ycls, then clock 12 to read 12 bits of data out
    // Chips must be deselected
    cs1 = 1;
    cs2 = 1;
    
 // Read Dock 1
    cs1 = 0;
    mydata1=0;
    for (i=0;i<14;i++)  
    {
        spi_clk=0;
        spi_clk=1;
        if(i>2)
        {
            if(spi_dat.read())
            {      
            mydata1=mydata1+lut[13-i+1];
            }
        }
    }
    spi_clk=0;
   
// Read Dock 2   
    cs1=1;
    cs2=0;
    mydata2=0;
    for(i=0;i<14;i++)
    {
        spi_clk=0;
        spi_clk=1;
   
        if(i>2)
        {
            if(spi_dat.read())
            {
                    mydata2=mydata2+lut[13-i+1];
            }
        }
    }  
    spi_clk=0;
   cs2=1;

// Fill a running buffer   
ave_samples1[icount]=mydata1;
ave_samples2[icount]=mydata2;
icount++;
 longterm_sum=longterm_sum+ave1;
 if(loop_count>20000)  // Only update tghe display ocassionally, as sampling ADC more important to catch RF energy in pulses
 {
    // Update red LED threshold if user uis pressing buttons to change
    if(up_btn.read())threshold=threshold+100;
    if(down_btn.read())threshold=threshold-100;
    if(threshold>3300) threshold=3300;  //No signal ADC values
    if(threshold<100) threshold=100;
    
    threshold_dbm=(-0.020*threshold)+23;  // Calculate threshold in dBm from counts
    longterm_ave=longterm_sum/(loop_count-1);
    longterm_sum=0;
    loop_count=0;   
    pwr1=(-0.020*mydata1)+23.0;  // this converts counts to dBm (RF power referenced in dB to 1 mW)
    delta=mydata2-mydata1;   // Calculate difference between main channel and other channel
    frq=0.436+.0015*delta-5.886e-7*delta*delta;  // This calculates approximate frequency
    sprintf(text,"Set:%.1fdBm", threshold_dbm);
    /* Display time reading in 35px by 15px textbox at(x=2, y=40) */
    oled.TextBox((uint8_t *)text,2,25,80,15); //Increase textbox for more digits
    sprintf(text,"Now:%.1fdBm",pwr1);
    oled.TextBox((uint8_t *)text,2,45,80,25);
  
    if(frq<0.7)  // Its flat below 700 MHz, cant really declare a frequency
    {
       sprintf(text,"F=    <0.7 GHz");
    }
    else
    {
       sprintf(text,"F=    %.1f",frq);
    }
    oled.TextBox((uint8_t *)text,2,65,80,25);
   // Print some debug info to serial port
   printf("flr: %i frq:%.2f Min: %i\tNow: %.1f\tAve: %i\tMax: %i\t\tMin: %i\tNow: %i\tAve: %i\tMax: %i\t\n\r",longterm_ave,frq,min1,pwr1,ave1,max1,min2,mydata2,ave2,max2);
   }
 }
 
    printf("\n\r ---- Program Complete ----- \n\r");
}

Credits

The Putz

2 projects • 3 followers

Hexiwear RF Energy Detector