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

•

7731 views

•

7 respects

entertainment system

health

games

Devices & Components

Arduino Leonardo with Headers

Neodymium

HM-10 Bluetooth module

Hall sensor

Wire, Wrapping Wire

Solderless Breadboard Half Size

Switch Actuator, Head for spring return push-button

Resistor 10k ohm

Development Kit Accessory, Jumper Wire Kit

Hardware & Tools

Solder Wire, Lead Free

Soldering iron (generic)

Software & Tools

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