Category Archives: DIY Projects

World’s cheapest speaker!

https://www.youtube.com/watch?v=WTWe3OcD7u4

What do you need to make the simplest form of a speaker? Surprisingly, you probably already have everything you need! Click on the “Parts list” tab to see what you need to make both bone conducting headphones and your own speaker! Then, if you still want more, click on the “Further Learning” tab to learn more about the history of speakers!

 


Help support my channel by becoming a patron!

 

Get social!

 

Here’s what you will need for these projects:

 

 

Bone Conducting Headphones

  • Small DC Motor
  • An old pair of headphones

Cheap Speaker

  • A Paperclip
  • A business card
  • A strong magnet
  • An old pair of headphones

Learn more about the history of speakers!

Beginners Guide To Projection Mapping

https://www.youtube.com/watch?v=skU3T8bgEIM

366_projection_mapping_thThis video will show you how the basics of projection mapping and how to do it on the cheap!

Here’s what you will need:

Projectors:

Amazon $60 projector

Build One from Recycled Parts

Build One for $5 worth of parts

TOTAL COST: ~$60.00 or less

Installing and Configuring VPT7

  1. VPT7
  2. Beginners Guide Tutorial

Projection Mapping Examples:
Pomplamoose “Happy Get Lucky” – https://www.youtube.com/watch?v=i7X8ZnmLfM0

LG Electronics Building Projection – https://www.youtube.com/watch?v=gy_jyxoWj5c

Audi A1 Car Projection – https://www.youtube.com/watch?v=x4sVTUAdoLg

Help support my channel:

http://www.patreon.com/tinkernut

Follow Tinkernut!

Google +

Facebook

Twitter

Make Your Own Cluster Computer

https://www.youtube.com/watch?v=1R0UgIgcb5g

Learn how to make a cluster computer using Raspberry Pi’s! You can also use this method to build your own super computer.

Acquiring the Parts
Here’s what you will need:

  1. 2 or more Raspberry Pi’s
  2. SD cards for each Pi
  3. Power Cables for each Pi
  4. Powered USB Hub (optional)
  5. Networking Cables
  6. A Hub or a Router

TOTAL COST: ~$100.00 [tabby title="Software"]

Installing and Configuring Raspbian

  • Download the Raspbian Image from here.
  • Burn the Raspbian Image to your SD Card
  • Once the image is burned to your SD Card, but it into the Raspberry Pi and boot it up with a Keyboard, Mouse, Monitor and Internet attached.
  • Upon first boot, you should see the Rasbperry Pi Configuration screen (otherwise type “sudo raspbi-config“. Here’s the options we’ll need to configure
      • Expand the File System
      • If needed, set the Internationalization options to match your countries keyboard layout.
      • Overlcock the Pi to 800 Mhz
      • Advanced Options
        • Set the Hostname to Pi01
        • Split the memory to 16mb for graphics
        • Enable SSH
      • Finish out of the configuration, but don’t reboot yet
      • To enable auto-login, at the terminal command type “sudo nano /etc/inittab
        • Comment out this line: #1:2345:respawn:/sbin/getty --noclear 38400 tty1
        • And add this line right beneath it: 1:2345:respawn:/bin/login -f pi tty1 </dev/tty1 >/dev/tty1 2>&1
      • Now you can reboot your Pi and it should auto-login

[tabby title="Terminal Commands"]

Installing MPICH

  • MPICH is software that allows for multi-processing communication between computers.
  • To install it on your Raspberry Pi, first make sure you have a valid Internet connection going to the Pi. Then follow these Terminal Commands
    • sudo apt-get update
    • mkdir mpich2
    • cd ~/mpich2
    • wget http://www.mpich.org/static/downloads/3.1/mpich-3.1.tar.gz
    • tar xfz mpich-3.1.tar.gz
    • sudo mkdir /home/rpimpi/
    • sudo mkdir /home/rpimpi/mpi-install
    • mkdir /home/pi/mpi-build
    • cd /home/pi/mpi-build
    • sudo apt-get install gfortran
    • sudo /home/pi/mpich2/mpich-3.1/configure -prefix=/home/rpimpi/mpi-install
    • sudo make
    • sudo make install
    • nano .bashrc
      • PATH=$PATH:/home/rpimpi/mpi-install/bin
    • sudo reboot
    • mpiexec -n 1 hostname
  • These commands will download and install MPICH, as well as add it as a path to your BASHRC boot file. The last command runs a test to see if it works. If the last command returns “Pi01″, then you did everything successfully.

Installing MPI4PY

  • As it is, MPICH can run C and Fortran programs. But since the Raspberry Pi has the Python coding environment pre-installed, it would be easiest to install a Python to MPI interpreter. Here’s the commands to do that:
Help support my channel: http://www.patreon.com/tinkernut Follow Tinkernut! Google + Facebook Twitter

Arduino Motion Detecting Squirt Gun

https://www.youtube.com/watch?v=bSz4FQPsir8

In case you want a nerdier way to make a cheap motion detecting squirt gun, Here’s how you can build your own with an Arduino and a PIR sensor!

Acquiring the Parts
Here’s what you will need:

  1. Raid Auto Trigger
  2. Arduino
  3. PIR Motion Sensor
  4. Diode
  5. NPN Transistor
  6. Wire cutters and wire

TOTAL COST: ~$45.00

Disassemble the Automatic Sprayer
Wire Up The Arduino
Here is a schematic of the Arduino. You can download the Fritzing files by clicking on this link. Screen Shot 2014-03-29 at 3.15.19 PM [tabby title="Step 3"]

Add The Code
Here is a copy of the Arduino code to upload to your arduino. You can also download it by clicking on this link. const int pirPower = 13; const int pirIn = 12; int motorPin1 = 3; void setup(){ pinMode(pirPower, OUTPUT); pinMode(pirIn, INPUT); pinMode(motorPin1, OUTPUT); digitalWrite(motorPin1, LOW); digitalWrite(pirPower, HIGH); } void loop(){ int value= digitalRead(pirIn); if (value == HIGH){ digitalWrite(motorPin1, HIGH); delay(500); digitalWrite(motorPin1, LOW); } }

Help support my channel: http://www.patreon.com/tinkernut Follow Tinkernut! Google + Facebook Twitter

Motion Detecting Squirt Gun Prank

https://www.youtube.com/watch?v=T7zxvW7MZac

In this April Fools day video, learn how to make a cheap motion detecting squirt gun using parts that you can find in your local grocery store!

If you want a geekier way to build a motion detecting squirt gun, check out the Arduino version of this same project.

Acquiring the Parts
Here’s what you will need:

TOTAL COST: ~$25.00

Disassemble the Air Freshner
Disassemble the Automatic Sprayer
Connect the Air Freshner to the Automatic Sprayer
Help support my channel: http://www.patreon.com/tinkernut Follow Tinkernut! Google + Facebook Twitter

Control An RC Car With A Smartphone

[tabby title="Video Walkthrough"]
Learn the basics of controlling objects with your Smartphone through Bluetooth!


[tabby title="Parts List"]

Acquiring the Parts
Here’s what you will need:

TOTAL COST: ~$30.00

[tabby title="Step 1"]

Adding Bluetooth to the Arduino

  1. To get started on adding bluetooth to the Arduino, you can watch my Arduino Bluetooth Basics Tutorial
  2. For a wiring diagram, you can reference my Fritzing sketch. (You need to download Fritzing
    in order t. view this.)

    h-bridge-wiring

[tabby title="Step 2"]

Software

Android

  1. To find your bluetooth’s MAC address, a good program to use is called Ardudroid on the Google Play store.
  2. To control the car, Tolik777 has created a great app that you can download from here and install on your Anrdoid device.

Arduino

  1. The first thing you need to to is download the Arduino software for your computer.
  2. Then you need to copy this code to a new sketch and upload it to your Arduino device. Code provided by
 
#include "EEPROM.h"

#define D1 2          // direction of motor rotation 1
#define M1 3          // PWM left motor
#define D2 4          // direction of motor rotation 2
#define M2 5          // PWM right motor
#define HORN 13       // additional channel 1
//#define autoOFF 2500  // milliseconds after which the robot stops when the connection

#define cmdL 'L'      // UART-command for left motor
#define cmdR 'R'      // UART-command for right motor
#define cmdH 'H'      // UART-command for additional channel (for example Horn)
#define cmdF 'F'      // UART-command for EEPROM operation
#define cmdr 'r'      // UART-command for EEPROM operation (read)
#define cmdw 'w'      // UART-command for EEPROM operation (write)

char incomingByte;    // incoming data

char L_Data[4];       // array data for left motor
byte L_index = 0;     // index of array L
char R_Data[4];       // array data for right motor
byte R_index = 0;     // index of array R
char H_Data[1];       // array data for additional channel
byte H_index = 0;     // index of array H
char F_Data[8];       // array data for  EEPROM
byte F_index = 0;     // index of array F
char command;         // command

unsigned long currentTime, lastTimeCommand, autoOFF;

void setup() {
  Serial.begin(9600);       // initialization UART
  pinMode(HORN, OUTPUT);    // additional channel
  pinMode(D1, OUTPUT);      // output for motor rotation
  pinMode(D2, OUTPUT);      // output for motor rotation
  /*EEPROM.write(0,255);
  EEPROM.write(1,255);
  EEPROM.write(2,255);
  EEPROM.write(3,255);*/
  timer_init();             // initialization software timer
}

void timer_init() {
  uint8_t sw_autoOFF = EEPROM.read(0);   // read EEPROM "is activated or not stopping the car when losing connection"
  if(sw_autoOFF == '1'){                 // if activated
    char var_Data[3];
    var_Data[0] = EEPROM.read(1);
    var_Data[1] = EEPROM.read(2);
    var_Data[2] = EEPROM.read(3);
    autoOFF = atoi(var_Data)*100;        // variable autoOFF ms
  }
  else if(sw_autoOFF == '0'){        
    autoOFF = 999999;
  }
  else if(sw_autoOFF == 255){
    autoOFF = 2500;                      // if the EEPROM is blank, dafault value is 2.5 sec
  }
  currentTime = millis();                // read the time elapsed since application start
}
 
void loop() {
  if (Serial.available() > 0) {          // if received UART data
    incomingByte = Serial.read();        // raed byte
    if(incomingByte == cmdL) {           // if received data for left motor L
      command = cmdL;                    // current command
      memset(L_Data,0,sizeof(L_Data));   // clear array
      L_index = 0;                       // resetting array index
    }
    else if(incomingByte == cmdR) {      // if received data for left motor R
      command = cmdR;
      memset(R_Data,0,sizeof(R_Data));
      R_index = 0;
    }
    else if(incomingByte == cmdH) {      // if received data for additional channel
      command = cmdH;
      memset(H_Data,0,sizeof(H_Data));
      H_index = 0;
    }   
    else if(incomingByte == cmdF) {      // if received data for EEPROM op
      command = cmdF;
      memset(F_Data,0,sizeof(F_Data));
      F_index = 0;
    }
    else if(incomingByte == '\r') command = 'e';   // end of line
    else if(incomingByte == '\t') command = 't';   // end of line for EEPROM op
    
    if(command == cmdL && incomingByte != cmdL){
      L_Data[L_index] = incomingByte;              // store each byte in the array
      L_index++;                                   // increment array index
    }
    else if(command == cmdR && incomingByte != cmdR){
      R_Data[R_index] = incomingByte;
      R_index++;
    }
    else if(command == cmdH && incomingByte != cmdH){
      H_Data[H_index] = incomingByte;
      H_index++;
    }   
    else if(command == cmdF && incomingByte != cmdF){
      F_Data[F_index] = incomingByte;
      F_index++;
    }   
    else if(command == 'e'){                       // if we take the line end
      Control4WD(atoi(L_Data),atoi(R_Data),atoi(H_Data));
      delay(10);
    }
    else if(command == 't'){                       // if we take the EEPROM line end
      Flash_Op(F_Data[0],F_Data[1],F_Data[2],F_Data[3],F_Data[4]);
    }
    lastTimeCommand = millis();                    // read the time elapsed since application start
  }
  if(millis() >= (lastTimeCommand + autoOFF)){     // compare the current timer with variable lastTimeCommand + autoOFF
    Control4WD(0,0,0);                             // stop the car
  }
}

void Control4WD(int mLeft, int mRight, uint8_t Horn){

  bool directionL, directionR;      // direction of motor rotation L298N
  byte valueL, valueR;              // PWM M1, M2 (0-255)
  
  if(mLeft > 0){
    valueL = mLeft;
    directionL = 0;
  }
  else if(mLeft < 0){
    valueL = 255 - abs(mLeft);
    directionL = 1;
  }
  else {
    directionL = 0;
    valueL = 0;
  }
 
  if(mRight > 0){
    valueR = mRight;
    directionR = 0;
  }
  else if(mRight < 0){
    valueR = 255 - abs(mRight);
    directionR = 1;
  }
  else {
    directionR = 0;
    valueR = 0;
  }
   
  analogWrite(M1, valueL);            // set speed for left motor
  analogWrite(M2, valueR);            // set speed for right motor
  digitalWrite(D1, directionL);       // set direction of left motor rotation
  digitalWrite(D2, directionR);       // set direction of right motor rotation
  
  digitalWrite(HORN, Horn);           // additional channel
}

void Flash_Op(char FCMD, uint8_t z1, uint8_t z2, uint8_t z3, uint8_t z4){

  if(FCMD == cmdr){           // if EEPROM data read command
    Serial.print("FData:");       // send EEPROM data
    Serial.write(EEPROM.read(0));     // read value from the memory with 0 address and print it to UART
    Serial.write(EEPROM.read(1));
    Serial.write(EEPROM.read(2));
    Serial.write(EEPROM.read(3));
    Serial.print("\r\n");         // mark the end of the transmission of data EEPROM
  }
  else if(FCMD == cmdw){          // if EEPROM data write command
    EEPROM.write(0,z1);               // z1 record to a memory with 0 address
    EEPROM.write(1,z2);
    EEPROM.write(2,z3);
    EEPROM.write(3,z4);
    timer_init();             // reinitialize the timer
    Serial.print("FWOK\r\n");         // send a message that the data is successfully written to EEPROM
  }
}

[tabby title="Links"]

Follow Tinkernut!
Google +
Facebook
Twitter
[tabbyending]

 

Arduino Bluetooth Basics

[tabby title="Overview"]
This video will show you the basics of controlling an Arduino through bluetooth. Click the “Step” tags for a walkthrough!


[tabby title="Step 1"]

Acquiring the Parts
Here’s what you will need:

  • A Bluetooth Capable Smartphone (I’ll be using an Android).
  • An Arduino ($10.99)
  • An Arduino Bluetooth Module ($6.45)
  • An LED ($0.99)

[tabby title="Step 2"]

Wiring

You can download the Fritzing sketch here.

Screen Shot 2014-03-08 at 7.38.33 PM

[tabby title="Step 3"]

Software

Android

A good Android program for Arduino is called Ardudroid on the Google Play store.

 

Arduino

 
int ledPin = 13; 
int state = 0;
int flag = 0; 
 
void setup() {
 pinMode(ledPin, OUTPUT);
 digitalWrite(ledPin, LOW);
 
 Serial.begin(9600); // Default connection rate for my BT module
}
 
void loop() {

 if(Serial.available() > 0){
 state = Serial.read();
 flag=0;
 }

 if (state == '0') {
 digitalWrite(ledPin, LOW);
 if(flag == 0){
 Serial.println("LED: off");
 flag = 1;
 }
 }

 else if (state == '1') {
 digitalWrite(ledPin, HIGH);
 if(flag == 0){
 Serial.println("LED: on");
 flag = 1;
 }
 }
}

[tabby title="Links"]

Follow Tinkernut!
Google +
Facebook
Twitter
[tabbyending]

 

How To Find Free Wifi

This video shows you some common tips for never being wifi-less again!

 

[tabby title="Overview"]
This video shows you some common tips for never being wifi-less again!


[tabby title="Steps"]
Websites and apps for finding free wifi

[tabby title="Links"]

Follow Tinkernut!
Google+
Facebook
Twitter

[tabbyending]

 

How To Make A Reverse Geocaching Puzzle Box

https://www.youtube.com/watch?v=qhX3N6YhPRM

A “[Reverse Geocaching Puzzle Box]” is an electronic puzzle box developed by [Mikal Hart]. It runs primarily off of an Arduino along with a handful of peripherals. This episode covers how to acquire and assemble the parts needed for the Puzzle Box as well as customizing and installing the software to run it.

 

If you’ve never heard of [Geocaching], it’s an outdoor activity where participants use a GPS to find and hide containers known as “Geocaches”. These containers normally contain some kind of trinket or memorabilia. So as you can imagine, “Reverse Geocaching” is where you have the container with you the whole time, and you have to take it to a specific location GPS coordinates in order to open it. In essence, it stays locked unless you’re standing in the right place.

Parts List

The price of this project depends on what you already have available and where you purchase your items. All in all, you can probably complete this project for less than $100. I’ve listed all of the required parts below as well as some cheap places to purchase them.

Reverse Geocaching Shield Version 1.0

Part name Price
Some type of Box $0
GPS Adapter $29
LCD Screen (2 x 8) $6
Push Button $4
Small Servo $4
Arduino Uno $10
Reverse Geocaching Shield Kit $32
Battery Terminal $2
8 x 2 Ribbon Cable $4
4 wire jumper cable $3

 

 

Building The Hardware

Putting together all of the electronics to make this box work requires a soldering iron and some basic soldering skills. Assembling the box could require a [Dremel], or other wood working tool. The core of this project revolves around the Arduino and the Reverse Gecaching shield. A “ shield” is essentially an electronics board that connects on top of an Arduino and extends it’s functionality. In this case, the RG shield easily connects the Arduino to the GPS, button, LCD and servo. Essentially 75% of the build involves assembling the RG shield.

Assembing the RG Shield

If you purchased the RG Shield kit, then as long as you have soldering skills, this should be pretty easy.

Fully assembled RG shield + Arduino

  1. Break the header (straight) pins so that they line up with the pins on the Arduino. Go ahead and place them into the Arduino with the long ends down.
  2. Place the RG Shield so on top of the Arduino so that the header pins slide into place and then solder the top of each pin to the shield.
  3. Break off 2 rows of 8 header pins and solder them into the corresponding holes onto the bottom of the RG board.
  4. In version 1.0 of the shield, there are 3 electronic components: 2 capacitors and 1 resistor. Match each component to it’s corresponding shape on the RG shield and solder them into place.
  5. Break off 4 right-angle pins and solder them, facing outward, to the bottom of the corresponding holes in the RG board.
  6. Break off another 3 right-angle pins and solder them, facing outward, to the bottom of the corresponding holes in the RG board.
  7. Find the GPS connector and position it where it belongs on the RG board and very carefully solder it into place, taking extra care not to solder the connector pins together.
  8. Solder some header pins to the top of the RG board where the 5v boost belongs.
  9. Place the 5v boost on top of those header pins and solder it into place.
  10. Solder some header pins to the top of the RG board where the regulator switch belongs.
  11. Place the regulator switch on top of those header pins and solder them into place.
  12. Lastly, solder the red and black wires from the battery terminal to the RG board. Ensure that the + and – wires are in the correct holes.

Other Miscellaneous Electronic Assembly

Button Wiring Diagram

  1. The LCD screen requires minimal assembly. Break off 2 rows of 8 header pins and solder them to the corresponding holes on the LCD screen.
  2. The 4-wire jumper cable needs to be connected to the button. You have to connect them in the wires to the proper terminals on the button as seen in the diagram to the right.
  3. The servo needs to be modded so that it can lock the box you have chosen to use. This can be any of an unlimited amount of options, so just use the option that works best for you.

Assembling the Box

Finished Reverse Geocaching Box

The Reverse Geocaching box can essentially be any type of box, so long as it can house all of the required electronics and a payload. It can be a wooden box, a metal box, an old lunch box, etc. There are a few things to keep in mind when creating a box. First, make sure that it can have the capability of being locked from the inside using the servo. Second, make sure you can cut out a portion of the box top in order to attach the LCD and button. Third, after all the electronics are inside the box, ensure that there is enough room for some type of payload or gift. And fourth, make sure that the Arduino is positioned so that it’s easy to plug into the computer without having to remove everything.

Software

Since this project runs off of an Arduino, you will need to download the [Arduino software] in order to load the Reverse Geocaching program onto it. It’s available for Windows Mac and Linux machines. Once you have it downloaded and installed, you can also [download an example program] for the Reverse Geocaching box from the Sundial website. Unzip it and then open up the extracted files into the Arduino program. You should see the code as well as some comments from Mikal Hart. The code by itself should work fine as is, but if we click the Verify button on the Arduino program, it’ll throw back errors regarding the PWMServo and tinyGPS libraries. Here’s how to fix those errors.

Installing Libraries

When it comes to code, libraries are a compiled set of commands that perform specific functions. For instance, if you want to control a servo but don’t want to write all the detailed code yourself, you can download a servo library and use that libraries pre-coded commands. This program requires two libraries to be installed: [PWMServo] and [TinyGPS].

Both links to those libraries will provide a way to download them in zipped files. After you have them downloaded and unzipped, you want to move the entire library folder to the library folder of your Arduino installation, normally located in your Documents > Arduino folder path. After moving them, you will need to restart your Arduino program before any changes take effect. If you need more help on isntalling Arduino libraries, the Arduino website has a [good guide].

Adjusting the lock settings

Once restarted, you should be able to click Verify to verify the code and the code should pass. So now we can start customizing the code. The first thing to look at is the Open and Closed angles of the servo.

static const int CLOSED_ANGLE = 90; 
static const int OPEN_ANGLE = 165; 

These will need to be adjusted so that your servo properly locks and unlocks the box. It will most likely take several tries to get this right. So make an adjustment, upload the code, let the code run through to see if it works, if not, adjust the angles more.

Setting the location

Immediately beneath the servo settings is the GPS coordinate settings.

static const float DEST_LATITUDE = 48.8469;
static const float DEST_LONGITUDE = -2.9986;

The DEST_LATITUDE and DEST_LONGITUDE values tell where the box can be opened. How do you determine the latitude and longitude coordinates for your destination? The easiest way is by going to [Google Maps] and finding the destination location on the map. Then right click on that location and select What’s here. This will show the latitude and longitude coordinates respectively in the search bar at the top of the maps page. Then just copy those values to your code.

Editing the LCD Messages

The next bit of customizable code is about halfway down the program. It starts with the attempt counter and then displays a message in Msg(lcd, format.

  /* increment it with each run */
  ++attempt_counter;

  /* Copyright notice */
  Msg(lcd, "HELLO", "EXPLORER", 1500);

  /* Greeting */
  Msg(lcd, "Welcome", "to your", 2000);
  Msg(lcd, "puzzle", "box!", 2000);

  /* Game over? */
  if (attempt_counter >= DEF_ATTEMPT_MAX)
  {
    Msg(lcd, "Sorry!", "No more", 2000);
    Msg(lcd, "attempts", "allowed!", 2000);
    PowerOff();
  }

Any of these items can be edited. The format is Msg(lcd, “‘First line’”, “Second line’”, delay time);. Keep in mind that each line on the screen is only 8 characters long.

Adding Clues

Along with displaying messages, you can also display different clues for each time the user presses the button. To do this, you want to create a new line of code similar to the code below. And you want the attempt_counter variable to be set equal to it’s corresponding clue. The attempt counter keeps track of how many times the user has pressed the button. If the user presses the button 1 time, it will show this code, which is the first clue. If you wanted to display a second clue, then you would set the attempt_counter to equal 2 and then change the display message to show the second clue.

  /* First Clue */
  if (attempt_counter == 1)
  {
    Msg(lcd, "Clue #1", "Bridge", 2000);
    PowerOff();
  }

Uploading the code

Once you have customized the code, the next step is to upload it to the Arduino. Assuming that the Arduino is already in your Reverse Geocaching Box, make sure that you have all batteries removed before connecting it to your computer. After you’ve connected it, go to Tools > Board and select your Arduino Board type and then go to Tools > Serial to select the USB port that it’s connected to. Now just click the Upload button on the program window and wait for it to upload to the Arduino. When it’s through, it should run through the code so you can see how it works. Then make any adjustments you need to and re-upload the code. After that, unplug the Arduino from your computer and insert the two AA batteries. Then insert your payload/gift, lock the box and give it to a friend!