Archive for category: Bipedal Robots

By Vinh-Khoa Ton, Control and Image Processing

The purpose of this experiment is to access the Arxterra control panel and to operate an Arduino board using the Microbridge connection through an Android phone.

For information about the Microbridge connection between Android and Arduino, please visit this blog post:
https://www.arxterra.com/simple-control-of-an-arduino using-an Android-phone/

A quick demonstration:
https://www.youtube.com/watch?v=D_rMULcm6uc&feature=youtu.be

How to set it up:
Use the schematic

The LEDs are on pins 2, 3, and 4 and the servo is on pin 5. The USB Host Shield v2.0 was needed for communication between the Android phone and the Arduino Duemilanove ATMega328.

Upload the Arduino code to the board (provided at the end of this post).

Open the ArxRobot app on Android phone and set up the connection with Arxterra, use the Microbridge connection type (for detail instructions please see Tommy’s powerpoint here:

http://csulb.edu/~hill/ee400d/Lectures/12_Arxterra%20Login.pptx)

Connect the Android and Arduino using a micro-USB cable (the app should have a command “socket client connected”)

In this example I created 3 custom commands (3 switches) to control 3 LEDs.

Log-in to Arxterra using the same credential that was used to connect to ArxRobot app.

Go to the control panel:

At this point, the connection should be established. If we move a LED switch, the corresponding LED should turn on/off accordingly. If we hit a move button, the servo should respond accordingly.

Conclusion:
This experiment serves an important part in building a solid foundation for the final connection between our robot and Arxterra. After we successfully grasp the concepts of the communication between Android and Arduino, we can proceed to replace the move servo function with more complex movements to suit our need. The only limitation of what it could do is our imagination.

Arduino Code:
https://github.com/kh0/Spring-2014-ROFIA/blob/master/ROFIACode/ArduinoControlWithArxterra

By Vinh-Khoa Ton, Control and Image Processing

The purpose of experiment is to become familiar with the way an Android phone communicates with an
Arduino board using MicroBridge, an Android Debug Bridge (ADB) implementation for microcontrollers.
[Insert Android-Arduino.jpeg]

How it works:
The ADB protocol can either create a new shell or use the existing shell on an Android phone to send commands, read debugging logs, and forward TCP ports and Unix sockets. The Android phone reads data from a port that Arduino is connected to through the ADB. When a connection is lost (the application crashes, the USB cable is unplugged, etc), MicroBridge will try to reconnect to the device upon redetection.

Compatibility:
MicroBridge is designed to work with Android phones with version 1.5 and above. The following phones are confirmed to be compatible: ZTE Blade, Nexus S, Samsung Galaxy S, HTC Desire HD, HTC Nexus One, and LG Eve. A quick demonstration:
http://youtu.be/cX8whgZkdzk

How to set it up:
Using the schematic

The LEDs are on pins 2, 3, and 4. The USB Host Shield v2.0 was needed for communication between the Android phone and the Arduino Duemilanove ATMega328.

Some prerequisites:
Download Android SDK at http://developer.android.com/sdk/index.html
Download ADB library at: https://code.google.com/p/microbridge/downloads/detail?name=MicroBridge-Arduino.zip&can=2&q
Download Arduino code and Android app at: https://github.com/mitchtech/android_adb_simple_digital_output

A look into the Arduino code:
void setup()
{
   int i;
   for (i = 0; i < LEDcount; i++)
{
   pinMode(i+2,OUTPUT); // Set pins as output
   LEDState[i] = 0; // Init state to 0
}
// Init serial port for debugging
Serial.begin(57600);
// Init the ADB subsystem.
ADB::init();
// Open an ADB stream to the phone’s shell. Auto-reconnect. Use any unused port number, eg:4568
   connection = ADB::addConnection(“tcp:4568”, true, adbEventHandler);
}
void loop()
{
// Poll the ADB subsystem.
ADB::poll();
}
void adbEventHandler(Connection * connection, adb_eventType event, uint16_t length, uint8_t * data)
{
// In this example Data packets contain three bytes: one for the state of each LED
if (event == ADB_CONNECTION_RECEIVE)
{
int i;
for (i = 0; i < LEDcount; i++)
{
   if(LEDState[i] != data[i])
   {
    digitalWrite(i+2, data[i]); // Change the state of LED
    Serial.println(data[i],DEC); // Output debugging to serial
    LEDState[i] = data[i]; // Store the State of LED
   }
  }
 }
}

We need to create a connection to the ADB streams and receive events when connecting, disconnecting, or receiving data. We initialize the ADB in the Setup function by calling “ADB::init();”.

In the Loop method, we must sequentially poll the ADB layer by calling “ADB::poll();”

These 2 calls are the minimum requirements for establishing and maintaining a connection to our Android phone. Next, we want to open a connection with the phone by calling “connection = ADB::addConnection(“tcp:4568”, true, adbEventHandler);”. The first parameter “tcp:4568” forwards local TCP port to the Arduino. The second parameter “true” indicates whether the reconnection should be handled automatically. The third parameter is a callback method which functions as an event handler, which defines what events need to be triggered. We need to implement the event handler function to receive data from the shell. This function has the following parameters: connection, adb event, payload length, and payload data. In this example, we are trying to read command data from the Android phone to control the Arduino so we need to specify the “event == ADB_CONNECTION_RECEIVE”. In this example the data package contains 3 bytes according to 3 LEDs outputs. The nested code in the if statement determines which LED lights up.

Conclusion:
The MicroBridge is a simple solution that allows communication between an Android phone and an Arduino board. With this experiment, we take a first step in getting familiar with the ADB protocol. This allows us to expand our Arduino projects with more capabilities such as remote control of our robots with a friendly user interface instead of having to upload the code manually, or utilizing the built-in gyroscope, camera, and accelerometer of the Android phone for external sensors for our robots.

Sources:
http://mitchtech.net/android-arduino-usb-host-simple-digital-output/

By Kevin Huynh, Project Manager / Computer Systems and Software

Objective:
For Spring 2014, one of the requirements for the biped is to add in some form of servo overcurrent protection. The goal of this is to prevent the servos from drawing too much current, overheating, and destroying the control circuit boards inside of the case. A situation where this can happen is when the servos are stalled from reaching their desired position, but they continue to draw the maximum current possible–2.3 A at 4.8 V for the Power HD1501 MG servos from the following datasheet:
http://www.pololu.com/file/0J729/HD-1501MG.pdf

The LiPo battery pack used for ROFIA is the Turnigy 1300 mAh 2S 20C LiPo pack, found below:
http://www.hobbyking.com/hobbyking/store/__9165__turnigy_1300mah_2s_20c_lipo_pack.html

This battery pack can easily supply 2.3 A for all twelve of the servos if they were all to stall at the same time.

The above calculation shows the LiPo battery pack can safely and continuously deliver up to 52 A to the servos for about 3 minutes, which is more than enough to supply the stall current to all of the servos simultaneously (27.6 A).

Possible Solutions:
The two methods that were considered for servo overcurrent protection were foldback current limiters and resettable fuses.

Solution Chosen for the Biped:
The resettable fuses were chosen for their low cost, simplicity of implementation, and because the specifications needed were easier to find on a polyfuse than a foldback current limiter IC. The drawbacks of the polyfuses can be mitigated by replacing the polyfuses as they trip by inserting the polyfuses into female headers soldered onto a protoshield, rather than soldering the polyfuses themselves. Since the stall current of the Power HD 1501MG servos is 2.3 A at 4.8 V, the 06R120BU Littelfuse was chosen.
http://www.mouser.com/ProductDetail/Littelfuse/06R120BU/?qs=sGAEpiMZZMsxR%252bBXi4wRUCTGuoKQj3D%2fwUhoRMyepPw%3d
http://www.mouser.com/ds/2/240/Littelfuse_USBR-36712.pdf

The main specification that was taken into consideration when choosing a polyfuse was the trip current. Since the stall current of the Power HD 1501MG servo is 2.3 A at 4.8 V, the polyfuse trip current was chosen to be 2.0 A. This ensures that the polyfuse will trip before the servo can reach the stalling current and damage itself. Other specifications, such as the hold current and maximum voltage, were satisfactory for the biped. The hold current rating of 1.2 A is well below the stalling current, so it is a safe operating current for the Power HD 1501MG servos. Since the output voltage of the UBEC is approximately 5.3 V and the operating voltage of the servos range from 4.8 V to 6.0 V, the polyfuse maximum voltage rating of 6 V is acceptable. The connections between the LiPo battery, UBEC buck converter, polyfuses, and servos are shown below. The servo pulse pins connect to digital pins on an Arduino Mega ADK.

By Vinh-Khoa Ton, Control and Image Processing

The purpose of this ultrasonic sensor examination was to determine the range and angle of the sensor detection. The ultrasonic sensor will be used as the eyes of ROFI and ROFIA for the purpose of avoiding obstacles. The Seeed Studio Ultrasonic Ranger v1.0 was the device chosen for this examination.

Examination Setup:
An Arduino ATMega328 was used to test the sensor. The connections between the ultrasonic sensor and Arduino are shown below.

The sensor was set at approximately 30 cm, the height of the robot. The sensor was placed on a hard and flat surface to ensure stability during the test. A black binder was used as an obstacle for easy angle adjustment (1 side is fixed and 1 side is adjusted).

The code used for the tests can be found in the dropbox link at the end of this post. The serial monitor, shown below, was used to record the distances at which the sensor detected an obstacle. The LED was programmed to light up if an object was within 30 cm of the sensor.

Detection Angle Testing:
A question that the test was designed to answer was: would ROFI and ROFIA be able to detect an object at their feet? To answer this question, the angle of the adjustable side of the binder with respect with the table was varied from being parallel with the table to being perpendicular with the table.

The highest distance value that the sensor detected for an angled surface was approximately 42 cm and any angle closer to being parallel with the ground resulted in the sensor being unable to detect the binder side.

The highest angle that the sensor could detect was approximately 36 degrees.

Detection Distance and Error Testing:
The sensor was tested with an upright object, as shown in the picture below, placed at different distances. The error between the sensor’s calculated distance and the actual distance was approximately

1 cm.

Conclusion:
The ultrasonic sensor is able to detect objects that are equal to and less than 36 degrees vertically away
from directly in front of it, given that the object is about 27.7 cm as shown in the angle testing section.
The ultrasonic sensor has about an error of 1 cm when detecting objects directly in front of it. The angle
detection brings up an interesting scenario. The ultrasonic sensor would have issues detecting objects
below it following any turning movements. The ultrasonic sensor also has problems detecting flat and
upright objects parallel to its line of sight. For the purpose of the biped project, however, we will be
avoiding these complications and will use it to simply avoid upright objects directly in front of it.

References:
Sensor specifications, background information, and Arduino code can be found here:
http://www.seeedstudio.com/wiki/Ultra_Sonic_range_measurement_module#Introduction

The Arduino code used to test the ultrasonic sensor can be found here:
https://dl.dropboxusercontent.com/u/20231161/Ultrasonic_Sensor_Testing.ino