In this short tutorial, I’ll walk you through the process of turning any bicycle into an arcade-like controller for computer games. Despite not setting the example for leading a healthy lifestyle, my wife and I do try to eat our greens, avoid too much junk, and keep in shape. Our 5 year old on the other hand, couldn’t care less about doing any physical activity, unless it gets him closer to his (my…) iPad. best Normally, This issue is partially remedied simply by being a kid, which involves a fair amount of running, climbing, falling… and recently cycling! But unfortunately, with the advent of the COVID-19 pandemic, we can’t really do much of that. So, I turned his bicycle into a keyboard. Now, he can play his favorite computer games and exercise at the same time! In this short article, I’ll walk you through the process of building your very own . keyboard bike Foundations: The first step is turning the bicycle into indoor training bikes by getting the rear wheel to spin freely without touching the ground, and allow the handlebars to turn freely as well. If your kid is propelled forward, you should NOT proceed to the following steps. There are many ways of getting the bike to remain in place while spinning the pedals. Hanging the bicycle from the ceiling, digging a hole in the floor beneath the wheel and many more. I personally used the training wheels to support the rear, but this is your place to get creative, and more importantly, . I am deliberately avoiding getting into too much detail about my implementation of this part (you can get a pretty good idea from the various pictures and gifs in this article…) as it is your responsibility to make sure that the bicycle are secure and safe to use. be responsible The plan After securing the bike so that it can be pedalled in place, we will connect sensors to capture the rotation of the rear wheel, position of the handle bars and some buttons for extra control (these can be easily programmed later to map any keyboard key). Data from all sensors will be captured and transformed by an Arduino that will function as a keyboard and send keystrokes to a computer running a (most likely racing) game. Hardware We must use a board that can function as a USB keyboard. I used . Arduino Leonardo I used 3 types of sensors: . — This sensor changes its output voltage when in the proximity of a magnetic field. We will use it to transform the rotation of the rear wheel to a forward key press. — Used to transform the handlebar orientation to left/right keys. — used as extra controllers. I recommend using this type of switches (limit switch) and not going for some fancy buttons. these switches are very responsive, whereas some buttons can sometimes be challenging for a kid to press. 1 A1302 Hall Effect Sensor 2. 10K ohm linear potentiometer 3. Microswitch highly Connecting the parts Hall effect sensor By placing magnets on the rear wheel, and positioning the sensor close (as close as possible without touching the wheel), we can sense the wheel’s rotation as the magnets pass by the sensor. I used two magnets equally spaced (that is ~180 degrees apart). A tip for attaching the magnets - You could probably find a more elegant solution, but the one I used here is to wrap the magnets in plastic wrap and twist the ends, like a candy wrap (I am referring to the white blobs seen spinning with the wheel in the gif above). Then use the loose ends to tie the magnets to the wheel’s spokes, and secure with hot glue. In order to get the sensor (this is referring to the red vertical rod in the gif, the sensor itself is located at its end) as close to the wheel as possible I mounted it to a flexible wire (I used some heavy duty electrical wire but any wire that will flex and keep its position will do). Potentiometer The potentiometer needs to be connected to the pivot point of the handlebars. There should be a socket for an allen wrench at that point. I used a fitting driver bit and connected it to the potentiometer. Originally, my plan was to solder both parts together, but driver bits have low (none) solder-ability. I ended up taking a short piece of straw (seen in the gif below in violet) sticking the potentiometer and driver bit from both sides, and injecting it with hot glue, to keep everything together. It’s solid as a rock. As for securing the potentiometer to the bike frame, you will again need to get creative. my solution (which can be seen in the trailer gif and in the image at the end of the article showing all components detached from the bike) was based on making a plexiglass “arm” to hold the potentiometer in place, and may not work for your child’s bike. The idea is simple, the potentiometer needs to spin with the handlebars. Simple as it is, the implementation can be quite challenging… Switches I placed one of the switches behind the (redundant) front wheel brake lever, and the other one behind the not redundant back wheel brake lever, and disconnected this brake, so that the switches are pressed by pressing the brakes, which feels very natural. Again, I’m not taking any responsibility here. if you feel the supports you made in part 1 are not strong enough and are worried about obstructing and/or disconnecting brakes, you can, and should place the buttons somewhere else. No right or wrong, as long as it’s comfortable and safe. I limited myself to two buttons but you can obviously go as high as the board allows. Wiring A note on thinking ahead. After completing , I set up to improve it by making sure I can easily disconnect all components and reassemble them again as quickly as possible, this required some tweaking, that could have been avoided if I had thought of this at the get go. It took me nearly to upgrade to , but it now takes to assemble/disassemble. keyboard-bike version 1.0 2 hours keyboard-bike version 2.0 less than a minute Another point to keep in mind is what’s the best place to secure the board. I thoughtlessly put it on the side my son gets on and off the bike. In retrospect, I should have chosen the other side… Code As explained in the hardware section, the setup is composed of 3 types of sensors: Hall effect sensor, potentiometer, and buttons. I’ll explain the code for each component separately. keyboard bike Hall effect sensor The hall effect sensor is “activated” when the wheel spins and the magnets pass by the sensor, inducing a change in output voltage. For this part, I switched on the key (forward key in my case) whenever there was an absolute change in voltage above a certain threshold (hall_effect_threshold). I then keep it on and start counting back for a certain amount of time (drive_decay_const). This allows tuning the amount of motion you get from each "spike". Increase the value of drive_decay_const to get more movement. Potentiometer Here we’re basically trying to convert an “analog” motion of turning the handlebars into a “binary” left or right clicks. A continuous press is way too dramatic if you just want to make small adjustments, so the amount of turn needs to be represented as “click amount”. I’m doing this by activating and deactivating turning movement at a set interval (interval), so that turning the handlebars beyond a certain threshold, will start pressing intermittently. In addition, I add a delay while the button is activated, that grows with the amount of turn. So for higher angle turns, the button will be pressed for a longer duration (that is, each click will be longer) resulting in a more aggressive turn. Also, notice that I'm initialising pot_center at setup. this is helpful for cases where the potentiometer gets disconnected from the socket. Instead of having to relocate the center, you can just reset the board, and the center will be reset. Switches Nothing special here. Just replace the activated key to suit your needs. The code here is for playing which is a great racing game for kids, but the bike could obviously be adjusted for many other games. We also use it to play Minecraft, which works great. SuperTuxKart hall_effect_threshold = turn_threshold = ; drive_decay_const = ; turn_decay_const = ; button_1_val = ; button_2_val = ; interval = ; button_1 = ; button_2 = ; pot_center = ; prev_hallSensorValue = ; delay_time = ; drive_decay = ; previousMillis = ; allow_turn = ; turn_amount = ; {
  Serial.begin( );
  Keyboard.begin();
  pinMode(button_1, INPUT);
  pinMode(button_2, INPUT);
  pot_center = analogRead(A1);
} { currentMillis = millis(); hallSensorValue = analogRead(A0); pot = analogRead(A1); ( (hallSensorValue- prev_hallSensorValue) > ){
    prev_hallSensorValue = hallSensorValue;
    Keyboard.press(KEY_UP_ARROW);
    drive_decay = drive_decay_const;
  } { (drive_decay <= ){
        Keyboard.release(KEY_UP_ARROW);
        } {
      drive_decay -= ;
      }
    } (allow_turn== ){ (pot < pot_center - turn_threshold) {
    Keyboard.press(KEY_RIGHT_ARROW);
    } (pot > pot_center + turn_threshold){
    Keyboard.press(KEY_LEFT_ARROW);
  }} (currentMillis - previousMillis >= interval) { previousMillis = currentMillis;
    turn_amount = (pot-pot_center); (allow_turn == ) { (turn_amount > turn_threshold){
          delay(turn_amount); }
      allow_turn = ;
    } {
      allow_turn = ;
      } Keyboard.release(KEY_RIGHT_ARROW);
      Keyboard.release(KEY_LEFT_ARROW);
    } (digitalRead(button_1) == HIGH){
    Keyboard.press(button_1_val);
    } {
     Keyboard.release(button_1_val);
    } (digitalRead(button_2) == HIGH){
    Keyboard.press(button_2_val);
    } {
     Keyboard.release(button_2_val);
    }
} /*
bicycle_keyboard
*/ # include "Keyboard.h" const int 1 // threshold for hall effect sensor. const int 35 // threshold for detecting a left/right movement. const int 100 // drive_decay speed of car (larger => slower decreasing / faster car) const int 0.75 // multiplier for intensity of turn. higher value => sharper turns. const char ' ' // value for button 1 const char 'n' // value for button 2 const long 200 // interval for allowing not allowing turns. const int 2 // button_1 pin const int 3 // button_2 pin int 500 // center point for potentiometer. this value is being reset in setup. int 0 // initial value for sensor const int 1 // delay between reads int 0 // initial drive_decay value unsigned long 0 // initial value bool true // allow turn is a boolean to only allow turns every passing interval int 0 // initial value void setup () 9600 void loop () unsigned long int int //  Serial.println(hallSensorValue); //  Serial.println(pot);  delay(delay_time);        // delay in between reads for stability  // DRIVE: if abs 1 else if 0 else 1 if true //TURN RIGHT if // TURN LEFT if if // interval has passed abs // switch allow turn state: if true if //keep button pressed longer the more aggressive the turn. false else true // release the turn keys: //check buttons if else if else Summary To conclude, I hope I did a good job of explaining how to get the built. If you chose to build one, and find that I have not, don’t hesitate to send me a message. keyboard bike Also published behind a paywall: https://towardsdatascience.com/keeping-your-kids-in-shape-during-quarantine-by-turning-their-bicycle-into-a-keyboard-e1f8a34fac2e

Glue

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

Quarantine Life: How to Keep Your Kids Active by Turning their Bicycle into an Arcade Controller

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

38 Stories To Learn About Arduino

3DRacers: the first 3D printed RC toy

5 Beginner Friendly Arduino Projects To Gain A Head Start

9 Reasons why you should Learn Python

A Crypto-Powered Alarm You Can’t Snooze!

38 Stories To Learn About Arduino

3DRacers: the first 3D printed RC toy

5 Beginner Friendly Arduino Projects To Gain A Head Start

9 Reasons why you should Learn Python

A Crypto-Powered Alarm You Can’t Snooze!

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps