Introduction
The Idea
The Design of the Jump Rope
Programming the 3D Sensor
The Android Application
Programming the Bluetooth LE
Construction
Result
The Schematics

Published August 25, 2018 © MIT

Skiptti

A smart jump rope that counts the number of jumps (skips) and syncs the count to your phone (Android).

IntermediateFull instructions provided2 days935

IoT

Sensing the World in All Three Dimensions

Things used in this project

Hardware components

Infineon 3D Magnetic Sensor 2Go

Nordic Semiconductor nRF51822 Bluetooth Smart Beacon Kit

Nordic Semiconductor nRF51 DK

Capacitor 100 µF

Linear Regulator (Low Dropout)

Resistor 10k ohm

Jumper wires (generic)

Plastic Jump rope

Software apps and online services

Microsoft Windows 10

Arduino IDE

Arm Mbed OS

Infineon Evaluation Kit for 3D sensor

Hand tools and fabrication machines

Soldering iron (generic)

Hot glue gun (generic)

Story

Introduction

As engaging in daily workout is good for our everyday fitness and wellness, so as its also worth being fun for us as well. that's one of my reasons for creating this project, Where you have to workout and at the same time have fun doing so. This project describes a simple design of a workout gear a "jump rope" which gives you a workout experience that has the potentials of helping you track your average calories burnt in a skip session and also have an opportunity to share your experience on a social media and even compete with your friends using the same jump rope. The jump rope simply counts the number of cycles and synchronizes the count to your Android mobile phone using Bluetooth Low energy (BLE 4.0) and calories burnt based on the count would be calculated and displayed on your Android phone. The diagram below explains the flow of operation of the project.

Skiptti flow of operation

The Idea

The first part of actualizing this project is building the BLE enabled jump rope what I call Skiptti. The simple idea is to have a sensor that can measure a complete cycle, and use each complete cycle to trigger a counter and have our BLE to transfer counts via Universal Asynchronous Receiver Transmitter (UART) Bluetooth Service to the android mobile phone already paired and connected to it.

Yes the idea is simple but it was also a difficult task to find what best could be used to sense a complete cycle to trigger a counter. So I tried rotary encoders "yes beautiful" rotary encoders like the ones in the diagram below looked like the best fit for this with the following advantages.

<Image title: encoders>

The rotary encoder has a quadrature output which can be used to check for direction of rotation

It has push button while it can rotate.

And I guess more advantages I'm currently not aware of.

Despite the beautiful advantages I mentioned above, I discovered it might not just be the best. Why?, For a solution like this, it means the encoder would be subjected to a serious and fast mechanical movement (rotation) as the skipping goes on which would generate heat and also reduces the life span of the encoder due to mechanical wear and tear especially if this is to be served to the consumer market. So what was an alternative? I looked forward to something that could be more efficient and I discovered the Infineon 3D magnetic sensor, which has the ability to detect movement of magnetic field from a magnet. The sensor has the ability to output magnetic field in 3 dimension and hence can use this data for detecting magnetic field from a magnet moving in a linear and rotational motion and also for joystick kind of movement. Though it was difficult to understand how it works at first until I ordered for an evaluation board which has on onboard 3D magnetic sensor (TLE493D-A2B6) called The 3D Magnetic Sensor 2GO. Now with this sensor used for the jump rope design it has helped in:

Eliminated the issue with heat generation and the wear and tear.

Also detects backward or forward rotation of the jump rope's shaft

Compact and simple to install

below is the arrangement of the Sensor 2GO and the magnet that came with it stuck on the rotating part of the jump rope

The Design of the Jump Rope

Having gotten the clear understanding of the requirement, the following components were used in realizing the design.

The Infineon 3D magnetic 2GO evaluation board

A Bluetooth Low Energy module Core51822

Like I said the critical part of the project was detecting a complete cycle from a rotating shaft, and the 3D magnetic sensor came to the rescue.

Detecting Rotation with the Magnetic Sensor

The evaluation board came with a software tool (Windows OS only) that helped in developing the code in detecting the rotation of magnets on a particular axis of rotation. I Installed the software and all I needed to do was just connect the evaluation board to the USB port selected the type of configuration and clicked start and voila! data everywhere!. The software implemented motion type visualizations such as joystick, graph, linear and rotation. Of these visualizations I found the graph most useful for me at least for the purpose of this project. The Image below shows how I got data to develop a naive rotation detection I finally used to program the evaluation board.

1 / 2

Using the above grave view and data I was able to coin a simple and naive way of detecting rotation. I simply rotated the magnet that came with the sensor 360 degrees. For each step of 90 degree of rotation, I observed the following as shown in the table below.

Observation of rotating a cuboid magnet about y axis of the 3D sensor

Note each coordinates are approximations, that means actual values were like 30 45, and 40. In order to reduce the complexity implementing the detection I further normalized the data to just represent Positive, Negative and zero. values that are between a particular range of positive to the negative are regarded as zero. while values greater than a chosen positive number is regarded as positive one and the one less than another number is considered as negative. In other words the code implementation as shown in the code section implemented 5 as the threshold number. any value greater than 5 is positive. Values between -5 and 5 are zero and values below -5 are regarded as negative. Hence the above table is re-written having the 50s replaced with + or -1.

Programming the 3D Sensor

The magnetic Sensor was programmed to implement rotation detection using the data in the table from the previous section.

The 3D sensor evaluation board is Arduino compatible. To program the board with the Arduino IDE minimum of version 1.6 is required. To program the board this link provides a full detail of how to install the evaluation board on Arduino IDE and also the library

The Android Application

Creating an android application is an essential part of the project. The application scans for nearby Bluetooth devices and displayed them as a list. users can easily select the device that they wish to connect to. But not just any device. The app's logic only responds to Skiptti devices. the source code is available here. Here are some snapshots from the app

1 / 5

Programming the Bluetooth LE

The Core51822 was programmed using nRF-DK 51 development board. The Mbed OS and its online compiler was used to write the code. The code is simply straight forward as it can be found in the code section below. To use the Mbed compiler simply signup as a developer create a project and use the code here in and paste in main.c and that's it choose your board and follow every other instruction to generate the hex file to program the BLE module. If you have NRF-51Dk here a connection you would use to program the core51822 BLE module.

Board connection for programming

Note any other programmer or can still be used for programming the module. for more info on how to program check here

The Mbed Interface Looks Like This:

Arm mbed interface

Construction

In Constructing the jump rope, I planned to use my 3D printer to print a design I had, but I was still trying to get a hang of how to use the printer so I decided to get a plastic non-smart skipping rope and I did a tear down on it and rebuilt it, now with the 3D sensor.

1 / 4

Result

Here is a video demonstration of me using the jump rope.

Also, here are images of it!

complete work

The Schematics

#include <Tle493d_w2b6.h>
Tle493d_w2b6 magSensor = Tle493d_w2b6();


int NEGATIVE = -1, ZERO = 0, POSITIVE = 1;
int ANGLE = 0;
int UNDEFINED = -500;
int PREVIOUS_ANGLE = 0;
int CURRENT_ANGLE = 0;
int FORWARD_DIRECTION  = 10;
int BACKWARD_DIRECTION = 11;
int DIRECTION = 0;
int CURRENT_DIRECTION = 0;
int STEP = -1;
int OUTPUT2 = 4;

int ACCUMULATOR = 0;

void setup() {
 // more setup
 Serial.begin(9600);
 magSensor.begin();
 magSensor.enableTemp();
 pinMode(LED_BUILTIN, OUTPUT);
 pinMode(OUTPUT2, OUTPUT);
 delay(3000);
 digitalWrite(LED_BUILTIN, HIGH);
 digitalWrite(OUTPUT2, HIGH);
}
void loop() {

  magSensor.updateData();               // read sensor info

  int xValue = (int)magSensor.getX();
  int yValue = (int)magSensor.getY();
  int zValue = (int)magSensor.getZ();

  int normalX = normalize(xValue);
  int normalY = normalize(yValue);
  int normalZ = normalize(zValue);

  ANGLE = getAngle(normalX, normalY, normalZ);
  Serial.print("Angle: ");
  Serial.println(ANGLE);
  isCompleteRotation();
  delay(50);
}

/** normalizes values above a threshold
 value from any axis greter than 5 is taken as positive
 values from any less than -5 is taken as negative
 values from any 3 axis greater than -5 and lesser than 5 is taken as zero*/

int normalize(int value){
    if(value < 0 && value < -5){
      return NEGATIVE;
    }else if((value < 0 && value > -5)||(value > 0 && value < 5)){
      return ZERO;
    }else if(value > 0 && value > 5){
      return POSITIVE;
    }
    return ZERO;
}


/* gets a resultant value representing the current orientation of the magnet in front of the sensor*/

int getAngle(int xNormal, int yNormal, int zNormal){
  if(xNormal == NEGATIVE && yNormal == ZERO && zNormal == NEGATIVE){
    CURRENT_ANGLE = 0;
  }

  if(xNormal == ZERO && yNormal == NEGATIVE && zNormal == ZERO){
    CURRENT_ANGLE = 90;
  }

  if(xNormal == POSITIVE && yNormal == ZERO && zNormal == POSITIVE){
    CURRENT_ANGLE = 180;
  }

  if(xNormal == ZERO && yNormal == POSITIVE && zNormal == ZERO){
    CURRENT_ANGLE  = 270;
  }
  
  return CURRENT_ANGLE;
}

/* Tracks rotation states to determine backward and forward rotation. and finally
 fires a signal of a complete cycle if the direction never changed for all 4 states of rotation i.e 0, 90, 180 and 270*/

void isCompleteRotation(){    
    if(CURRENT_ANGLE != PREVIOUS_ANGLE){

      switch(CURRENT_ANGLE){
        case 0:{
            if(PREVIOUS_ANGLE == 270){
               DIRECTION = FORWARD_DIRECTION;
            }
            if(PREVIOUS_ANGLE == 90){
               DIRECTION = BACKWARD_DIRECTION;
            }
            break;
        }

        case 90:{
            if(PREVIOUS_ANGLE == 0){
               DIRECTION = FORWARD_DIRECTION;
            }
            if(PREVIOUS_ANGLE == 180){
               DIRECTION = BACKWARD_DIRECTION;
            }
            break;
        }

        case 180:{
            if(PREVIOUS_ANGLE == 90){
               DIRECTION = FORWARD_DIRECTION;
            }
            if(PREVIOUS_ANGLE == 270){
               DIRECTION = BACKWARD_DIRECTION;
            }
            break;
        }

        case 270:{
            if(PREVIOUS_ANGLE == 180){
               DIRECTION = FORWARD_DIRECTION;
            }
            if(PREVIOUS_ANGLE == 0){
               DIRECTION = BACKWARD_DIRECTION;
            }
            break;
        }
      }

      if(CURRENT_DIRECTION == DIRECTION){
          STEP++;
      }else{
          STEP = 0;
      }
      
      Serial.println(DIRECTION == FORWARD_DIRECTION? "FORWARD==" : "==BACKWARD");
      CURRENT_DIRECTION = DIRECTION;
      PREVIOUS_ANGLE = CURRENT_ANGLE;
      if(STEP >= 4){
        STEP = 0;
        digitalWrite(LED_BUILTIN, HIGH);
        digitalWrite(OUTPUT2, HIGH);
      }else{
        digitalWrite(LED_BUILTIN, LOW);
        digitalWrite(OUTPUT2, LOW);
      }
      Serial.print("STEPS: ");
      Serial.println(STEP);
    }
}

/* mbed Microcontroller Library
 * Copyright (c) 2006-2013 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "mbed.h"
#include "ble/BLE.h"
#include "ble/services/UARTService.h"
#include "DeviceInformationService.h"


const static char     DEVICE_NAME[]        = "Skiptti3";
uint8_t            READING []          = "Skipptii counts";
uint8_t * dataPointer;
char buffer [50];

//static const uint16_t uuid16_list[]        = {GattService::UUID_HEART_RATE_SERVICE,GattService::UUID_DEVICE_INFORMATION_SERVICE};

BLEDevice  ble;
DigitalOut led1(LED1);
//DigitalOut led1(P0_14);

InterruptIn counterSource(P0_17);

UARTService *uartServicePtr;
bool isConnected = false;
uint16_t period = 0, clockCounter = 0, skipCounts = 0;
uint8_t rpm = 0;
uint16_t size;

enum {
    RELEASED = 0,
    PRESSED,
    IDLE
};
static uint8_t buttonState = IDLE;

void buttonPressedCallback(void)
{
    /* Note that the buttonPressedCallback() executes in interrupt context, so it is safer to access
     * BLE device API from the main thread. */
    buttonState = PRESSED;
}

void buttonReleasedCallback(void)
{
    /* Note that the buttonReleasedCallback() executes in interrupt context, so it is safer to access
     * BLE device API from the main thread. */
    if(buttonState == PRESSED){
        period = clockCounter;
        clockCounter = 0;
        buttonState = RELEASED;
        if(period > 50){
            skipCounts = 0;    //please start again you rested and that shows the end of skip session
        }
        skipCounts++;
        if(ble.gap().getState().connected){
            printf("data received %u bytes\n\r", skipCounts);
            int n = sprintf(buffer, "period %u skip %u\n\r", period, skipCounts);
            ble.updateCharacteristicValue(uartServicePtr->getRXCharacteristicHandle(), (uint8_t*)buffer, n);
        }
    }
    
}

void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
{
    printf("Disconnected!\r\n");
    isConnected = false;
    ble.startAdvertising();
}

void connectionCallback(const Gap::ConnectionCallbackParams_t *params)
{
    printf("Connected!\r\n");
    isConnected = true;
}

void passkeyDisplayCallback(Gap::Handle_t handle, const SecurityManager::Passkey_t passkey)
{
    printf("Input passKey: ");
    for (unsigned i = 0; i < Gap::ADDR_LEN; i++) {
        printf("%c ", passkey[i]);
    }
    printf("\r\n");
}

void securitySetupCompletedCallback(Gap::Handle_t handle, SecurityManager::SecurityCompletionStatus_t status)
{
    if (status == SecurityManager::SEC_STATUS_SUCCESS) {
        printf("Security success\r\n");
    } else {
        printf("Security failed\r\n");
    }
}

void onDataWritten(const GattWriteCallbackParams *params)
{
    if ((uartServicePtr != NULL) && (params->handle == uartServicePtr->getTXCharacteristicHandle())) {
        uint16_t bytesRead = params->len;
        printf("received %u bytes\n\r", bytesRead);
        printf("data received %s bytes\n\r", params->data);
        ble.updateCharacteristicValue(uartServicePtr->getRXCharacteristicHandle(), params->data, bytesRead);
    }
}

void periodicCallback(void)
{
    led1 = !led1;
    clockCounter++;
}

int main(void)
{
    led1 = 1;
    Ticker ticker;
    ticker.attach(periodicCallback, 0.1);

    printf("Initialising the nRF51822\n\r");
    ble.init();
    
    /* Initialize BLE security */
    bool enableBonding = true;
    bool requireMITM   = true;
    ble.securityManager().init(enableBonding, requireMITM, SecurityManager::IO_CAPS_DISPLAY_ONLY);
    
    /* Set callback functions */
    ble.gap().onConnection(connectionCallback);
    ble.onDisconnection(disconnectionCallback);
    ble.onDataWritten(onDataWritten);
    ble.securityManager().onPasskeyDisplay(passkeyDisplayCallback);
    ble.securityManager().onSecuritySetupCompleted(securitySetupCompletedCallback);

    /* setup advertising */
    ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED);
    ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME,(const uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME) - 1);
    ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,(const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));

    ble.setAdvertisingInterval(1000); /* 1000ms; in multiples of 0.625ms. */
    ble.startAdvertising();

    UARTService uartService(ble);
    uartServicePtr = &uartService;
    
    counterSource.fall(buttonPressedCallback);
    counterSource.rise(buttonReleasedCallback);

    while (true) {
        ble.waitForEvent();
    }
}

Credits

Emmanuel Edwards

4 projects • 10 followers

A Java based application developer. I do more of android application development and embedded system designs with C/C++,

Comments

Awards

IoT

Sensing the World in All Three Dimensions

Skiptti