Team IOT 32: Daniel Cornett, William Ladd

Published November 15, 2018

Bicycle Movement Tracking Using Particle Photon

Track the distance, speed, and acceleration of your bicycle in real time using two Particle Photons.

IntermediateFull instructions provided10 hours1,417

Bicycle Movement Tracking Using Particle Photon

Things used in this project

Hardware components

Particle Photon

7Pin 0.96 Inch IIC/SPI Serial 128x64 White OLED Display Module

Breadboard (generic)

Hall Effect Sensor

4xAA battery holder

AA Batteries

Electrical Tape

Magnets

Resistor 1k ohm

Resistor 10k ohm

5 mm LED: Green

Female/Female Jumper Wires

Male/Male Jumper Wires

Software apps and online services

ThingSpeak API

Hand tools and fabrication machines

Wire Strippers

Weller WLC100 40-Watt Soldering Station

3D Printer

Superglue

Zip Ties

Story

Overview

Whether you want to brag how fast you can go, or if you just want to track your weekend bicycle excursion, this project allows you to keep tabs on your distance, speed and acceleration. Two Particle Photons and a Hall-Effect sensor are used to measure the revolutions of the back tire of the bicycle. This allows for the calculation of distance, speed, and acceleration.

Video Overview of the Project (Re-upload)

Video Overview of the Project

Hardware

Electrical Setup

For the electrical component setup, we need two particle photons and two small solder-less breadboards. The particle photons can be purchased for $19.00 each from Particle. We also need some jumper wires, two 4-AA battery holders, various resistors, a hall effect sensor, and an OLED Display screen. Refer to the schematics section for a circuit diagram.

Speedometer Photon Circuit Setup Without Battery Pack

Data Acquisition Photon Circuit Setup Without Battery Pack

MountingSetup

For the mounting setup, we used a 3d printer to make the enclosures. The.stl files can be found in the attachments section.

Speedometer Enclosure

Data Acquisition Photon Enclosure

Depending on your bicycle and how you want to mount the enclosures, you may need to edit some of the dimensions. This particular setup used a diameter of 0.5” for the bicycle stem segment.

The Bicycle Stem Neck Used in this Project

Zip ties were used to fasten the mounts onto the bicycle, but more permanent options such as metal ties could also be used.

Putting the Electrical and Mounting Setups Together

Speedometer Photon [Display Module]

Perhaps the most difficult part of this project is fitting the electrical component setup into the enclosures. It is advised to take the side tabs off of the breadboard used in the speedometer for extra space. The breadboard should slide into place and "lock" due to the upward deflection of the plastic.

Breadboard With Side Tabs In Speedometer Enclosure

We also need to run cables out to the display. We used female to female wires attached to male to male wires, since not many female-male wires can actually fit in the enclosure due to height limitations. The female to female wires were bundled like so:

Female-Female Wires Bundle

The Male-Male Wires were then attached and secure:

Female-Female and Male-Male Wire Bundle

If the connections between the two are not very secure, you may want to tape the two bundles together at this intersection. The ones we used snapped into place well, and required minimal taping. Once the cable assembly is put together, feed it through the slot on the front of the speedometer:

Wire Assembly Fed Through Slot

You may want to use a small string to guide it. Also pictured is the battery pack inserted into the bottom compartment. It simply slides into place and is held in place by the door. Now comes the most difficult part, fitting the circuit into the upper compartment. We advise using tape to secure wires down so they don't slip out of the breadboard. Alternatively, you could just solder the wires, but that would be much more time intensive. The very organized circuit insertion:

Speedometer in the Upper Compartment

Again, notice that the breadboard has been reduced in size to accommodate for the wires. One last thing to do is to attach the screen. A small spacer block was printed for adjustable screen height. You can go without this block, but if you want to adjust what angle the screen is at to you on the bicycle, this is one way to do it. The spacer we printed looked like:

Screen Spacer

After either securing the screen using the spacer, or just using the configuration in the original model, the speedometer photon is almost complete. All that is needed is to insert the battery pack into the holder, and switch it on!

Completed Speedometer Mount

Data Acquisition Photon [Hall Effect Sensor Module]

This assembly is much easier than the Speedometer Photon. Once the circuit is assembled, the breadboard can just be slid into place. The only precautions needed is to first attach the LED to the breadboard, feed it through one of the enclosure holes, and secure it to the enclosure with your preferred adhesive. This can be seen in the final build:

Completed Data Acquisition Photon

We have a little bit to go before we have completed this assembly however. Once the circuit is assembled, it is advised to secure the wires to the breadboard using tape. Alternatively, one could use solder for this.

Taping the wires down

Once the wires have been taped down, feed the hall-effect sensor and battery pack wires out of the 2 remaining holes in the enclosure.

Feeding the Wires

The wires should look like the above image. Now, all that's left to do is slide the breadboard in, slide the battery pack in, and slide the door closed. Also, remember to flash the code to the photon. With both Photon circuits assembled and placed in their enclosures, we can then begin mounting them onto the bicycle.

Mounting

SpeedometerPhoton

The only step is to zip tie the enclosure to the bike as pictured:

Completing the Speedometer

Data Acquisition Photon

This Photon is easy to mount, but requires some additional work in regards to the hall effect sensor. First, mount the enclosure onto the bike as pictured:

Data Acquisition Photon Mounting

Once the enclosure is mounted, take the wires and tape them to the frame, bundling them as you go. For superior looks and organization, one could braid the wires as so:

Optimal Cord Braiding Example (Credit: BoatUS)

Run your wires towards the back of the bike. You should end with a hall effect sensor placement looking something like this:

Hall Effect Sensor Placement

Also seen in the photo is the magnet placement. For this project, we attempted to first use traditional bicycle spoke magnets, but found that they were not strong enough to trigger the hall effect sensor. The fix that we came up with was to use stronger, albeit uglier, magnets. The important detail in mounting the magnets is make sure that they are all equal distance from the center of the wheel, and are equally spaced along the turn of the wheel. We chose to use 4 magnets, but the code is designed so that a single variable controlling the number of magnets can be changed to customize the number of magnets used on the bicycle. The accuracy of the speedometer goes up the more magnets are present. However, keep in mind that the Photon can collect data no faster than it's clock speed (120MHz). The finished setup looked something like this:

Hall Effect Sensor Mounting Complete

At this point the entire assembly is finished. The finished product should look something like this:

Finished Assembly

Calculations

In order to estimate the velocity of the bike, a discrete form of the derivative of position with respect to time is required. Velocity is estimated by the change in position divided by the change in time. To find the distance, the number of rotations of the wheel and the distance traveled per rotation of the wheel is used. The Hall Effect Sensor module and magnets mounted on the bike around the wheel are used to determine the number of rotations (number of passes of the magnet by the Hall Effect Sensor divided by the number of magnets) and a tape measure is used to determine the distance traveled for a rotation of the wheel. For every submission of data from the Hall Effect Sensor module to the Display module there is a 3.3 second window of time for which the passes are observed. When the first pass within the 3.3 second window is detected (pass zero), a timer starts and adds up time between passes. The parameters used from the 3.3 second window to determine the average velocity are the number of passes after pass zero and the time between pass zero and the final pass. The velocity is calculated using the parameters listed above through the code here:

calculatedvelocity = ((simplefloat-(1))*(calibration/(magcount*timepass*5280*12/(3600*1000))));
// simplefloat - Number of Passes in 3.3 second window including pass zero
// calibration - Distance traveled per rotation of the wheel in Inches
// magcount    - Number of Magnets on the Wheel
// timepass    - time passed between pass zero and the final pass in milliseconds
// conversions - 12 inches in 1 foot
//               5280 feet in 1 mile
//               3600 seconds in 1 hour
//               1000 seconds in 1 millisecond
    1 Line, 8 Comment Lines

For data submitted to the Thingspeak live charts, raw number of passes and the time window of 16.5 seconds (Thingspeak requires 15 seconds between data submissions) are used to determine the average velocity. The error times are considered insignificant due to the large time window for data submitted to Thingspeak.

Thingspeak Live Charts

Velocity is graphed live using a webhook integration to send particle publish data from the photon to Thingspeak. Using MATLAB, the velocity data is used to chart distance traveled, velocity, acceleration, and idle time. Distance traveled and acceleration are determined via discrete calculations of kinematic equations and using the assumption that unknown constants are zero. Idle time is the time for which the Hall Effect Sensor is turned on but there is no significant movement (speed less than 1 MPH). All of these charts for the device used for this project can be access publicly here: Thingspeak Graphs, Note: Sometimes Thingspeak does not load the MATLAB code correctly and returns an error, refreshing the page is required to fix this. Here is an example of the graphs page with data from testing on 11/09/2018:

Sample of Thingspeak Output Graphs (11/09/2018)

Speedometer Housing

Autodesk Inventor File for the Speedometer Mount. The mount contains a particle photon, battery pack, and OLED display. The neck is adjusted on a per bicycle basis, so the radius may need to be changed for a different bicycle.The model has been parametrically modeled in such a way so that editing the radius drives relations for other parts of the mount while allowing the housing the remain the same size. Depending on the display used, a spacing block may need to be superglued to the mount to allow for adequate wiring. It is advised to bundle extra wires together with zip-ties for space management inside of the housing. Lastly, the mount is secured with zip-ties.

Schematics

Code

Hall Effect Sensor Module Photon Code

C/C++

This is the code used in the Hall Effect Module Photon for determining the speed of the bike based on the data from the hall effect sensor. From this data, the number of passes is determined and is adjusted for the distance traveled per rotation of the bike tires. The velocity data is sent to the Display Module and Thingspeak via Particle.Publish. This code also checks to see if the Display Module is turned on via
Particle.Subscribe and turns on the Led upon detection of the Display Module being online and turns off upon no indicators for 11 seconds.

// -------------------------------------------------------
// Hall Effect Sensor Module Proceedure
// By: William Ladd and Dan Cornett
//
// MEGR3171 Fall 2018 IOT Project
//
//
//
// -------------------------------------------------------

// Declare all Pins
int power = A2;			
int sig = A1;
int ledpower = D2;

// Declare all Integers, Floats, and Character Arrays
int readingvalue;		
int looptime;
int calculation;
int magnettime;
int passsingle;
int passamt;
int passloga;
int passlogb;
int passlogc;
int totaltostart;
int cyc;
int subcyc;
int timesumA;
int timesumB;
int timesumC;
int timecheckA;
int timecheckB;
int timecheckC;
int timepass;
int lightcheck;
int cycpassamt;
float calibration;
int magcount;
int timesincemag;
float simplefloat;
float calculatedvelocity;
char cldsubmit[40];

void setup() {

// Setup Pin Modes
    pinMode(power,OUTPUT);																	
	pinMode(ledpower,OUTPUT);	
    pinMode(sig,INPUT);  

// Turn on power to Hall Effect Sensor 
    digitalWrite(power,HIGH);		
// Turn off power for Led Connection Indicator
	digitalWrite(ledpower,LOW);																
	
// Declare variables for monitoring from particle console
    Particle.variable("reading", &readingvalue, INT);										
    Particle.variable("calculation", &calculation, INT);
    Particle.variable("singlepass", &passsingle, INT);
    Particle.variable("timeinloop", &looptime, INT);
    Particle.variable("passamount", &passamt, INT);
    Particle.variable("magnettime", &magnettime, INT);
    Particle.variable("totaltostart", &totaltostart, INT);
	
// Declare function for ability to turn off and on power to Hall Effect Sensor
    Particle.function("power",powerToggle);												
    
// Setup Hook Response for Thingspeak
    Particle.subscribe("hook-response/MEGR3171wladd3_Cycles", dummyHandler, MY_DEVICES);	
// Subscribe to Status indicator for Display Module
	Particle.subscribe("MEGR3171wladd3_Status", readStatus);								
    
// Setup Default Variable Values
    calculation = 0;																	
    magnettime = 0;
    passamt = 0;
	  subcyc = 0;
	  timesincemag = 0;
	
// Enter the distance traveled per rotation of the wheel in inches into the
// calibration value to calculate bike velocity.
	calibration = 91.000;	
// Enter the number of magnets used on the wheel	
	magcount = 4;
}


void loop() {
  
// Gather output data from Hall Effect Sensor
    readingvalue = analogRead(sig);		
    looptime = (looptime + 1);			
// Add 1 to loop time tracking counter
    
	timesincemag = timesincemag + 2;
	
    if (looptime>=550) {				
// Check if loop time is 550 ((2ms delay per loop -> 1.100s between critical times due to publish limits of photon)
    
		subcyc = subcyc + 1;
		
		if (subcyc==4) {subcyc = 1;} else {}
		
		if (subcyc==1) {timepass = timesumA; timesumA = 0; timecheckA = 0;} else {}
		if (subcyc==2) {timepass = timesumB; timesumB = 0; timecheckB = 0;} else {}
		if (subcyc==3) {timepass = timesumC; timesumC = 0; timecheckC = 0;} else {}
		if (timepass==0) {timepass=100000000;} else {}
		
        cyc = (cyc + 1);				
// Increment the cycle number
        cycpassamt = cycpassamt + passamt;	
// Add together number of passes during this set of 15 cycles
        if (lightcheck<=0) {			
// Check for Disconnect of Display Photon, Turn off Led if Disconnected else Increment down Disconnect Timer
			digitalWrite(ledpower,LOW);
		} 
		else {
			lightcheck = (lightcheck - 1);
		}
        
        
        if (cyc>=15) {					
// Check which number cycle this is, every 15 cycles, on cycle number 15,
// publish to Thingspeak, else publish to Display
        
			looptime = 0;
			passlogc = passlogb;						
			passlogb = passloga;						
			passloga = passamt;							
// Memorize Passes Amount of Last 2 Periods of 1.1 Seconds Each
// Overwrite each previous one with each newer one
			simplefloat = cycpassamt;					
// Retrieve Data of last 16.5 seconds and convert to Float type for calculations
			calculatedvelocity = (simplefloat*(calibration/(magcount*16.5*5280*12/3600)));	
// Calculate the average velocity in MPH over the past 16.5 seconds with 
// 2 magnets per rotation for submission to Thingspeak
        
			Serial.begin();
			Particle.publish("MEGR3171wladd3_Cycles",String(calculatedvelocity, 2),0,PUBLIC);	
// Submit data to Thingspeak

// Reset cycle number and tracking variables         
			cycpassamt = 0;		
			cyc = 0;
			if (calculation>=1) {
				passsingle = 1;
			} 
			else {
				passsingle = 0;
			}
			calculation = 0;
			magnettime = 0;
			passamt = 0;
        
        }
        else {
        
			looptime = 0;
			passlogc = passlogb;						
// Memorize Passes Amount of Last 2 Periods of 1.1 Seconds Each
			passlogb = passloga;						
// Overwrite each previous one with each newer one
			passloga = passamt;							
			passamt = passlogc + passlogb + passloga;	
// Sum together Data for Last 3 Cycles over 3.3 Seconds
		
			simplefloat = passamt;						
// Retrieve Data of last 3.3 Seconds and convert to Float type for calculations
// Calculate based on time between passes the speed.
            if (simplefloat==0) {calculatedvelocity=0;} else {
			calculatedvelocity = ((simplefloat-(1))*(calibration/(magcount*timepass*5280*12/(3600*1000))));	}
// Calculate the average velocity in MPH over the past 3.3 seconds with 
// 2 magnets per rotation for submission to Display
        
			if (calculatedvelocity>=10) {				
// Format velocity value for display, if less than 10, move over by 1 space to
// keep decimal in locked position
				Serial.begin();
				Particle.publish("MEGR3171wladd3_Display",String(calculatedvelocity, 2),0,PUBLIC); 	
// Submit data to Display
			}
			else {
				Serial.begin();
				Particle.publish("MEGR3171wladd3_Display",String(" " + String(calculatedvelocity, 2)),0,PUBLIC);	
// Submit formatted data to Display
			}
			
			if (calculation>=1) {	
// Reset tracking variables
				passsingle = 1;
			} 
			else {
				passsingle = 0;
			}
			calculation = 0;
			magnettime = 0;
			passamt = 0;
        
        }
		
    } 
	
    else {
	
    }
    
	
    if (readingvalue<=200) { 			
// Check for a Passing Spoke then Check if Spoke was detected in previous Cycle.
		magnettime = (magnettime + 1); 
		calculation = (calculation + 1); 
        if (calculation==1) {
			passamt = (passamt + 1); 
			totaltostart = (totaltostart + 1);

			if (timecheckA==1) {timesumA = timesumA + timesincemag;} else {}
			if (timecheckB==1) {timesumB = timesumB + timesincemag;} else {}
			if (timecheckC==1) {timesumC = timesumC + timesincemag;} else {}

			timecheckA = 1;
			timecheckB = 1;
			timecheckC = 1;


			timesincemag = 0;}
        else {
		}
    } 
    else { 
        calculation = 0;
    }
		
    delay(1);		
// End of Loop Delay to set time per loop (1ms default + 1ms delay)
}


int powerToggle(String command) {	
// Function to turn off and on Hall Effect Sensor from Console, input "on" to turn on or "off" to turn off

    if (command=="on") {
        digitalWrite(power,HIGH);
        return 1;
    }
    else if (command=="off") {
        digitalWrite(power,LOW);
        return 0;
    }
    else {
        return -1;
    }
}


void readStatus(const char *event, const char *data)	
// Check for Display photon online status, turn on Led if yes and reset time on offline check timer
{
	digitalWrite(ledpower,HIGH);
	lightcheck = 10;
}


void dummyHandler(const char *event, const char *data)	
// Dummy Handler for Hook Response for Thingspeak
{
}

// -------------------------------------------------------
// Display Module Proceedure
// By: William Ladd and Dan Cornett
//
// MEGR3171 Fall 2018 IOT Project
//
//
//
// -------------------------------------------------------

// This #include statement was automatically added by the Particle IDE.
#include <Adafruit_SSD1306.h>								
// Include Statement to Integrate Code required for Adafruit Display 
// Include this code in the library for display to work

// Adjustments required for Adafruit Display
#define OLED_DC     D3                                      
#define OLED_CS     D4                                      
#define OLED_RESET  D5                                      
Adafruit_SSD1306 display(OLED_DC, OLED_RESET, OLED_CS);     
// End of Adjustments required for Adafruit Display

void setup() {

// Subscribe to Hall Effect Module Output to take output and display on display
  Particle.subscribe("MEGR3171wladd3_Display", readCycle);	
	
// Declare Use of Screen
  display.begin(SSD1306_SWITCHCAPVCC);      
	
// Setup Screen Options
  display.setTextSize(2);            // Set Text Display Size to 2
  display.setTextColor(WHITE);      // Set Colour of Display to White (Displays as Blue)
  display.setTextWrap(false);       // Disable Text Wrapping for Text Falling off Display

delay(50);
      display.clearDisplay();       // Clear the screen
      display.setCursor(0, 0);      // Set position on screen for display of text
      display.println("ME3171 F18");// Display Author In formation on Startup
      display.println("-=IOT 32=-");//
      display.println("W. Ladd");   //
      display.println("D. Cornett");//
      display.display();            // Update Display
delay(6000);
      display.setTextSize(4);       // Set Text Display Size to 4
      display.clearDisplay();       // Clear the screen
      display.setCursor(0, 0);      // Set position on screen for display of text
      display.println("-----");     // Print pending data line
      display.print(" MPH");        // Print Units
      display.display();            // Update Display
}

void loop()  {



}
	  
// Upon reception of new data, display new data
void readCycle(const char *event, const char *data)  
{
     
      display.clearDisplay(); // Clear the screen
      display.setCursor(0, 0);// Set position on screen for display of text
      display.println(data);  // Print the data from Hall Effect Module Photon
      display.print(" MPH");  // Print Units
      display.display();      // Update Display
      
      // Send response to Hall Effect Module Photon
      Particle.publish("MEGR3171wladd3_Status", "Online");	

}

% Used The Following Template:
% Template MATLAB code for visualizing data from a channel as a 2D line
% plot using PLOT function.

readChannelID = 607694;
fieldID1 = 1;
readAPIKey = "1J5FYDH61C7GGKLG";

[data, time] = thingSpeakRead(readChannelID, 'Field', fieldID1, 'NumPoints', 100, 'ReadKey', readAPIKey);

n=1;
q=1;
k=0;
datab = data;

% Add Velocity Distance from Current Interval to Previous Intervals
for n = 1:100           
    for q = 1:n
        k=k+data(q,1);
    end 
    datab(n,1) = k;
k=0;

end

% Determine the Distance Traveled from the Equation
% s = v*t [Time Period of 16.5 Seconds per Velocity Data Point]
% [Devide time by 3600 to convert Seconds to Hours]
datab = datab*(16.5/3600);      

% Plot Data
plot(time, datab);       
title('Distance Traveled')
xlabel('Time')
ylabel('Distance (Miles)')

% Used The Following Template:
% Template MATLAB code for visualizing data from a channel as a 2D line
% plot using PLOT function.

readChannelID = 607694;
fieldID1 = 1;
readAPIKey = "1J5FYDH61C7GGKLG";

[data, time] = thingSpeakRead(readChannelID, 'Field', fieldID1, 'NumPoints', 100, 'ReadKey', readAPIKey);

% Plot Data
plot(time, data);        
title('Velocity')
xlabel('Time')
ylabel('Velocity (MPH)')

% Used The Following Template:
% Template MATLAB code for visualizing data from a channel as a 2D line
% plot using PLOT function.

readChannelID = 607694;
fieldID1 = 1;
readAPIKey = "1J5FYDH61C7GGKLG";

[data, time] = thingSpeakRead(readChannelID, 'Field', fieldID1, 'NumPoints', 100, 'ReadKey', readAPIKey);

n=1;
q=1;
k=0;
datab = data;

% Add Velocity Distance from Current Interval to Previous Intervals
% Apply the descrete version of the equation a = dv/dt
    datab(n,1) = (data(n+1,1)-data(n,1))/16.5;
for n = 1:99           
    
k=0;

end

data(100,1) = 0;

% Plot Data
plot(time, datab);     
title('Acceleration')
xlabel('Time')
ylabel('Acceleration (MPH per Second)')

% Used The Following Template:
% Template MATLAB code for visualizing data from a channel as a 2D line
% plot using PLOT function.

readChannelID = 607694;
fieldID1 = 1;
readAPIKey = "1J5FYDH61C7GGKLG";

[data, time] = thingSpeakRead(readChannelID, 'Field', fieldID1, 'NumPoints', 100, 'ReadKey', readAPIKey);

n = 2;
% Write to DataB for Checking with Both and Overwriting on DataB
datab = data;         
% Zero Out First Time to Set unknown to Assumed Zero
datab(1,1) = 0;       

% Check for Velcoity greater than 1, if velocity less than or equal 1,
% zero out the idle time else, add to previous idle time.
for n = 2:100         
    if data(n,1) <= 1;
    datab(n,1) = datab(n-1,1) + 1;
    else
    datab(n,1) = 0;
    end
end

% Adjust for Time Period Between Data Poins
datab = datab*16.5;    

% Plot Data
plot(time, datab);    
title('Idle Time')
xlabel('Time')
ylabel('Idle Time (Seconds)')

Credits

Daniel Cornett

1 project • 0 followers

William Ladd

1 project • 0 followers

Bicycle Movement Tracking Using Particle Photon

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Overview

Hardware

Calculations

Thingspeak Live Charts

Custom parts and enclosures

Speedometer Housing

Data Acquisition Photon Housing

Schematics

Hall Effect Sensor Module [Breadboard View]

Display Module [Breadboard View]

Hall Effect Sensor Module [Circuit Diagram]

Display Module [Circuit Diagram]

Code

Hall Effect Sensor Module Photon Code

Display Module Photon Code

Graphing [Distance Traveled]

Graphing [Velocity]

Graphing [Acceleration]

Graphing [Idle Time]

Credits

Daniel Cornett

William Ladd

Comments

Embed the widget on your own site

Bicycle Movement Tracking Using Particle Photon

Bicycle Movement Tracking Using Particle Photon

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Overview

Hardware

Calculations

Thingspeak Live Charts

Custom parts and enclosures

Speedometer Housing

Data Acquisition Photon Housing

Schematics

Hall Effect Sensor Module [Breadboard View]

Display Module [Breadboard View]

Hall Effect Sensor Module [Circuit Diagram]

Display Module [Circuit Diagram]

Code

Hall Effect Sensor Module Photon Code

Display Module Photon Code

Graphing [Distance Traveled]

Graphing [Velocity]

Graphing [Acceleration]

Graphing [Idle Time]

Credits

Daniel Cornett

William Ladd

Comments

Related channels and tags