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 Make A Reverse Geocaching Puzzle Box

[vc_row][vc_column width=”2/3″][vc_separator][venera_framed_image content_type=”video” css_animation=”appear” frame_type=”browser” slider_engine=”flexslider” video_link=”https://www.youtube.com/watch?v=qhX3N6YhPRM” browser_url=”https://www.youtube.com/watch?v=qhX3N6YhPRM”][vc_separator][/vc_column][vc_column width=”1/3″][/vc_column][/vc_row][vc_row][vc_column width=”2/3″][vc_tabs][vc_tab title=”About This Project” tab_id=”1402713028-1-39e9a4-2f888a6d-d37d76d3-94cefaff-ff2c”][vc_column_text]

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.

[/vc_column_text][/vc_tab][vc_tab title=”Parts and Downloads” tab_id=”1402713028-2-39e9a4-2f888a6d-d37d76d3-94cefaff-ff2c”][vc_column_text]

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


[/vc_column_text][/vc_tab][vc_tab title=”Assembly” tab_id=”1402753910272-3-88a6d-d37d76d3-94cefaff-ff2c”][vc_column_text]

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!


[/vc_column_text][/vc_tab][vc_tab title=”Important Links” tab_id=”1402753981900-3-108a6d-d37d76d3-94cefaff-ff2c”][vc_column_text]

Help support my channel:

  1. Donate To My Patreon
  2. Follw Me On Google +
  3. Like Me On Facebook
  4. Follow Me On Twitter
[/vc_column_text][/vc_tab][/vc_tabs][/vc_column][vc_column width=”1/3″][/vc_column][/vc_row]

Urban Survival 101 [Youtube Nextup Collaberation]

This video will show you how to create a fully functioning stove out of junk. To be more specific, we’ll create a grill out of a coffee can, tin foil, a cooling rack, 9v battery and steel wool.


After learning how to make this, check out the Cooking With Jack Channel (www.youtube.com/jakatak69) to learn how to cook on it!


YOUTUBE NEXTUP CREATORS! COLLECT THEM ALL!

www.youtube.com/KidHaru

www.youtube.com/peterhollens

www.youtube.com/Techmaster8

www.youtube.com/Wrenthereaper

www.youtube.com/comediva

www.youtube.com/Cracked

www.youtube.com/emmymadeinjapan

www.youtube.com/Evelinicutza

www.youtube.com/nikkiphillippi

www.youtube.com/MamaNaturalBlog

www.youtube.com/CheckInTheMirror

www.youtube.com/riannstar

www.youtube.com/Cyr1216

www.youtube.com/MrRepzion

www.youtube.com/Soundlyawake

www.youtube.com/xperpetualmotion

www.youtube.com/PrettyMuchIt

www.youtube.com/shep689

www.youtube.com/StrengthProject

www.youtube.com/AVbyte

www.youtube.com/jakatak69

www.youtube.com/PaperPastels

www.youtube.com/gigafide

www.youtube.com/suburbanhomeboy

www.youtube.com/thenivenulls

www.youtube.com/recklessmike

www.youtube.com/JWatson2239

www.youtube.com/Nitrorcx

www.youtube.com/qbanguy

www.youtube.com/WTFfilmsFTW

DIY Arcade Cabinet Using A Raspberry Pi

[vc_row][vc_column width=”2/3″][vc_separator][venera_framed_image content_type=”video” css_animation=”appear” frame_type=”browser” slider_engine=”flexslider” video_link=”https://www.youtube.com/watch?v=LssEe_xx3eI” browser_url=”https://www.youtube.com/watch?v=LssEe_xx3eI”][vc_separator][/vc_column][vc_column width=”1/3″][/vc_column][/vc_row][vc_row][vc_column width=”2/3″][vc_tabs][vc_tab title=”About This Project” tab_id=”1402713028-1-39e9a4-2f888a6d-d37d76d3-94ce”][vc_column_text]

The $35 Raspberry Pi has proven to be a hit amongst hardware hackers and DIYers. It’s very small, easy to set up, and very versatile. This tutorial walks you through the steps of creating and setting up an Arcade cabinet using a Raspberry Pi as the core.


[/vc_column_text][/vc_tab][vc_tab title=”Parts and Downloads” tab_id=”1402713028-2-39e9a4-2f888a6d-d37d76d3-94ce”][vc_column_text]

Parts List

The prices really depend on what you would like to purchase. Depending on what you already have available, it’s possible that you may not have to spend over $50.

Raspberry Pi Arcade

Part name Price
Raspberry Pi $35
Wifi Adapter $17
Ethernet Cable $3
SD Card $6
Powered USB Hub $4
USB Mouse $6
USB Keyboard $5
Monitor (may also need an adapter) $120
USB Joystick and Buttons (optional) $27
Arcade Cabinet Kit (optional) $200-$500
[/vc_column_text][/vc_tab][vc_tab title=”Assembly” tab_id=”1402753910272-3-88a6d-d37d76d3-94ce”][vc_column_text]

Raspberry Pi Setup

Installing the Operating System

There are several different options when it comes to emulators on the Raspberry Pi, but in order to make the Pi function as an Arcade, one stands out amongst the rest. It’s an opensource program called AdvMame and what makes it unique is that it can be used in conjunction AdvMenu to automatically boot to your game directory. The only issue is that it requires a lot of editing and tweaks to get everything to work. Luckily the folks at blog.sheasilverman.com have compiled a version of AdvMame with all the tweaks and edits so that it works specifically for the Pi. It’s called PiMame and can be downloaded and burned to an SD card.

Win32DiskImager

Windows

To install PiMame on an SD card in Windows, you need to download an image burner such as Win32 Disk Imager. After you have PiMame downloaded, you should be able to extract it to view the PiMame.img file. Launch Win32 Disk Imager and under “Image File”, select the PiMame image. For “Device”, select the drive letter for your SD card. Then click “write” to burn the image to the SD card.


Mac

For Mac computers you do not need any extra software. Just download the PiMame zip file and extract it. Insert your SD card and open up a terminal prompt. Type in

df -h

Record all of the “disk” entries that are listed (ex. disks1). Go into your Disk Utility settings and find your SD card and unmount it (not eject). Then go back to your terminal prompt and type df -h again to see which disk is no longer there. The missing one is the disk ID of your SD card. With that in mind, type in this command

sudo dd bs=1m if=~/PATH TO PIMAME/pimame-0.5.img of=/dev/DISK#

where PATH TO PIMAME is the path to where you downloaded the PiMame image and where disk# is set to your SD cards disk number (ex. disks1 = disk1). Executing this command will burn the image to your SD card. When it’s done, you can type

sudo diskutil eject /dev/DISK#

This will eject your SD card.

First Run

Gridlee game splash screen

Once PiMame is installed on your SD card, it’s time to boot up your Raspberry Pi. Make sure that you have a monitor plugged into it as well as the powered USB hub with your USB wireless card, keyboard, and mouse plugged into it. As a pro tip, you can also plug the Raspberry Pi itself into the USB hub since the hub can provide enough juice to power the Pi. The only reason you would need the network cable is in the event that the wireless adapter doesn’t work and you need to download updates in order to get it working.

With the SD card in the Raspberry Pi, turn it on and you should see it boot to the AdvMenu where you will see a game called Gridlee already installed. You can use your keyboard’s number pad and enter key to select the game and play it.

Setting up wireless

The most optimal way for the Arcade cabinet to connect through the internet would be through wireless. But in order to tweak the AdvMame and AdvMenu setup, we need to first get to the command line console. If you are in a game, you can hit Esc on your keyboard and select Exit. This will take you back to the game menu. Then hit Esc again to exit the menu and bring up the command prompt. The newest version of PiMame includes Raspbian, which provides a Graphical User Interface (GUI) that has an easy to use wireless program.

Raspbian Wireless Interface

Making sure that your USB Wifi card is plugged in, type this in to access the Raspbian GUI:

startx

This will launch the user interface in which the mouse will be enabled and can be used. Double click on the Wifi Config icon, which should be on the desktop. This will launch an interface. Click on the Manage Networks tab and select the Enabled radio button to enable wireless. Then you should be able to click scan to scan your area for wireless networks. Find your wireless network, double-click on it and enter in your wireless password. When you have successfully connected, you can logout of the Raspbian GUI session. At this point you can unplug your network cable and your mouse as they will no longer be needed.

Connecting via SSH

With the wifi enabled, the easiest way to work with the Pi is through SSH, which is essentially a way to remote connect to the Pi and run commands on it. Connecting via SSH requires finding the IP address of your Pi. The easiest way to do this is by typing

ifconfig

This brings up your internet connection settings with eth0 being your ethernet connection and wlan0 being your wireless connection. Immediately under your wlan0 connection, you should see the IP address assigned to it (ex. 192.168.1.5). Once you have your IP address, you can connect via SSH.

Tweaking The Software

Adding Joystick Input

If you would like to be able to use joysticks and buttons with your arcade machine, then you will first need to purchase USB enabled joysticks and buttons. Depending on what you get and where you purchase them, the price can range from $25 to hundreds of dollars. When using them, make sure that you have them plugged directly into the powered USB hub, as joysticks sometimes require more power than the Pi alone can provide.

Once you have the joysticks and buttons hooked up and plugged in, we need to enable them within the software, because AdvMame has it turned off by default. So make sure you are at a command prompt and type

sudo nano .advance/advmenu.rc

This will open up the AdvMenu settings as an editable file. Within this file, you want to find the line that says:

device_joystick none

and edit it so that is says

device_joystick auto

Now hit Ctrl X on your keyboard and it will ask you if you want to overwrite the file, hit y for yes and then hit enter to save. You should now be back at the command prompt. At this point, you could restart your Pi by typing:

sudo reboot

It will reboot back into the game menu where you can start the game and see if the joystick functionality works.

Arcade Cabinet Setup

Monitors

When it comes to monitors, just about any will do as long as you have the right adapter. Here you can find an HDMI to VGA and a HDMI to DVI adapter. Those two adapters should account for most monitor connections (including older CRT monitors). The main thing that you need to take into account is the size of the monitor and how it will fit into your arcade cabinet.


[/vc_column_text][/vc_tab][vc_tab title=”Important Links” tab_id=”1402753981900-3-108a6d-d37d76d3-94ce”][vc_column_text]

Help support my channel:

  1. Donate To My Patreon
  2. Follw Me On Google +
  3. Like Me On Facebook
  4. Follow Me On Twitter
[/vc_column_text][/vc_tab][/vc_tabs][/vc_column][vc_column width=”1/3″][/vc_column][/vc_row]

How To Make Smartphone Controlled Christmas Lights


Learn how to make Android or iPhone controlled Christmas lights (or other electronic objects) using a raspberry pi.


Music Synchronized Christmas Lights – https://www.youtube.com/watch?v=KrRczbPg9yg

USB Christmas Lights – https://www.youtube.com/watch?v=Q6NtqO1vou4

Raspberry Pi tutorial – http://www.youtube.com/watch?v=WgcNBjIJNYs

Download Rasbian – http://www.raspberrypi.org/downloads

Download WebIOPi – http://code.google.com/p/webiopi/

SSR Details – http://goo.gl/x74u3