Super Diet Racing Game Bike

This is a bicycle racing game machine using Hall sensor and Unity3D racing game kit. It's very useful to use on diet.

May 10, 2019

•

5658 views

•

6 respects

entertainment system

health

games

Components and supplies

Neodymium

HM-10 Bluetooth module

Hall sensor

Arduino Leonardo

Wire, Wrapping Wire

Solderless Breadboard Half Size

Switch Actuator, Head for spring return push-button

Resistor 10k ohm

Development Kit Accessory, Jumper Wire Kit

Tools and machines

Solder Wire, Lead Free

Soldering iron (generic)

Apps and platforms

Arduino IDE

Unity

Project description

Code

Bike racing board source

c_cpp

1 /*
2  Bike racing board for Bluetooth 
3  
4  created 2 May 2019
5  modified 10 May 2019
6  by Steve Kim
7  This example code is in the public  domain.
8 
9*/
10#include <SoftwareSerial.h>
11
12//#define DEBUG 1
13
14//Bluetooth  send constants
15#define ACCEL         "w"
16#define STEER_LEFT    "a"
17#define  STEER_RIGHT   "d"
18#define NITRO         "n"
19#define PAUSE         "q"
20#define  ENTER         "e"
21
22#define RPM_LIMIT_COUNT 50
23
24SoftwareSerial hm10(8,9);  //RX, TX connection 
25
26// set pin numbers for the five buttons:
27const int  upButton = 12;//bicycle hall sensor
28const int downButton = 11;//not used
29const  int leftButton = 4;
30const int rightButton = 5;
31const int enterButton = 2;
32const  int escButton = 3;
33const int ledPin = 13;
34
35
36//Speed variable
37int  rotate_count_thresh = 2;//Hall sensor sensitivity
38bool hall_sensor_contacted  = false;
39int  rotate_count = 0;
40
41//Duration measurement variables
42float  start_time;
43float end_time;
44float on_time;
45float off_time;
46float passed_time;
47
48//Button  State
49bool leftButtonState = false;
50bool rightButtonState = false;
51bool  enterButtonState = false;
52bool escButtonState = false;
53bool boostKeyState  = false;
54
55void debug_serial_print(const char *str)
56{
57  #ifdef DEBUG
58    Serial.print(str);
59  #endif
60}
61
62void debug_serial_println(const char  *str)
63{
64  #ifdef DEBUG
65    Serial.println(str);;
66  #endif
67}
68
69void  setup() { // initialize the buttons' inputs:
70  pinMode(upButton, INPUT);
71  pinMode(downButton, INPUT);
72  pinMode(leftButton, INPUT);
73  pinMode(rightButton,  INPUT);
74  pinMode(enterButton, INPUT);
75  pinMode(escButton, INPUT);
76  pinMode(ledPin,OUTPUT);
77
78  Serial.begin(115200);
79  hm10.begin(9600);
80}
81
82void loop() { 
83
84  rotate_count = 0;
85  hall_sensor_contacted = false;
86
87  start_time = micros();  
88  on_time = micros();
89
90  while(true){
91    //Button input processing
92    ///////////// Left Button //////////////////////////////////////////////////////
93    if(digitalRead(leftButton) == HIGH && leftButtonState == false){//left button  on
94      if(digitalRead(rightButton) == LOW && rightButtonState == false){//left  only on
95        //Keyboard.press(key_left);
96        hm10.write(STEER_LEFT);
97        
98        debug_serial_println("key_left pressed."); 
99        leftButtonState  = true;
100      }      
101    }else if(digitalRead(leftButton) == LOW && leftButtonState  == true){//left button off
102      //Keyboard.release(key_left);
103      debug_serial_println("key_left  released.");    
104      leftButtonState = false;
105      boostKeyState = false;
106    }
107
108    ///////////// Right Button //////////////////////////////////////////////////////
109    if(digitalRead(rightButton) == HIGH && rightButtonState == false){//right button  on
110      if(digitalRead(leftButton) == LOW && leftButtonState == false){//right  only on
111        //Keyboard.press(key_right);
112        hm10.write(STEER_RIGHT);
113        
114        debug_serial_println("key_right pressed.");
115        rightButtonState  = true;
116      }      
117    }else if(digitalRead(rightButton) == LOW && rightButtonState  == true){//right button off
118      //Keyboard.release(key_right);
119      debug_serial_println("key_right  released.");
120      rightButtonState = false;
121      boostKeyState = false;
122    }
123
124    ///////////// Left & Right On together => Boost /////////////////////////////////////
125    if(digitalRead(leftButton) == HIGH  && digitalRead(rightButton) == HIGH && boostKeyState  == false){     
126          //Keyboard.press(key_boost);
127          hm10.write(NITRO);
128          
129          debug_serial_println("key_boost pressed."); 
130          leftButtonState  = true;
131          rightButtonState = true;
132          boostKeyState = true;         
133    }
134
135    ///////////// Enter Button //////////////////////////////////////////////////////
136    if(digitalRead(enterButton) == HIGH && enterButtonState == false){//enter button  on
137      //Keyboard.press(key_enter);
138      hm10.write(ENTER);
139      
140      debug_serial_println("key_enter pressed.");
141      enterButtonState =  true;
142    }else if(digitalRead(enterButton) == LOW && enterButtonState == true){//enter  button off
143      //Keyboard.release(key_enter);
144      debug_serial_println("key_enter  released.");
145      enterButtonState = false;
146    }
147
148    /////////////  Esc Button //////////////////////////////////////////////////////
149    if(digitalRead(escButton)  == HIGH && escButtonState == false){//esc button on
150      //Keyboard.press(key_esc);
151      hm10.write(PAUSE);
152      
153      debug_serial_println("key_esc pressed.");
154      escButtonState = true;
155    }else if(digitalRead(escButton) == LOW && escButtonState  == true){//esc button off
156      //Keyboard.release(key_esc);
157      debug_serial_println("key_esc  released.");
158      escButtonState = false;
159    }
160  
161   /////////////  Bicycle Sensor Input //////////////////////////////////////////////////////
162   if(digitalRead(upButton) == LOW) {//sensor on
163        if(hall_sensor_contacted  == false){
164          debug_serial_println("hall_sensor_contacted 1");
165          hall_sensor_contacted  = true;
166          rotate_count += 1;
167          on_time = micros();
168        }
169    }else{
170        hall_sensor_contacted = false;
171        off_time = micros();
172        passed_time = (off_time - on_time) / 1000000.0;
173      
174      if(passed_time  >= 1){//when rotation stopped
175        //debug_serial_println("break 1");
176        break;
177      }
178    }
179
180    if(rotate_count >= rotate_count_thresh){  
181      //debug_serial_println("break 2");
182      break;    
183    }
184  }
185  
186  end_time = micros();
187  passed_time = (end_time - start_time) /  1000000.0;
188  float rpm_val = (rotate_count/passed_time)*60.0;
189
190//  Serial.print("Time  Passed: ");
191//  Serial.print(passed_time);
192//  debug_serial_println("s");
193//  Serial.print(rpm_val);
194//  debug_serial_println(" RPM");
195  
196  delay(1);        // delay in between reads for stability
197
198  if(rpm_val >= RPM_LIMIT_COUNT){
199    //Keyboard.press(key_up);
200    hm10.write(ACCEL);
201    debug_serial_println("key_up  press");
202  }else{
203    //Keyboard.releaseAll();   
204    //debug_serial_println("key  release All");
205  }  
206}

 /*
  Bike racing board for Bluetooth 
  
  created 2 May 2019
  modified 10 May 2019
  by Steve Kim
  This example code is in the public  domain.
 
*/
#include <SoftwareSerial.h>

//#define DEBUG 1

//Bluetooth  send constants
#define ACCEL         "w"
#define STEER_LEFT    "a"
#define  STEER_RIGHT   "d"
#define NITRO         "n"
#define PAUSE         "q"
#define  ENTER         "e"

#define RPM_LIMIT_COUNT 50

SoftwareSerial hm10(8,9);  //RX, TX connection 

// set pin numbers for the five buttons:
const int  upButton = 12;//bicycle hall sensor
const int downButton = 11;//not used
const  int leftButton = 4;
const int rightButton = 5;
const int enterButton = 2;
const  int escButton = 3;
const int ledPin = 13;


//Speed variable
int  rotate_count_thresh = 2;//Hall sensor sensitivity
bool hall_sensor_contacted  = false;
int  rotate_count = 0;

//Duration measurement variables
float  start_time;
float end_time;
float on_time;
float off_time;
float passed_time;

//Button  State
bool leftButtonState = false;
bool rightButtonState = false;
bool  enterButtonState = false;
bool escButtonState = false;
bool boostKeyState  = false;

void debug_serial_print(const char *str)
{
  #ifdef DEBUG
    Serial.print(str);
  #endif
}

void debug_serial_println(const char  *str)
{
  #ifdef DEBUG
    Serial.println(str);;
  #endif
}

void  setup() { // initialize the buttons' inputs:
  pinMode(upButton, INPUT);
  pinMode(downButton, INPUT);
  pinMode(leftButton, INPUT);
  pinMode(rightButton,  INPUT);
  pinMode(enterButton, INPUT);
  pinMode(escButton, INPUT);
  pinMode(ledPin,OUTPUT);

  Serial.begin(115200);
  hm10.begin(9600);
}

void loop() { 

  rotate_count = 0;
  hall_sensor_contacted = false;

  start_time = micros();  
  on_time = micros();

  while(true){
    //Button input processing
    ///////////// Left Button //////////////////////////////////////////////////////
    if(digitalRead(leftButton) == HIGH && leftButtonState == false){//left button  on
      if(digitalRead(rightButton) == LOW && rightButtonState == false){//left  only on
        //Keyboard.press(key_left);
        hm10.write(STEER_LEFT);
        
        debug_serial_println("key_left pressed."); 
        leftButtonState  = true;
      }      
    }else if(digitalRead(leftButton) == LOW && leftButtonState  == true){//left button off
      //Keyboard.release(key_left);
      debug_serial_println("key_left  released.");    
      leftButtonState = false;
      boostKeyState = false;
    }

    ///////////// Right Button //////////////////////////////////////////////////////
    if(digitalRead(rightButton) == HIGH && rightButtonState == false){//right button  on
      if(digitalRead(leftButton) == LOW && leftButtonState == false){//right  only on
        //Keyboard.press(key_right);
        hm10.write(STEER_RIGHT);
        
        debug_serial_println("key_right pressed.");
        rightButtonState  = true;
      }      
    }else if(digitalRead(rightButton) == LOW && rightButtonState  == true){//right button off
      //Keyboard.release(key_right);
      debug_serial_println("key_right  released.");
      rightButtonState = false;
      boostKeyState = false;
    }

    ///////////// Left & Right On together => Boost /////////////////////////////////////
    if(digitalRead(leftButton) == HIGH  && digitalRead(rightButton) == HIGH && boostKeyState  == false){     
          //Keyboard.press(key_boost);
          hm10.write(NITRO);
          
          debug_serial_println("key_boost pressed."); 
          leftButtonState  = true;
          rightButtonState = true;
          boostKeyState = true;         
    }

    ///////////// Enter Button //////////////////////////////////////////////////////
    if(digitalRead(enterButton) == HIGH && enterButtonState == false){//enter button  on
      //Keyboard.press(key_enter);
      hm10.write(ENTER);
      
      debug_serial_println("key_enter pressed.");
      enterButtonState =  true;
    }else if(digitalRead(enterButton) == LOW && enterButtonState == true){//enter  button off
      //Keyboard.release(key_enter);
      debug_serial_println("key_enter  released.");
      enterButtonState = false;
    }

    /////////////  Esc Button //////////////////////////////////////////////////////
    if(digitalRead(escButton)  == HIGH && escButtonState == false){//esc button on
      //Keyboard.press(key_esc);
      hm10.write(PAUSE);
      
      debug_serial_println("key_esc pressed.");
      escButtonState = true;
    }else if(digitalRead(escButton) == LOW && escButtonState  == true){//esc button off
      //Keyboard.release(key_esc);
      debug_serial_println("key_esc  released.");
      escButtonState = false;
    }
  
   /////////////  Bicycle Sensor Input //////////////////////////////////////////////////////
   if(digitalRead(upButton) == LOW) {//sensor on
        if(hall_sensor_contacted  == false){
          debug_serial_println("hall_sensor_contacted 1");
          hall_sensor_contacted  = true;
          rotate_count += 1;
          on_time = micros();
        }
    }else{
        hall_sensor_contacted = false;
        off_time = micros();
        passed_time = (off_time - on_time) / 1000000.0;
      
      if(passed_time  >= 1){//when rotation stopped
        //debug_serial_println("break 1");
        break;
      }
    }

    if(rotate_count >= rotate_count_thresh){  
      //debug_serial_println("break 2");
      break;    
    }
  }
  
  end_time = micros();
  passed_time = (end_time - start_time) /  1000000.0;
  float rpm_val = (rotate_count/passed_time)*60.0;

//  Serial.print("Time  Passed: ");
//  Serial.print(passed_time);
//  debug_serial_println("s");
//  Serial.print(rpm_val);
//  debug_serial_println(" RPM");
  
  delay(1);        // delay in between reads for stability

  if(rpm_val >= RPM_LIMIT_COUNT){
    //Keyboard.press(key_up);
    hm10.write(ACCEL);
    debug_serial_println("key_up  press");
  }else{
    //Keyboard.releaseAll();   
    //debug_serial_println("key  release All");
  }  
}

Bike racing board source

c_cpp

1 /*
2  Bike racing board for Bluetooth 
3  
4  created 2 May 2019
5   modified 10 May 2019
6  by Steve Kim
7  This example code is in the public   domain.
8 
9*/
10#include <SoftwareSerial.h>
11
12//#define DEBUG 1
13
14//Bluetooth   send constants
15#define ACCEL         "w"
16#define STEER_LEFT    "a"
17#define   STEER_RIGHT   "d"
18#define NITRO         "n"
19#define PAUSE         "q"
20#define   ENTER         "e"
21
22#define RPM_LIMIT_COUNT 50
23
24SoftwareSerial hm10(8,9);   //RX, TX connection 
25
26// set pin numbers for the five buttons:
27const int   upButton = 12;//bicycle hall sensor
28const int downButton = 11;//not used
29const   int leftButton = 4;
30const int rightButton = 5;
31const int enterButton = 2;
32const   int escButton = 3;
33const int ledPin = 13;
34
35
36//Speed variable
37int   rotate_count_thresh = 2;//Hall sensor sensitivity
38bool hall_sensor_contacted   = false;
39int  rotate_count = 0;
40
41//Duration measurement variables
42float   start_time;
43float end_time;
44float on_time;
45float off_time;
46float passed_time;
47
48//Button   State
49bool leftButtonState = false;
50bool rightButtonState = false;
51bool   enterButtonState = false;
52bool escButtonState = false;
53bool boostKeyState   = false;
54
55void debug_serial_print(const char *str)
56{
57  #ifdef DEBUG
58     Serial.print(str);
59  #endif
60}
61
62void debug_serial_println(const char   *str)
63{
64  #ifdef DEBUG
65    Serial.println(str);;
66  #endif
67}
68
69void   setup() { // initialize the buttons' inputs:
70  pinMode(upButton, INPUT);
71   pinMode(downButton, INPUT);
72  pinMode(leftButton, INPUT);
73  pinMode(rightButton,   INPUT);
74  pinMode(enterButton, INPUT);
75  pinMode(escButton, INPUT);
76  pinMode(ledPin,OUTPUT);
77
78   Serial.begin(115200);
79  hm10.begin(9600);
80}
81
82void loop() { 
83
84   rotate_count = 0;
85  hall_sensor_contacted = false;
86
87  start_time = micros();   
88  on_time = micros();
89
90  while(true){
91    //Button input processing
92     ///////////// Left Button //////////////////////////////////////////////////////
93     if(digitalRead(leftButton) == HIGH && leftButtonState == false){//left button   on
94      if(digitalRead(rightButton) == LOW && rightButtonState == false){//left   only on
95        //Keyboard.press(key_left);
96        hm10.write(STEER_LEFT);
97         
98        debug_serial_println("key_left pressed."); 
99        leftButtonState   = true;
100      }      
101    }else if(digitalRead(leftButton) == LOW && leftButtonState   == true){//left button off
102      //Keyboard.release(key_left);
103      debug_serial_println("key_left   released.");    
104      leftButtonState = false;
105      boostKeyState = false;
106     }
107
108    ///////////// Right Button //////////////////////////////////////////////////////
109     if(digitalRead(rightButton) == HIGH && rightButtonState == false){//right button   on
110      if(digitalRead(leftButton) == LOW && leftButtonState == false){//right   only on
111        //Keyboard.press(key_right);
112        hm10.write(STEER_RIGHT);
113         
114        debug_serial_println("key_right pressed.");
115        rightButtonState   = true;
116      }      
117    }else if(digitalRead(rightButton) == LOW && rightButtonState   == true){//right button off
118      //Keyboard.release(key_right);
119      debug_serial_println("key_right   released.");
120      rightButtonState = false;
121      boostKeyState = false;
122     }
123
124    ///////////// Left & Right On together => Boost /////////////////////////////////////
125     if(digitalRead(leftButton) == HIGH  && digitalRead(rightButton) == HIGH && boostKeyState   == false){     
126          //Keyboard.press(key_boost);
127          hm10.write(NITRO);
128           
129          debug_serial_println("key_boost pressed."); 
130          leftButtonState   = true;
131          rightButtonState = true;
132          boostKeyState = true;          
133    }
134
135    ///////////// Enter Button //////////////////////////////////////////////////////
136     if(digitalRead(enterButton) == HIGH && enterButtonState == false){//enter button   on
137      //Keyboard.press(key_enter);
138      hm10.write(ENTER);
139      
140       debug_serial_println("key_enter pressed.");
141      enterButtonState =   true;
142    }else if(digitalRead(enterButton) == LOW && enterButtonState == true){//enter   button off
143      //Keyboard.release(key_enter);
144      debug_serial_println("key_enter   released.");
145      enterButtonState = false;
146    }
147
148    /////////////   Esc Button //////////////////////////////////////////////////////
149    if(digitalRead(escButton)   == HIGH && escButtonState == false){//esc button on
150      //Keyboard.press(key_esc);
151       hm10.write(PAUSE);
152      
153      debug_serial_println("key_esc pressed.");
154       escButtonState = true;
155    }else if(digitalRead(escButton) == LOW && escButtonState   == true){//esc button off
156      //Keyboard.release(key_esc);
157      debug_serial_println("key_esc   released.");
158      escButtonState = false;
159    }
160  
161   /////////////   Bicycle Sensor Input //////////////////////////////////////////////////////
162    if(digitalRead(upButton) == LOW) {//sensor on
163        if(hall_sensor_contacted   == false){
164          debug_serial_println("hall_sensor_contacted 1");
165          hall_sensor_contacted   = true;
166          rotate_count += 1;
167          on_time = micros();
168        }
169     }else{
170        hall_sensor_contacted = false;
171        off_time = micros();
172         passed_time = (off_time - on_time) / 1000000.0;
173      
174      if(passed_time   >= 1){//when rotation stopped
175        //debug_serial_println("break 1");
176         break;
177      }
178    }
179
180    if(rotate_count >= rotate_count_thresh){   
181      //debug_serial_println("break 2");
182      break;    
183    }
184   }
185  
186  end_time = micros();
187  passed_time = (end_time - start_time) /   1000000.0;
188  float rpm_val = (rotate_count/passed_time)*60.0;
189
190//  Serial.print("Time   Passed: ");
191//  Serial.print(passed_time);
192//  debug_serial_println("s");
193//   Serial.print(rpm_val);
194//  debug_serial_println(" RPM");
195  
196  delay(1);         // delay in between reads for stability
197
198  if(rpm_val >= RPM_LIMIT_COUNT){
199     //Keyboard.press(key_up);
200    hm10.write(ACCEL);
201    debug_serial_println("key_up   press");
202  }else{
203    //Keyboard.releaseAll();   
204    //debug_serial_println("key   release All");
205  }  
206}

 /*
  Bike racing board for Bluetooth 
  
  created 2 May 2019
   modified 10 May 2019
  by Steve Kim
  This example code is in the public   domain.
 
*/
#include <SoftwareSerial.h>

//#define DEBUG 1

//Bluetooth   send constants
#define ACCEL         "w"
#define STEER_LEFT    "a"
#define   STEER_RIGHT   "d"
#define NITRO         "n"
#define PAUSE         "q"
#define   ENTER         "e"

#define RPM_LIMIT_COUNT 50

SoftwareSerial hm10(8,9);   //RX, TX connection 

// set pin numbers for the five buttons:
const int   upButton = 12;//bicycle hall sensor
const int downButton = 11;//not used
const   int leftButton = 4;
const int rightButton = 5;
const int enterButton = 2;
const   int escButton = 3;
const int ledPin = 13;


//Speed variable
int   rotate_count_thresh = 2;//Hall sensor sensitivity
bool hall_sensor_contacted   = false;
int  rotate_count = 0;

//Duration measurement variables
float   start_time;
float end_time;
float on_time;
float off_time;
float passed_time;

//Button   State
bool leftButtonState = false;
bool rightButtonState = false;
bool   enterButtonState = false;
bool escButtonState = false;
bool boostKeyState   = false;

void debug_serial_print(const char *str)
{
  #ifdef DEBUG
     Serial.print(str);
  #endif
}

void debug_serial_println(const char   *str)
{
  #ifdef DEBUG
    Serial.println(str);;
  #endif
}

void   setup() { // initialize the buttons' inputs:
  pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
  pinMode(leftButton, INPUT);
  pinMode(rightButton,   INPUT);
  pinMode(enterButton, INPUT);
  pinMode(escButton, INPUT);
  pinMode(ledPin,OUTPUT);

   Serial.begin(115200);
  hm10.begin(9600);
}

void loop() { 

   rotate_count = 0;
  hall_sensor_contacted = false;

  start_time = micros();   
  on_time = micros();

  while(true){
    //Button input processing
     ///////////// Left Button //////////////////////////////////////////////////////
     if(digitalRead(leftButton) == HIGH && leftButtonState == false){//left button   on
      if(digitalRead(rightButton) == LOW && rightButtonState == false){//left   only on
        //Keyboard.press(key_left);
        hm10.write(STEER_LEFT);
         
        debug_serial_println("key_left pressed."); 
        leftButtonState   = true;
      }      
    }else if(digitalRead(leftButton) == LOW && leftButtonState   == true){//left button off
      //Keyboard.release(key_left);
      debug_serial_println("key_left   released.");    
      leftButtonState = false;
      boostKeyState = false;
     }

    ///////////// Right Button //////////////////////////////////////////////////////
     if(digitalRead(rightButton) == HIGH && rightButtonState == false){//right button   on
      if(digitalRead(leftButton) == LOW && leftButtonState == false){//right   only on
        //Keyboard.press(key_right);
        hm10.write(STEER_RIGHT);
         
        debug_serial_println("key_right pressed.");
        rightButtonState   = true;
      }      
    }else if(digitalRead(rightButton) == LOW && rightButtonState   == true){//right button off
      //Keyboard.release(key_right);
      debug_serial_println("key_right   released.");
      rightButtonState = false;
      boostKeyState = false;
     }

    ///////////// Left & Right On together => Boost /////////////////////////////////////
     if(digitalRead(leftButton) == HIGH  && digitalRead(rightButton) == HIGH && boostKeyState   == false){     
          //Keyboard.press(key_boost);
          hm10.write(NITRO);
           
          debug_serial_println("key_boost pressed."); 
          leftButtonState   = true;
          rightButtonState = true;
          boostKeyState = true;          
    }

    ///////////// Enter Button //////////////////////////////////////////////////////
     if(digitalRead(enterButton) == HIGH && enterButtonState == false){//enter button   on
      //Keyboard.press(key_enter);
      hm10.write(ENTER);
      
       debug_serial_println("key_enter pressed.");
      enterButtonState =   true;
    }else if(digitalRead(enterButton) == LOW && enterButtonState == true){//enter   button off
      //Keyboard.release(key_enter);
      debug_serial_println("key_enter   released.");
      enterButtonState = false;
    }

    /////////////   Esc Button //////////////////////////////////////////////////////
    if(digitalRead(escButton)   == HIGH && escButtonState == false){//esc button on
      //Keyboard.press(key_esc);
       hm10.write(PAUSE);
      
      debug_serial_println("key_esc pressed.");
       escButtonState = true;
    }else if(digitalRead(escButton) == LOW && escButtonState   == true){//esc button off
      //Keyboard.release(key_esc);
      debug_serial_println("key_esc   released.");
      escButtonState = false;
    }
  
   /////////////   Bicycle Sensor Input //////////////////////////////////////////////////////
    if(digitalRead(upButton) == LOW) {//sensor on
        if(hall_sensor_contacted   == false){
          debug_serial_println("hall_sensor_contacted 1");
          hall_sensor_contacted   = true;
          rotate_count += 1;
          on_time = micros();
        }
     }else{
        hall_sensor_contacted = false;
        off_time = micros();
         passed_time = (off_time - on_time) / 1000000.0;
      
      if(passed_time   >= 1){//when rotation stopped
        //debug_serial_println("break 1");
         break;
      }
    }

    if(rotate_count >= rotate_count_thresh){   
      //debug_serial_println("break 2");
      break;    
    }
   }
  
  end_time = micros();
  passed_time = (end_time - start_time) /   1000000.0;
  float rpm_val = (rotate_count/passed_time)*60.0;

//  Serial.print("Time   Passed: ");
//  Serial.print(passed_time);
//  debug_serial_println("s");
//   Serial.print(rpm_val);
//  debug_serial_println(" RPM");
  
  delay(1);         // delay in between reads for stability

  if(rpm_val >= RPM_LIMIT_COUNT){
     //Keyboard.press(key_up);
    hm10.write(ACCEL);
    debug_serial_println("key_up   press");
  }else{
    //Keyboard.releaseAll();   
    //debug_serial_println("key   release All");
  }  
}

Bike racing board source

c_cpp

1 /*
2  Bike racing board for Bluetooth 
3  
4  created 2 May 2019
5
6  modified 10 May 2019
7  by Steve Kim
8  This example code is in the public
9  domain.
10 
11*/
12#include <SoftwareSerial.h>
13
14//#define DEBUG 1
15
16//Bluetooth
17  send constants
18#define ACCEL         "w"
19#define STEER_LEFT    "a"
20#define
21  STEER_RIGHT   "d"
22#define NITRO         "n"
23#define PAUSE         "q"
24#define
25  ENTER         "e"
26
27#define RPM_LIMIT_COUNT 50
28
29SoftwareSerial hm10(8,9);
30  //RX, TX connection 
31
32// set pin numbers for the five buttons:
33const int
34  upButton = 12;//bicycle hall sensor
35const int downButton = 11;//not used
36const
37  int leftButton = 4;
38const int rightButton = 5;
39const int enterButton = 2;
40const
41  int escButton = 3;
42const int ledPin = 13;
43
44
45//Speed variable
46int
47  rotate_count_thresh = 2;//Hall sensor sensitivity
48bool hall_sensor_contacted
49  = false;
50int  rotate_count = 0;
51
52//Duration measurement variables
53float
54  start_time;
55float end_time;
56float on_time;
57float off_time;
58float passed_time;
59
60//Button
61  State
62bool leftButtonState = false;
63bool rightButtonState = false;
64bool
65  enterButtonState = false;
66bool escButtonState = false;
67bool boostKeyState
68  = false;
69
70void debug_serial_print(const char *str)
71{
72  #ifdef DEBUG
73
74    Serial.print(str);
75  #endif
76}
77
78void debug_serial_println(const char
79  *str)
80{
81  #ifdef DEBUG
82    Serial.println(str);;
83  #endif
84}
85
86void
87  setup() { // initialize the buttons' inputs:
88  pinMode(upButton, INPUT);
89
90  pinMode(downButton, INPUT);
91  pinMode(leftButton, INPUT);
92  pinMode(rightButton,
93  INPUT);
94  pinMode(enterButton, INPUT);
95  pinMode(escButton, INPUT);
96  pinMode(ledPin,OUTPUT);
97
98
99  Serial.begin(115200);
100  hm10.begin(9600);
101}
102
103void loop() { 
104
105
106  rotate_count = 0;
107  hall_sensor_contacted = false;
108
109  start_time = micros();
110  
111  on_time = micros();
112
113  while(true){
114    //Button input processing
115
116    ///////////// Left Button //////////////////////////////////////////////////////
117
118    if(digitalRead(leftButton) == HIGH && leftButtonState == false){//left button
119  on
120      if(digitalRead(rightButton) == LOW && rightButtonState == false){//left
121  only on
122        //Keyboard.press(key_left);
123        hm10.write(STEER_LEFT);
124
125        
126        debug_serial_println("key_left pressed."); 
127        leftButtonState
128  = true;
129      }      
130    }else if(digitalRead(leftButton) == LOW && leftButtonState
131  == true){//left button off
132      //Keyboard.release(key_left);
133      debug_serial_println("key_left
134  released.");    
135      leftButtonState = false;
136      boostKeyState = false;
137
138    }
139
140    ///////////// Right Button //////////////////////////////////////////////////////
141
142    if(digitalRead(rightButton) == HIGH && rightButtonState == false){//right button
143  on
144      if(digitalRead(leftButton) == LOW && leftButtonState == false){//right
145  only on
146        //Keyboard.press(key_right);
147        hm10.write(STEER_RIGHT);
148
149        
150        debug_serial_println("key_right pressed.");
151        rightButtonState
152  = true;
153      }      
154    }else if(digitalRead(rightButton) == LOW && rightButtonState
155  == true){//right button off
156      //Keyboard.release(key_right);
157      debug_serial_println("key_right
158  released.");
159      rightButtonState = false;
160      boostKeyState = false;
161
162    }
163
164    ///////////// Left & Right On together => Boost /////////////////////////////////////
165
166    if(digitalRead(leftButton) == HIGH  && digitalRead(rightButton) == HIGH && boostKeyState
167  == false){     
168          //Keyboard.press(key_boost);
169          hm10.write(NITRO);
170
171          
172          debug_serial_println("key_boost pressed."); 
173          leftButtonState
174  = true;
175          rightButtonState = true;
176          boostKeyState = true;
177         
178    }
179
180    ///////////// Enter Button //////////////////////////////////////////////////////
181
182    if(digitalRead(enterButton) == HIGH && enterButtonState == false){//enter button
183  on
184      //Keyboard.press(key_enter);
185      hm10.write(ENTER);
186      
187
188      debug_serial_println("key_enter pressed.");
189      enterButtonState =
190  true;
191    }else if(digitalRead(enterButton) == LOW && enterButtonState == true){//enter
192  button off
193      //Keyboard.release(key_enter);
194      debug_serial_println("key_enter
195  released.");
196      enterButtonState = false;
197    }
198
199    /////////////
200  Esc Button //////////////////////////////////////////////////////
201    if(digitalRead(escButton)
202  == HIGH && escButtonState == false){//esc button on
203      //Keyboard.press(key_esc);
204
205      hm10.write(PAUSE);
206      
207      debug_serial_println("key_esc pressed.");
208
209      escButtonState = true;
210    }else if(digitalRead(escButton) == LOW && escButtonState
211  == true){//esc button off
212      //Keyboard.release(key_esc);
213      debug_serial_println("key_esc
214  released.");
215      escButtonState = false;
216    }
217  
218   /////////////
219  Bicycle Sensor Input //////////////////////////////////////////////////////
220
221   if(digitalRead(upButton) == LOW) {//sensor on
222        if(hall_sensor_contacted
223  == false){
224          debug_serial_println("hall_sensor_contacted 1");
225          hall_sensor_contacted
226  = true;
227          rotate_count += 1;
228          on_time = micros();
229        }
230
231    }else{
232        hall_sensor_contacted = false;
233        off_time = micros();
234
235        passed_time = (off_time - on_time) / 1000000.0;
236      
237      if(passed_time
238  >= 1){//when rotation stopped
239        //debug_serial_println("break 1");
240
241        break;
242      }
243    }
244
245    if(rotate_count >= rotate_count_thresh){
246  
247      //debug_serial_println("break 2");
248      break;    
249    }
250
251  }
252  
253  end_time = micros();
254  passed_time = (end_time - start_time) /
255  1000000.0;
256  float rpm_val = (rotate_count/passed_time)*60.0;
257
258//  Serial.print("Time
259  Passed: ");
260//  Serial.print(passed_time);
261//  debug_serial_println("s");
262//
263  Serial.print(rpm_val);
264//  debug_serial_println(" RPM");
265  
266  delay(1);
267        // delay in between reads for stability
268
269  if(rpm_val >= RPM_LIMIT_COUNT){
270
271    //Keyboard.press(key_up);
272    hm10.write(ACCEL);
273    debug_serial_println("key_up
274  press");
275  }else{
276    //Keyboard.releaseAll();   
277    //debug_serial_println("key
278  release All");
279  }  
280}

 /*
  Bike racing board for Bluetooth 
  
  created 2 May 2019

  modified 10 May 2019
  by Steve Kim
  This example code is in the public
  domain.
 
*/
#include <SoftwareSerial.h>

//#define DEBUG 1

//Bluetooth
  send constants
#define ACCEL         "w"
#define STEER_LEFT    "a"
#define
  STEER_RIGHT   "d"
#define NITRO         "n"
#define PAUSE         "q"
#define
  ENTER         "e"

#define RPM_LIMIT_COUNT 50

SoftwareSerial hm10(8,9);
  //RX, TX connection 

// set pin numbers for the five buttons:
const int
  upButton = 12;//bicycle hall sensor
const int downButton = 11;//not used
const
  int leftButton = 4;
const int rightButton = 5;
const int enterButton = 2;
const
  int escButton = 3;
const int ledPin = 13;


//Speed variable
int
  rotate_count_thresh = 2;//Hall sensor sensitivity
bool hall_sensor_contacted
  = false;
int  rotate_count = 0;

//Duration measurement variables
float
  start_time;
float end_time;
float on_time;
float off_time;
float passed_time;

//Button
  State
bool leftButtonState = false;
bool rightButtonState = false;
bool
  enterButtonState = false;
bool escButtonState = false;
bool boostKeyState
  = false;

void debug_serial_print(const char *str)
{
  #ifdef DEBUG

    Serial.print(str);
  #endif
}

void debug_serial_println(const char
  *str)
{
  #ifdef DEBUG
    Serial.println(str);;
  #endif
}

void
  setup() { // initialize the buttons' inputs:
  pinMode(upButton, INPUT);

  pinMode(downButton, INPUT);
  pinMode(leftButton, INPUT);
  pinMode(rightButton,
  INPUT);
  pinMode(enterButton, INPUT);
  pinMode(escButton, INPUT);
  pinMode(ledPin,OUTPUT);


  Serial.begin(115200);
  hm10.begin(9600);
}

void loop() { 


  rotate_count = 0;
  hall_sensor_contacted = false;

  start_time = micros();
  
  on_time = micros();

  while(true){
    //Button input processing

    ///////////// Left Button //////////////////////////////////////////////////////

    if(digitalRead(leftButton) == HIGH && leftButtonState == false){//left button
  on
      if(digitalRead(rightButton) == LOW && rightButtonState == false){//left
  only on
        //Keyboard.press(key_left);
        hm10.write(STEER_LEFT);

        
        debug_serial_println("key_left pressed."); 
        leftButtonState
  = true;
      }      
    }else if(digitalRead(leftButton) == LOW && leftButtonState
  == true){//left button off
      //Keyboard.release(key_left);
      debug_serial_println("key_left
  released.");    
      leftButtonState = false;
      boostKeyState = false;

    }

    ///////////// Right Button //////////////////////////////////////////////////////

    if(digitalRead(rightButton) == HIGH && rightButtonState == false){//right button
  on
      if(digitalRead(leftButton) == LOW && leftButtonState == false){//right
  only on
        //Keyboard.press(key_right);
        hm10.write(STEER_RIGHT);

        
        debug_serial_println("key_right pressed.");
        rightButtonState
  = true;
      }      
    }else if(digitalRead(rightButton) == LOW && rightButtonState
  == true){//right button off
      //Keyboard.release(key_right);
      debug_serial_println("key_right
  released.");
      rightButtonState = false;
      boostKeyState = false;

    }

    ///////////// Left & Right On together => Boost /////////////////////////////////////

    if(digitalRead(leftButton) == HIGH  && digitalRead(rightButton) == HIGH && boostKeyState
  == false){     
          //Keyboard.press(key_boost);
          hm10.write(NITRO);

          
          debug_serial_println("key_boost pressed."); 
          leftButtonState
  = true;
          rightButtonState = true;
          boostKeyState = true;
         
    }

    ///////////// Enter Button //////////////////////////////////////////////////////

    if(digitalRead(enterButton) == HIGH && enterButtonState == false){//enter button
  on
      //Keyboard.press(key_enter);
      hm10.write(ENTER);
      

      debug_serial_println("key_enter pressed.");
      enterButtonState =
  true;
    }else if(digitalRead(enterButton) == LOW && enterButtonState == true){//enter
  button off
      //Keyboard.release(key_enter);
      debug_serial_println("key_enter
  released.");
      enterButtonState = false;
    }

    /////////////
  Esc Button //////////////////////////////////////////////////////
    if(digitalRead(escButton)
  == HIGH && escButtonState == false){//esc button on
      //Keyboard.press(key_esc);

      hm10.write(PAUSE);
      
      debug_serial_println("key_esc pressed.");

      escButtonState = true;
    }else if(digitalRead(escButton) == LOW && escButtonState
  == true){//esc button off
      //Keyboard.release(key_esc);
      debug_serial_println("key_esc
  released.");
      escButtonState = false;
    }
  
   /////////////
  Bicycle Sensor Input //////////////////////////////////////////////////////

   if(digitalRead(upButton) == LOW) {//sensor on
        if(hall_sensor_contacted
  == false){
          debug_serial_println("hall_sensor_contacted 1");
          hall_sensor_contacted
  = true;
          rotate_count += 1;
          on_time = micros();
        }

    }else{
        hall_sensor_contacted = false;
        off_time = micros();

        passed_time = (off_time - on_time) / 1000000.0;
      
      if(passed_time
  >= 1){//when rotation stopped
        //debug_serial_println("break 1");

        break;
      }
    }

    if(rotate_count >= rotate_count_thresh){
  
      //debug_serial_println("break 2");
      break;    
    }

  }
  
  end_time = micros();
  passed_time = (end_time - start_time) /
  1000000.0;
  float rpm_val = (rotate_count/passed_time)*60.0;

//  Serial.print("Time
  Passed: ");
//  Serial.print(passed_time);
//  debug_serial_println("s");
//
  Serial.print(rpm_val);
//  debug_serial_println(" RPM");
  
  delay(1);
        // delay in between reads for stability

  if(rpm_val >= RPM_LIMIT_COUNT){

    //Keyboard.press(key_up);
    hm10.write(ACCEL);
    debug_serial_println("key_up
  press");
  }else{
    //Keyboard.releaseAll();   
    //debug_serial_println("key
  release All");
  }  
}

Bike racing board source