How to build your own set of Kino Wheels

Whether you like to practise operating hand wheels or use this in your own hardware project, here’s how to build a set of Kino Wheels. It’s gonna take a couple of hours, but we’ve intentionally kept it as simple as possible so anyone can follow along. The components will cost you about $200-$300. It’s open source, so you’re free to modify the design & code to your requirements.

Introduction

If you intend to use Kino Wheels to practise operating with our software, please download the Kino Wheels Simulator before you start and test if it works on your PC. The software is currently only available for Windows 7/10 and you need a decent graphics card to run it.

In the first part of the tutorial we’ll go through installing the Arduino IDE and loading the code onto your Arduino Microcontroller. In the next step we’ll be wiring up the rotary encoders to the Arduino. Now you are already able to control pan and tilt in the Kino Wheels Simulator, but we still need to mount the handwheels and attach them to the rotary encoders. The final optional step is to build a housing: We’ll go over this briefly in the last section and show you an example how to package everything neatly in an outdoor case.

Feel free to join our Facebook community to get in touch with other people building their set of Kino Wheels and share your finished unit!

Disclaimer

This tutorial and the Kino Wheels Simulator Software are provided “as is” for educational purposes only and it is your responsibility to use it properly and at your own risk. If you are unsure about working with electronics ask someone with experience, as some parts may get damaged if connected the wrong way. We’ve written this tutorial very carefully, but cannot assume responsibility for any errors.

Now that’s out of the way, here comes the fun part!

Parts and Tools

You don’t need a lot of tools for this project: a wire cutter, a Phillips screwdriver and a set of Allen keys will get you through. If you plan on building a housing, you’ll also need a power drill and a step drill bit.

The following are the parts we used. The electronic parts should be widely available, but you might need to substitute some mechanical parts in case they are not available where you live. Don’t worry though, we don’t have mechanical engineering degrees either, it just can take a bit of research to find exactly the right parts. We’d suggest getting the electronic parts first and shop for the mechanical parts while or after assembling the electronics.

Electronic components

1x    Arduino MEGA 2560 Microcontroller  arduino.cc

It’s important that you get the MEGA 2560 version of the board. Do not get the cheaper but very popular Arduino UNO because the project will not work with it.

2x    Rotary Encoders (Model: LPD3806-600BM-G5-24C)

Those are Chinese rotary encoders that are sold under different brand names. The ones we got are labeled “Wisamic 600p/r”. Googling “incremental rotary encoder 600p/r” will also help finding them even if they are sold under a different name. They register 600 steps per revolution, but through some software tricks we will quadruple this to 2400 steps. Unless you have experience in electronics try to get exactly those so you don’t have to figure out the wiring by yourself.

1x    Breadboard (400 tie points)

This is the base for wiring everything up. It’s normally used for prototyping before soldering everything to a circuit board. We use it permanently in this project to skip the soldering part and keep things simple. You could also try to get an electronics starter pack, they often include a breadboard, resistors and jumper wires.

8x   1/4 W 10K Ohm resistors

1x    Pack of jumper wires

1x    USB cable (A-B)

Mechanical components

We sourced most parts from the manufacturers MAEDLER (German) and MISUMI (Japanese). Both of their websites are also available in English.

2x    Spoked handwheel DIN 950 140mm (with thread hole for machine handle) maedler.de

These handwheels have a diameter of 140mm (about 5.5 inches). The hole in the middle has a diameter of 14mm.

2x    Revolving handle DIN 98 maedler.de

The matching handle for the hand wheels. If you choose to get a different sized hand wheel, make sure to get the right handle.

2x    Ball pillow block bearing TUCP 202 bore 15mm maedler.de

The bearings make everything turn smoothly and they also carry most of the weight of the hand wheels. These have a bore diameter of 15mm. The screws that hold the shaft in place need a 3mm Allen key.

2x    Flat knurled thumb screw DIN 653 maedler.de

2x    Rotary Shaft (SFRDE-D15-L60-F12-P6-T12-Q14-N6) misumi-europe.com

These rotary shafts have a diameter of 15mm in the middle to fit the bearings. One end has a M6 thread where the shaft is only 14mm in diameter, so the handwheels fit on there and can be screwed tight with a thumb screw. The other side is only 6mm in diameter to match the shaft of the rotary encoders. Misumi let’s you customize these types of rotary shafts. The options are extensive, so if you have different hand wheels or bearings that need a different shaft or different end shapes, you’ll probably be able to configure it on their website.

2x    Coupling (CPR16-6-6) misumi-europe.com

This coupling connects the shaft to the rotary encoder. The screws need an 1.5mm Allen key.

22x   Adhesive wheel balancing weights (5 grams per piece)

Originally made for balancing alloy wheels of cars, we’ll use them as counterweights for the handle of the wheel. If you are using an already balanced hand wheel you won’t need them.

 

Various parts

2x    Steel angle

We used them to mount the rotary encoders to the wooden board. It’s best you take one encoder, head to a hardware store and find a steel angle that has its borings at the right position to match the encoders. If you have access to a metal shop or a 3D printer you could also make a custom bracket.

4x    M3x10 screws

To attach the encoders to the steel angles.

1x    Wooden board

Used as base to mount everything onto while working on it. You can of course switch to a housing later.

x      Various wood screws (Philipps round head)

x      Various washers

Housing (optional)

1x    B&W Outdoor Case Type 4000 b-w-international.com

Empty case without the cubed foam or separators.

x      Wooden boards of various sizes

Used to mount everything inside the case. If you don’t have a saw, you can have them cut to size at your local hardware store.

1x    Small can of black paint

Just to give the inside a bit less of a DIY look 🙂

1x    Panel Mount USB-B Cable

To comfortably connect and disconnect the USB cord.

Setting up the Arduino

First you need to install the Arduino IDE. You can download it from https://www.arduino.cc/en/Main/Software. Make sure you allow the installation of all drivers.

After the installation is complete, connect the Arduino MEGA to your computer. (1) Start the Arduino IDE, click on “Tools” and under “Board” select “Arduino/Genuino MEGA or MEGA 2560”. (2) Then click on “Tools” again, go to “Port” and select the port of your Arduino.

The next step is to load the program code on the Arduino that will register the rotation of the handwheels and send it to your computer. Arduino programs are called “sketches”.

By default, the Arduino IDE should have created a new sketch with a bit of code. (3) Delete all the code.

(4) Now copy the code of the Kino Wheels sketch below to your clipboard and paste it into your empty sketch.

Kino Wheels sketch

float pulsesX, XA_SIG=0, XB_SIG=1, pulsesY, YA_SIG=0, YB_SIG=1;

void setup(){
attachInterrupt(0, XA_RISE, RISING); // Pin 2
attachInterrupt(1, XB_RISE, RISING); // Pin 3
attachInterrupt(4, YA_RISE, RISING); // Pin 19
attachInterrupt(5, YB_RISE, RISING); // Pin 18
Serial.begin(115200);
delay(100);
Serial.println(“Connected”);
}//setup

void loop(){
Serial.print(“x”);
Serial.print(pulsesX);
Serial.print(“y”);
Serial.print(pulsesY);
Serial.println(“end”);
delay(20);
}

//X-Axis

void XA_RISE(){
detachInterrupt(0);
//delay(1);
XA_SIG=1;

if(XB_SIG==0)
pulsesX++;//moving forward
if(XB_SIG==1)
pulsesX;//moving reverse

attachInterrupt(0, XA_FALL, FALLING);
}

void XA_FALL(){
detachInterrupt(0);
//delay(1);
XA_SIG=0;

if(XB_SIG==1)
pulsesX++;//moving forward
if(XB_SIG==0)
pulsesX;//moving reverse

attachInterrupt(0, XA_RISE, RISING);
}

void XB_RISE(){
detachInterrupt(1);
//delay(1);
XB_SIG=1;

if(XA_SIG==1)
pulsesX++;//moving forward
if(XA_SIG==0)
pulsesX;//moving reverse

attachInterrupt(1, XB_FALL, FALLING);
}

void XB_FALL(){
detachInterrupt(1);
//delay(1);
XB_SIG=0;

if(XA_SIG==0)
pulsesX++;//moving forward
if(XA_SIG==1)
pulsesX;//moving reverse

attachInterrupt(1, XB_RISE, RISING);
}

//Y-Axis

void YA_RISE(){
detachInterrupt(4);
//delay(1);
YA_SIG=1;

if(YB_SIG==0)
pulsesY++;//moving forward
if(YB_SIG==1)
pulsesY;//moving reverse

attachInterrupt(4, YA_FALL, FALLING);
}

void YA_FALL(){
detachInterrupt(4);
//delay(1);
YA_SIG=0;

if(YB_SIG==1)
pulsesY++;//moving forward
if(YB_SIG==0)
pulsesY;//moving reverse

attachInterrupt(4, YA_RISE, RISING);
}

void YB_RISE(){
detachInterrupt(5);
//delay(1);
YB_SIG=1;

if(YA_SIG==1)
pulsesY++;//moving forward
if(YA_SIG==0)
pulsesY;//moving reverse

attachInterrupt(5, YB_FALL, FALLING);
}

void YB_FALL(){
detachInterrupt(5);
//delay(1);
YB_SIG=0;

if(YA_SIG==0)
pulsesY++;//moving forward
if(YA_SIG==1)
pulsesY;//moving reverse

attachInterrupt(5, YB_RISE, RISING);
}

This sketch is based on Kevin Darrah’s rotary encoder tutorial, if you’re interested in a detailed explaination.

Then go to “File”->“Save” and name it “KinoWheelsSketch” or anything you like. (5) Next click  the arrow button in the upper left to it to upload it to your Arduino. It will say “Done Uploading” if successful.

Now let’s see if the sketch works! (6) Go to “Tools”->”Serial Monitor” to see the output the Arduino is now sending to your PC. Make sure to select a baud rate of 115200 in the drop-down menu in the lower right. This rate was set in the sketch and it defines at which rate information is transferred back and forth between the Arduino and your PC. If they don’t match you’ll get garbled text as result. You should now see “x0.00y0.00end” being printed to the screen repeatedly.

Connecting the rotary encoders

The following section can look a bit overwhelming if you have never had anything to do with electronics. Don’t worry though, we’ll go through it carefully step by step and it is actually not difficult at all.

Breadboard 101

Before we start, let’s take a look at the breadboard on which we will build the circuit. Understanding how this works will help you troubleshoot if you accidentally wire up something incorrectly. A breadboard is a tool to prototype circuits without needing to solder the connections. Pictured is a breadboard with 400 tie points, but you can use any size you like. There’s a bus strip on each side consisting of two rows (red/blue): One is for connecting the supply voltage, one for ground. The tie points of each individual line are connected internally. They are not connected to the inner tie points. Those are arranged in columns that are separated in the middle. The green lines in the second picture illustrate which tie points are internally connected on the breadboard. So if hook up a power source to a tie point, all points that are on the same green line are connected to this power source.

A breadboard with 400 tie points

Internal connection of tie points (green lines)

The wiring

Now we will build the circuit to connect the rotary encoders to the Arduino. First make sure you have disconnected the Arduino from your computer. It should never be connected to a power source while working on the wiring! It’s advisable to use color-coded jumper wires as it makes it easier to keep track of the connections.

(1) Place the Arduino and the breadboard in front of you like in the picture. (2) Connect the 5V pin of the Arduino to the red power rail and one of the GND pins to the blue power rail. Then make a connection from the red power rail to the tie point J7.

(3) In the next step we place the resistors on the breadboard: Two resistors connect to the power on column 7 and their other ends connect to columns 4 and 10. From there the other two resistors connect to columns 1 and 13. Remember the internal connection of the breadboard? You don’t have to use the same placement on the breadboard only make sure the circuit stays the same. To keep things neat, you can clip the wire ends of the resistors with your wire-cutter, so they’ll sit flush on the breadboard when connected to the tie points.

(4) The yellow jumper wires are now used to connect PIN 18 to tie point J13 and PIN 19 to tie point J1.

(5) This step is for keeping things tidy, but you could skip it and connect the rotary encoder directly if you are short on jumper wires. The connections are: Ground to E13 (black), 5V to E9 (red), F10 to E5 (white) and F4 to E1 (green).

(6) Now you only have to match colors of the jumper wires to the wires coming out of the rotary encoder and connect each to the corresponding column.

(7) Repeat all steps for the tilt axis. It’s the same circuit, but the connection to the Arduino is on PIN 2 and PIN 3 this time.

(8) It should look like this when you’re finished.

The moment of truth

It’s time to connect the Arduino to your PC again. Open the serial monitor of the Arduino IDE and start turning the shafts of the rotary encoders. You should now see the values changing. Clockwise rotation should increase the value of the corresponding axis, counter-clockwise rotation should decrease it. If it doesn’t work, don’t panic: Double check each and every connection you made on the breadboard. Most likely you’ve just made a tiny mistake somewhere.

Congratulations! If you made it this far, you’re already past the complicated parts of this tutorial.

Mounting the mechanical components

In this part we will attach the rotary encoders to the handwheels. If you got the same mechanical parts as listed above, this is fairly easy. Even if you plan to build a housing, we’d recommend mounting everything to a wooden board first. This way you can test everything and plan the housing in detail before making potentially costly mistakes.

On geared heads you usually operate the tilt with your right hand and the pan with your left hand. So the the handwheel for tilting faces the operator while the handwheel for panning is on the left at a 90° angle. Repeat the following steps for both axes.

After you’ve mounted the first bearing (to the wooden board or your housing), (1) insert the rotary shaft into it and tighten the two screws to keep it place (3mm Allen key). The 14mm part of the shaft faces outside and you can now push on the handwheel. (2) To keep it in place use the thumb screw and a washer. (3) Attach the rotary encoder to your bracket. We’ve simply used a steel angle from the hardware store and mounted the encoder with two M3 screws. (4) Push the 6mm coupling onto the rotary shaft and tighten the two screws (1.5mm Allen key). (5) Now insert the shaft of the rotary encoder into the other side of the coupling and also tighten it. Most likely the rotary encoder and its bracket will now float in the air. Depending on the height it might be enough to use a couple of washers to level it. Be careful when screwing it tight and make sure it is leveled as good as possible and in a straight line with the axis of the rotary shaft.

Balancing the handwheels

If you have used a geared head before you might have noticed that the handwheels are balanced, so they won’t rotate after you stop them. The handwheels we are using will not stay in place when the handle is attached. Gravity will kick in and the handle will always end up at the bottom. Unfortunately finding balanced wheels at a reasonable price seemed to be impossible, so we do it ourselves: If you are using the same hand wheels we did, you need 55 grams of counterweight to balance out the handle. It’s quite easy: (1) Cut the adhesive strips apart into single 5 gram weights and (2) start placing them on the back of the wheel opposite to the handle. (3) After attaching eleven pieces the wheel is balanced.

Building a housing

Mounting everything on a wooden board is enough to start practising and if you’re on a budget you can stop here. But if you made it this far you probably want to package everything neatly and build some sort of housing.

We decided to put everything in an outdoor case which also has room to store the hand wheels for transportation. It’s a bit bulky, so if you have access to a 3D printer, designing your own housing might be an option too.

The finished housing.

A look into the case.

Step by step

(1) Start by planning carefully, you will regret rushing this. Place all parts inside to get an idea and try to figure out if everything will have enough room. Also make sure the hand wheels are at the right height so they can spin freely once attached. (2) Drill the holes at the hand wheel positions with the step drill bit. Heads up: The case now isn’t waterproof anymore 😉 (3) Cut the wooden boards to size and (4) drill holes in the bottom of the case for the screws that will hold everything in place. (5) Paint the boards if you like. (6) Place the bearings and rotary encoders and adjust the height with washers. Mount the Arduino board and connect it to the encoders. (7) Drill another hole for the USB connector  on the back of the case and attach the cable to the Arduino board. (8) Add some foam here and there to cushion the wheels for transport. (9) And that’s it!

It’s a wrap!

Congratulations, you made it! Now you can use your Kino Wheels with our free simulator or do whatever you’ve set out to do with them! We’re curious what you come up with so please post your build to our Facebook page or tag your photos on Instagram with #kinowheels.