The fritzing schematic above depicts the circuit we used for testing the Wild Thumper Chassis’ motors, batteries, ultrasonic sensors, headlight L.E.D.s, servo driver along with servos, the motor shield along with the six motors driving the rover, and the Bluetooth module.
Earlier testing showed us that the Arduino Mega that we are using would leave us with plenty of unused pins, so we contemplated switching micro- controllers to the Arduino Uno. But after more experimentation we found the need for a servo driver to drive our pan and tilt system. We also found the need of digital pins to control the headlight L.E.D.s, communication pins for the Bluetooth module, and control pins for the ultrasonic sensors. Because of these needs, we determined that it would be best if we kept using the Arduino Mega.
As you can see from the fritzing diagram, the VHN5019 motor shield utilizes a little more than half of the Mega’s pins in order to drive the motors. So we decided to make another custom PCB shield that would serve to drive the HC-06 Bluetooth Module, the HCSR-04 ultrasonic sensors, the L.E.D. headlights, and the PCA9685 servo driver.
Breadboard:
The photo above depicts the circuit we used for testing the ultrasonic sensors, the servos, the Bluetooth module, the motor shield, and the servo driver.
Charging Circuit:
For our charge control circuit, we chose to use the Black Menba 20A 12V/24V Solar Charge/ Panel Battery Controller. We chose this solar charge controller because our initial charge controller design proved to be inoperable after thorough testing.
For our L.E.D. headlights, we chose to use the 6 Piranha 5V Led Light Panel Board. For this decision, we had only two factors: price and brightness. These L.E.D.s proved to be very bright meeting our expectations and making sure we met one of our requirements of aiding the pathfinder with lighting.
Qianyi Tang (CSULB Computer Science Major Graduate Student)
Table of Contents
Introduction:
In our Project Tango system block diagram, one of the software module is to develop Bluetooth API in the Point Cloud App command sequence. This blog post is to show the approach of modifying point cloud App to pair and connect another device to Tango tablet through Bluetooth while still running Point Cloud.
Steps:
Download and install Android Studio and Tango SDK
Download the Point Cloud sample code and import it into Android Studio
Connect the Tango tablet to the PC and enable the Android Debugging Bridge (ADB)
Build and run the Point Cloud sample code. This would automatically install the App in Tango tablet
Open project → app → Java → PointCloudActivity.java
Open project → res → layout → activity_jpoint_cloud.xml
Open project → res → values → strings.xml
Breakdown and modify the code
The download instruction and links can be found here:
Add the following code to “activity_jpoint_cloud.xml”
/******/
<Button android:id=“@+id/bluetooth_button” android:layout_width=“100dp” android:layout_height=“wrap_content” android:layout_above=“@+id/first_person_button” android:layout_alignParentRight=“true” android:layout_marginBottom=“5dp” android:layout_marginRight=“5dp” android:paddingRight=“5dp” android:text=“@string/bluetooth” />
/******/
The code above will generate a button on the screen called”bluetooth” with the width of 100 dp(density-independent pixles). The “bluetooth” button will be placed above the “first_person_button” in the point cloud App.
This declares Bluetooth adapter and store the list of paired Bluetooth devices. The last line is to store the state of Bluetooth(on/off) because the button can be used as a switch. By initial, it is set to off.
Add one line below:
/******/
BA = BluetoothAdapter.getDefaultAdapter();
/******/
This will assign the BluetoothAdapter.
Now go down to public classes, Add the following code:
/********/
public void bluetoothOn(){ if (!BA.isEnabled()) { Intent turnOn = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); startActivityForResult(turnOn, 0); Toast.makeText(getApplicationContext(),”Turned on”,Toast.LENGTH_LONG).show(); visible(); } else { Toast.makeText(getApplicationContext(),”Already on”, Toast.LENGTH_LONG).show(); } }
/********/
This creates a function “bluetoothOn()” to turn on Bluetooth device and toast a message (“Turned on” or “Already on”).
/********/
public void bluetoothOff(){ BA.disable(); Toast.makeText(getApplicationContext(),”Turned off” ,Toast.LENGTH_LONG).show();
}
/********/
similarly, this creates a function “bluetoothOff()” to turn off Bluetooth device and toast a message “Turned off”
Next add the following lines below:
/********/
public void visible(){ Intent getVisible = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); startActivityForResult(getVisible, 0); }
/********/
This will alter the Bluetooth device into visible state.
Continue adding these lines of code:
/********/
public void list(){ pairedDevices = BA.getBondedDevices(); ArrayList list = new ArrayList();
This creates an array and add paired devices into list.
Finally, incorporate the main function:
/********/
@Override public void onClick(View v) { switch (v.getId()) { case R.id.first_person_button: mRenderer.setFirstPersonView(); break; case R.id.third_person_button: mRenderer.setThirdPersonView(); break; case R.id.top_down_button: mRenderer.setTopDownView(); break; case R.id.bluetooth_button: if(bluetoothFlag == false){ bluetoothOn(); bluetoothFlag = true; }else { bluetoothOff(); bluetoothFlag = false; } default: Log.w(TAG, “Unrecognized button click.”); } }
/********/
This will create the click event handler. Based on different click event,it will switch viewer’s perspective and turn on/off Bluetooth device. In Bluetooth button section, this function will switch adapter between on/off.
This is what the App will looks like after the modification. Notice the Button shows upon on the screen.
Modifying an existing Android App could be difficult since it requires good knowledge of Java Programming language as well as understand Android Studio platform. In this approach, I first did research and learn the basic Android App development and Java programming on Udacity website. Then I start modifying code in Point Cloud Existing App but unfortunately I crushed the App over and over again. After we got the Project Tango system block diagram from professor Hill, I start researching into Android Bluetooth API and trying to implement existing bluetooth sample code into the Point Cloud activity. Finally I successfully debug and run the modified App but the button itself does not work properly. After trying to debug the code, I found out that I need assistant from someone who develop the point cloud App to let me know where the breakpoints goes since I lost track of the breakpoints when stepping into the code.
This blog post does not show the fully functional Point Cloud App with Bluetooth feature, but can be documented and used as a good resource for individuals or groups from future class to continue developing the Java Point Cloud App.
https://www.arxterra.com/wp-content/uploads/2016/04/rsz_id5w5dkk.png7272peiyuanxu93/wp-content/uploads/2013/04/Arxterra-Logo-340x156.pngpeiyuanxu932016-05-02 17:37:412018-03-13 21:57:37Spring 2016 Pathfinder: Project Tango Bluetooth API
The objective of this test is to be able to send data from Android OS (Java, android studio) to the Arduino via Bluetooth. We use a simple open source code found on github to see if we can send data to the Arduino. The mission of this experiment is to move us closer to sending data from the Google tango (the Google tango is an Android OS device, therefore it uses java/Android studio) to the Arduino via Bluetooth.
Tools:
Android Studio
Arduino IDE
Bluetooth Module (we used the HC-06)
Arduino Uno / Mega
LED
Breadboard
Android Phone with usb cord.
LED Test Java Code:
The Java code that is on github should work when you import it to Android studio. After importing the code into android studio, you have to wait and let android studio build the project. This will take from seconds to minutes. Once the gradle has been built, you can run the app. Before you run the app, you have to make sure your android phone is in debug mode (if you don’t know how to get it to debug mode, just google it with your version of phone) so you can connect it to android studio. Once your phone is connected to android studio, you can run it and choose your phone so the app can be on your phone. When have the app on your phone, then you need to go to the Arduino code. If you want to know more about the code, I suggest that you read and run through the code yourself to get an idea of how this app works.
The Arduino code is also on github. It is at the bottom of this page here. Just copy and paste it to Arduino ide. Once you have it, go through the code so you know where to connect everything on the Arduino. Once you have connected everything the right way, verify the code and upload it to your Arduino. (Note: There are sometimes problem uploading code to the Arduino when the Bluetooth module is connected on the Arduino at the same time it is uploading. So to get over this problem, simply just take the Bluetooth module out before uploading the code and put it back on when the code has successfully been uploaded to the Arduino.)
The first LED is connected to pin 9 and ground. The second LED is connected pin 2 and ground. The third LED is connected to pin 3 and ground. The RX on the Bluetooth module is connected to pin 11 and the TX is connected to pin 10. On the picture above, the button “Light Up” were pushed and as you can see, all the LEDs lit up.
Results:
When you have both the Java code and Arduino code, you should be able scan and find your Bluetooth module on the app. Once connected, turn on the LED lights by sliding the bars to the right or pressing all light up. Below is a picture showing how it should look like when you are lighting up the LED. In the end, we were able to send data from java to Arduino via Bluetooth. To take this a little further, we successfully move our pathfinder prototype with the app.
Changing just bits and pieces of the code, we were able to make the rover go forward, backwards, and turn. The java code that was changed was only the button name. The main change that made our rover move was changing the Arduino code. We sent the data to the motors instead of LED.
Making the LED App Control Motors:
The main thing that we changed in this code was the serial port, and adding the motor shield code. We changed the serial port that we use to send data to the Arduino. Since we are using the Arduino Mega, we use serial port 2 instead of pins 10 and 11 as above. In the first LED case, we made the rover go forward. The second LED made our rover turn right and the third LED made it go in reverse. On the Java code side, we didn’t change anything from the code, we just changed names of LED1, LED2, and LED3 to forward and reverse.
The the code highlighted below is what was changed from the code given in the link above. These code were added so we can move the motors of our pathfinder.
#include <SoftwareSerial.h>
#include <stdio.h>
#include <DualVNH5019MotorShield.h>
DualVNH5019MotorShield md;
int ledONE = 2;
int ledTWO = 9;
int ledTHREE = 4;
int bluetoothTX = 11 ;
int bluetoothRX = 10 ;
char receivedValue ;
SoftwareSerial bluetooth ( bluetoothTX, bluetoothRX );
void setup()
{
Serial2.begin(9600);
Serial2.println(“console> “);
pinMode(ledONE, OUTPUT);
pinMode(ledTWO, OUTPUT);
pinMode(ledTHREE, OUTPUT);
// bluetooth.begin(115200);
// bluetooth.print(“$$$”);
// delay(100);
// bluetooth.println(“U,9600,N”);
// bluetooth.begin(9600);
}
void loop()
{
int brightness = 0;
int led = 0;
signed int data = 0;
//if( bluetooth.available() )
if (Serial2.available())
{
//data = (int) bluetooth.read();
data=(int) Serial2.read();
Serial2.println( data ); // for debugging, show received data
if(data == 26)
{
allDown() ;
}else if(data == 89)
{
allUp() ;
}else{
led = data / 100; // which led to select ?
brightness = data % 100 ; // 0 – 25 , LED brightness ( * 10 ) for actual value
switch(led) // Now, let’s select the right led.
{
case 0 : setLEDthree ( brightness * 10 ); break;
case 1 : setLEDone ( brightness * 10 ); break;
case 2 : setLEDtwo ( brightness * 10 ); break;
default : setLEDthree ( brightness * 10 ); break; // DO NOT know what to do ? must be led 3
}
}
//bluetooth.flush(); // IMPORTANT clean bluetooth stream, flush stuck data
void setLEDtwo(int brighteness) // turn rover to the right
{
int m1Speed = brighteness; // left motor
int m2Speed = -brighteness ;// right motor
md.setSpeeds(m1Speed, m2Speed);
//analogWrite(ledTWO, brighteness*16 ) ;
}
void setLEDthree(int brighteness) // move rover in reverse
{
int m1Speed = -brighteness; // left motor
int m2Speed = -brighteness ;// right motor
md.setSpeeds(m1Speed, m2Speed);
//analogWrite(ledTHREE, brighteness*16 ) ;
}
Conclusion:
In conclusion, we were able to send data to the Arduino from Android OS via bluetooth. We then tried to control the our motors by changing up the code to light up LEDs to control the left and right motors on the pathfinder. The next step is to implement this code to the Google tango point cloud app and see if we can extract the depth and send it to the Arduino.
https://www.arxterra.com/wp-content/uploads/2016/04/rsz_id5w5dkk.png7272peiyuanxu93/wp-content/uploads/2013/04/Arxterra-Logo-340x156.pngpeiyuanxu932016-05-02 17:36:092018-03-13 21:57:37Spring 2016 Pathfinder: Project Tango Module#5 – Android to Arduino Via Bluetooth
Google tango tablet can perform depth perception by using point cloud app, however, the source code of point cloud app is written in Java with different modules. This blog post assumed the reader has no experience in Java programming, yet they can still extract data out from point cloud app. Paraview is an program on PC that offers alternate method to manipulate point cloud data, while the other method would involve changing the Google tango Source code.
Paraview and VTK:
Paraview is a program run on the foundation of C, python, and Java language. Paraview version 4.01 was design for google tango project. VTK (Visualization Toolkit) is used to create digital filter in order to exclude any unnecessary point cloud data gather by Paraview.
For reference of how to set up Paraview on both PC and Tango tablet, see here
Testing Results:
The above picture is a screenshot of Paraview Tango Recorder App. On the left side, There is a scroll button “record” that can be turned on and start recording the point cloud image.
Then turn on the “Auto Mode” button, it will start scanning the area and capturing point cloud images. The “Take Snapshot” button will only take one image.
Once the “Record” button turned off, the app will save the files in VTK format and send them via Bluetooth or through Wi-Fi to emails or Google Drive. In order to process the data on PC, we choose to save to Google Drive and then import the files to Paraview program.
In the Paraview program, you can 3D view the point cloud data. if you record the data in “Auto Mode”. you can enable the animation view and see the video. Paraview has some build in filter that you can use to filter out the point cloud data, however, most of the filter applications are designed for 3D indoor mappings. Next step for us is to research into VTK library and learn to build our custom filter to filter out the irrelevant data and only leaves a single point or an area that we are interested.
Task for future semester
After paraview and VTK filter all points, the specific point needed to be transferred to Arxterra app. Arxterra app will use the depth information from point cloud to drive pathfinder.
This code filters the pixels to make white sphere and green background. The idea of this approach is trying to use the image processing and filtering method to get the point cloud data we want and on some level avoid Java Programming and modifying the point cloud app.
https://www.arxterra.com/wp-content/uploads/2016/04/rsz_id5w5dkk.png7272peiyuanxu93/wp-content/uploads/2013/04/Arxterra-Logo-340x156.pngpeiyuanxu932016-05-02 17:31:142018-03-13 21:57:38Spring 2016 Pathfinder: Project Tango – Interactive Visualization of data from Tango using Paraview
Tuong Vu (Electronics & Control – Sensors, Actuators and Power)
Table of Contents
Introduction:
This blog post will be explaining the total current drawn from the batteries by the motors. The amount of currents drawn from the batteries are resulted of the wheels experiencing at different friction forces. Different friction forces correlated to different terrains that the pathfinder traveled on. For example, rocky or sandy terrains required the pathfinder to exert more torque on its wheels in order to move which corresponds to more current being drawn from the batteries. The friction force is much larger on sandy or rocky terrains compare to smooth cement terrains. The more currents being drawn by the pathfinder lead to shorter batteries life (refer the previous blog post about batteries life).
Test procedure:
Components:
R.S.E.717 Multimeter
Samsung S7 cell phone
Motors : Pololu motors
Using the DMM in series with the motors shield would allow currents drawn from the batteries by the motors to be observable. As the pathfinder conducts its route, collecting the currents being drained from the batteries is an issue. A smartphone was attached in the back of the pathfinder to record the currents being drawn from the batteries as the pathfinder goes through its route.
Current drawn:
Moving back and forward do not require high amount of pressure on the wheels which current was drawn was the low, refer to figure.1.
Figure 1
Turning left and right required more than the average current drawn,so the battery life is shorter, refer to figure 2.
Figure 2
Different load & road environment :
Torque is the ( N*M) as N is the force and M as mass of the total load. Amps is the current drawn by the motors. As the pathfinder undergoes a route through rocky terrain, more torque is required to turn its wheels. Travelling on rocky terrain deplete the batteries much faster than travelling on smooth surface, current drawn from the motor is linear proportional to the motor torque, refer to figure 3.
Figure 3
Conclusion:
The amount of currents drawing from the batteries is related to the terrains that the wheels of the pathfinder travels upon. Rocky and sandy terrains require the pathfinder to exert more torque on its wheel in order to move which corresponds to more current being drawn from the batteries,so turning left and right draw more current than going forward and backward.
https://www.arxterra.com/wp-content/uploads/2016/03/rsz_result1.jpg7272peiyuanxu93/wp-content/uploads/2013/04/Arxterra-Logo-340x156.pngpeiyuanxu932016-04-25 18:28:262018-03-13 21:57:38Spring 2016 Pathfinder: Current Drawn Test
As previously detailed in the Spring 2016 Pathfinder Design and Manufacturing – Tilt System Design blog post, the tilt system will contain a base that will hold the tablet, phone, and tilt servo.1 While a prototype of this base has already been designed, it was around the measurements of the pan servo as the tilt servo had not yet been acquired. This report will serve to document the new tilt system base as designed around the measurements of the new tilt servo. Also mentioned will be the addition of cord holes in the previous design. Note that the final product will be constructed of 3D printed, ABS plastic parts.
Google Tango Tablet Encasement Improvement
In view of one of Pathfinder’s Level 1 requirements, an enclosed environment for a Google Tango tablet was designed.2 However, this design did not take into account the fact that the tablet will need to be continuously charging, as it has a shorter battery life then our Project’s required duration.3 Therefore, the position of the charging port was documented, and a cut-out was added to the previously designed tablet box.
Tilt Servo Measurement Process
In order to redesign the tilt system for the new servo, the servo first had to be measured and modeled. To begin with, the tilt servo’s basic dimensions (height, width and depth) were measured. Below illustrates the depth measurement as an example.
Note that with the servo horn, the depth is 1.744in (illustrated below), and with the fan attachment, it is 1.881in.
Similarily, multiple height and width measurements were taken as needed from varing reference points.
Next, the diameter of the servo horn was measured and found to be .236in.
The placement of the servo horn was based on the midpoint of the circle it is located on. Note that this circle has the same diameter as the width of the servo.
To assist in the tilt servo mounting design, the position of the screw flaps were also measured. These included the distance from the edge of the screw flaps to the other side of the screw holes, the thickness of the screw flaps (illustrated below) and the distance of the screw flaps from the back of the servo.
Lastly, the position of the power and controlling cord was documented to allow for a cord hole to be added to the previous design.
Following a similar process to the one demonstrated above, combined with a few calculations where needed, the servo fan was dimensioned as well.
Completed Tilt Servo and Fan 3D Model
For size and position reference, the above parts were modeled in Solidworks.
Tilt Servo Base Measurement Process
Combining the modeling process of the tilt servo detailed above, with the previous design of the tilt system base1 the previous base was modified to accommodate the new tilt servo. While a variety of measurement calculations were performed, only the main few will be detailed below.
To start with the tilt servo’s total depth of 1.881in meant that the tilt system base width changed from its original width of 10.98in to 11.19in.
The position of the servo horn changed the height of the servo encasement box supports from 4.29in to 4.98in.
To allow for proper mounting of the tilt servo, the original base design was modified to give room for the servo’s mounting screws. This was done by thinning the front of the servo support strut and servo encasement lid in alignment of the servo’s mounting flaps, as dimensioned above, so that screw holes can be drilled there later.
Next the position of the tilt servo’s cord was noted and a hole was added to the bottom of the servo encasement box.
Note that in view of the final selection of LED headlights,4 the previous tilt system base’s headlight holder design was removed. A safe adhesive method will be used for the future design.
Lastly, to accommodate the size of the 3D printer Spring 2016’s Pathfinder will be using, the design of the tilt system base was cut in half and a square connector bracket was added to connect the two pieces.
Conclusion and Future Plans
In conclusion, Spring 2016 Pathfinder’s new tilt system has been modified to fit the new tilt servo and to account for charging cords that are required by components of the system. LED mounting will be detailed after the new tilt system has been fabricated.
Juan Acosta (Electronics & Control – MCU Subsystem & Firmware)
Table of Contents
Introduction:
One of our requirements is to have the Pathfinder explore the CSULB campus at night. In order for us to accomplish this objective, we will need a way of maintaining a visible line of sight for the Tango Tablet and Android Phone. So we decided that we would give the Pathfinder bright headlights that would allow us to see a maximum of 4 meters or about 12 feet ahead of the pathfinder.
Materials:
HC-06 bluetooth Module
Ar 2560 or Arduino UNO
Jumper Wirduino MEGAes (4)
6 Piranha 5V Led Light Panel Board White Night Lights Lamp Super Bright (2)
Laptop with Coolterm application
Fritzing Schematic and Steps:
Wire GND of the HC-06 to GND on the arduino
Wire VCC of the HC-06 to 5V on the arduino
Wire RXD of the HC-06 to TX0 on the arduino
Wire TXD of the HC-06 to RX0 on the arduino
Wire 5V of the LEDS to PIN52 on the arduino
Wire GND of the LEDS to GND on the arduino
Upload arduino code provided. (Notice: Be aware that the HC-06 must be unplugged while uploading code to the arduino, otherwise you may run into functionality issues.)
Initially you will have to pair the HC-06 with the laptop through bluetooth (Password for HC-06: 0000 or 1234)
Manually control the LEDS through Coolterm by sending a ‘0’ for off, or ‘1’ for on.
Arduino Code:
// The following code was written, tested and debugged by Juan Acosta for
// testing the LED Headlights operation using the HC-06 to implement commands
// being sent from the COOLTERM application from a laptop or phone to the arduino.
// Group: Pathfinder Spring 2016
// Electronics and Control: Juan Acosta (MCU Subsystem and Control Firmware)
pinMode(52,OUTPUT); // initialize pin 52 as output for LED Headlights
Serial.begin(9600); // set the data rate for the Serial Port
}
char a; // stores incoming character from other device (phone, tablet, or laptop)
void loop() {
if (Serial.available()){ // if text arrived in from hardware serial…
a=(Serial.read());
if (a==’1′){
digitalWrite(52,HIGH); // turn the LED Headlights on (HIGH is the voltage level)
}
if (a==’0′){
digitalWrite(52,LOW); // turn the LED Headlights off
}
if (a==’?’){
Serial.println(“Send ‘0’ to turn LED Headlights on”);
Serial.println(“Send ‘1’ to turn LED Headlights off”);
}
// you can add more “if” statements with other characters to add more commands
}
}
Video Demonstration
Conclusion:
We were able to meet the requirement of having a distance of at most 4 meters or 12 feet lit up. These LED lights will definitely help illuminate the path for the pathfinder as it traverses through CSULB at night. Even though these LED lights are super bright, they should not be relied on as the primary source of lighting aid, we are using these in conjunction with the lighting from all the lamp posts around campus. After we confirmed that the LED Headlights were working through bluetooth, we can then transfer what we applied over to arxterra so we can control the LED Headlights through the arxterra control panel through custom commands.
This spring 2016 Pathfinder project will use Google’s Project Tango as a platform to test and implement SLAM (Simultaneous Localization and Mapping) technology for autonomous vehicles. Project Tango uses computer vision to give device the ability to know the position in the relative 3D space as well as the distance from the surrounding objects to the device itself.
Physical Description
The Tango tablet has a physical dimension of 119.77 x 196.33 x 15.36mm.
The weight is 0.82 lbs (370g)
On the back of the tablet, it has a fisheye camera placed in the middle with an IR projector on the right and a RGB-IR camera on the left. The IR projector and RGB-IR camera work together with IMU (Inertial Measurement Unit) sensors to perform the features of Motion Tracking, Depth Perception and Area Learning.
Key Features
Motion Tracking
The IMU is used to give feedback on the device orientation and spatial displacement from a reference point. The Motion Tracking feature is usually achieved by integrating readings from orthogonally placed gyroscopes, magnetometers, and accelerometers.
Tango’s Depth perception can provide feedback on distances between the device and nearby solid objects. Tango uses an approach called structured light sensing where a pattern of light is cast and the size and shape of the pattern seen by the camera is used to determine the distance.
Tango’s Area Learning feature helps with motion tracking by correcting drift and helps with navigation of indoors applications. It uses image processing of visual features in a virtual environment to recognize a previously-visited location.
The IR sensors for depth perception is generally restricted to indoor environments (sun and incandescent IR light can drown out structured light sensing). Therefore, in order to accomplish the requirements for both solar panels implementation (under direct sunshine) and Tango applications (without sunshine), the mission course is changed to be at CSULB campus during night time.
Range of IR sensors practically limits its use to nearby obstacle detection rather than long-range path creation. The range of the IR sensor is from 0.5 meters to 4 meters based on Project tango’s website.
Power Test For Tango Tablet
The purpose of this test is to gain the power specs while running point cloud App, screen on, bluetooth on, WiFi on for worst case.
The result shows that it takes about 2 hours and 16 minutes to run the battery from fully charged (100%) to 14%. In which case, it dose not meet our level 1 requirement of running for 4 hours. Also it is recommended to use a high-power 2A USB hub to charge the Tango Tablet.
Therefore, in order to meet the level 1 requirement, an extra portable charger (Power output: 5V, 2A) with Micro USB cable will be used to charge Tango tablet continuously during the mission.
Notice that Project Tango offers APIs in C and Java, and a SDK for Unity. For developers who are already familiar with Android studio and Java development, the Java API is the one to use. Developers who want to be able to write apps with the Android NDK (Native Development Kit) should use the C API, which enables more flexibility on the native and system level. The Unity SDK is good for game development in 3D virtual environment.
Once you have downloaded the sample code and successfully installed the App. you will see a window like this:
This is the Point Cloud version of a person standing in the Hallway. On the top left, It states that “Average depth(m): 4.352” which means that person is about 4 meters away from the tablet.
On the right side, there are 4 buttons. The first “Bluetooth” button is the custom button that I made in order to connect the tablet to Arduino through BlueTooth while running the Java Point Cloud App. Below the “Bluetooth” button, there are the three buttons that can switch from different orientation and give different point of view of the Point Cloud data.
After we have done that, now it is important to understand how the system should work between Project tango and Arduino and then eventually implement the software modules on Arxterra.
Project Tango System Block Diagram
Above is the Project Tango System Block Diagram that provided by Professor Hill. The diagram is divided into two parts. In the Android Operating system, commands will be sent by Arxterra to WiFi Manager API and decoded in Tango Android OS. Then the main point cloud App will process the coordinates and position information from Sensor Event API and Tango XYZij structure and send feedback telemetry back from WiFi Manager API to Arxterra. In the Arduino part, Java Point Cloud App will send command sequence through bluetooth to UART subsystem decoder and then to Arduino board. Then the microcontroller (Arduino mega) will send serial read/write to command decoder to command handler and then to GPIO to control the Ultrasonic sensors, H-bridge motors and servos. From that, our team develop the software modules and tasks breakdown to accomplish the system design.
Software Modules and Task Breakdown
Module 1: Sending commands to WiFi Manager API (Through “cool term”)
Module 2: WiFi Manager API sending telemetry out to Arxterra
Module 3: Tango SDK or NDK (Translate XYZij to Tango)
Module 4: SensorEvent API (IMU)
Module 5: BlueTooth API to HC-06 Module to Arduino
Module 6: Arduino to HC-06 to BlueTooth API
Module 7: Arduino Command Decoder to Command Handler
Module 8: Arduino Command Handler to GPIO Output to Motors and Servos Control
Module 9: GPIO Input to Telemetry Send Packets to UART Receiving Subsystem to Android OS
Module 10 Java App Command Sequence Development
More on IMU and Coordinate System
Module 3 requires to understand the IMU (Inertial Measurement Unit) and Project Tango Coordinate Frames. The links below explain the Tango Coordinate System Conventions
Module 10 requires knowledge of processing point cloud data. This may be as easy as importing a library and using the defined classes/methods for data manipulation.
The PCL (Point Cloud Library) and ROS (Robot Operating System) are both open sources that offers libraries and tools to analyze point cloud data. Many companies and developers are working on building application with PCL or ROS for Project Tango. Some useful Tips and tutorials can be found here:
The use of Project Tango tablet is ambitious since it is fairly new and requires extensive knowledge of Android App development and Java Programming. In this semester, our team is able to attempt and finish some of the Project Tango modules, that includes “BlueTooth API to HC-06 Module to Arduino (Blinking LED and Motors Control)”, “Extract Point Cloud Data from Tango and process with Paraview software”. We will have upcoming blog posts to explain and show the steps of how these modules can be done. We hope the research work we have here can benefit the future groups or individual who wants to continue work on Project Tango.
Based on the requirements from the customer, the pathfinder must be able to self – charge its batteries using solar panels. This document explains the requirement for the solar panels and physical implementation based on batteries. The customer wants the pathfinder to be able to run for four hours and self-charge for eight hours. Our mission required the pathfinder to navigate around CSULB with the assistance of Google Tango Tablet.
Batteries:
The Batteries from older design are being used in order to power the motors system, pan and title system, and sensor system. These Batteries are Gens ace 7.4V 10000mAh Pd Based on the the test we conducted, these batteries are sufficient to support the pathfinder for the mission. The pathfinder draw an average of 1.43A while operating at full load in moving forward and backward, turning left and right, and stopping. Equation .1 shows the total time the pathfinder can operate with these batteries.
A DMM is measuring the average current drawn by the motors when the pathfinder is conducting a forwards, backwards, stop, and start maneuvers.
Calculation:
According to the batteries that we planning to use, the current supplied by the solar panels must be about 640 mA to charge our batteries from 0V, batteries are drained,to 7.4V. Fortunately, the batteries will never be totally drained to 0V, but our solar panel are adequate to charge the batteries from 1V to 3.2 V within 8 hours refer to equation 2 and equation 3.
Solar Panel:
Requirement:
12 Voltage
700 mAh
· ECO-WORTHY 10W Solar Panel 10 Watt 12 Volt PV Solar Module, Solar Cell Panel
Pathfinder will utilize both two NPower Amorphous Solar Panel Battery and ECO-WORTHY 10W Solar Panel 10 Watt 12 Volt PV Solar Module as its charging mechanism, and the total current supply by the solar panels is about 640 mA ( max). Modifying the solar panels placement on the pathfinder to resemble the Arxterra logo; allow the pathfinder to be more efficient in obstacle avoidance.
Image.1 Arxterra Logo
( Solar Panel Configuration will closely resemble the Arxterra Logo to reduce collisions)
The goal of Spring 2016’s Pathfinder is to harbor a Google Tango tablet, phone, solar panels, pan and tilt system and self-contained electronics.1 To support this a rocker bogie suspension system2 will be used. As a purchasable rocker bogie suspension system could not be found to fit the size requirements of the tilt system design3 the suspension system will be built from scratch. This report shall document the design process.
Rocker Bogie Suspension System Design
To start with, a general design for the rocker bogie suspension system (hereafter referred to as suspension system) needed to be selected. To guarantee that basic proportions were kept, ServoCity’s Bogie Runt Rover4 was used as a model. To fit the requirements mentioned in the introduction, this model will be simplified and doubled in size.
Rocker Bogie Suspension System Measurement Process
ServoCity’s Bogie Runt Rover consists of six part types that require Solidworks modeling for Spring 2016’s Pathfinder design. To obtain accurate dimensions the individual parts were measured with digital calipers.
Placement and dimension of screw holes were also measured.
These measurements were then marked on rough sketches to allow for easy reference for the Solidworks model.
Where necessary, simple calculations were done to translate the digital caliper’s measurements into dimensions Solidworks requires.
For parts that were difficult for the digital calipers to measure, trace marks were made on paper and measurements were taken from there.
Rocker Bogie Suspension System Model Alterations – Size
After measuring and modeling all of the parts required for the suspension system design, a thickness needed to be selected. To start with, .25in was used, as this was the thickness in the original Runt Rover design. From there, the Solidworks model was doubled in size. The thickness however, was kept at .25in.
Material Selection
Now that the suspension system parts are completely modeled, a material needed to be selected for their fabrication. ABS plastic and aluminum were considered. While ABS plastic has a density of .0376 lb/in^3, compared to aluminum’s density of .0983 lb/in^3,5,6,7 the 3D printers available to Spring 2016’s Pathfinder at this time are not large enough to print the suspension system’s enlarged parts. Therefore, the suspension system will be made out of aluminum.
Rocker Bogie Suspension System Model Alterations – Simplification
To assist in the fabrication process, the suspension system parts will be simplified. As the aluminum fabricator currently available to Spring 2016’s Pathfinder is limited to drilling holes and cutting straight edges, the parts will be squared off where necessary. Their crucial measurements however, will be kept the same.
Rocker Bogie Suspension System Weight and Strength Check
Having modeled all of the parts, the next step was to check the weight and strength of the system as a whole. By setting the material of the parts in Solidworks, the weight of a part can be obtained. Alloy 6061 was used, as it is both a commonly used type of aluminum, and can be welded.
Above specified the weight of the swivel bar (the part illustrated in the previous section). Following this procedure for all of the parts, the total weight of the suspension system totaled 10.65lbs for .25in thick aluminum, and 5.34lbs for .125in thick aluminum.
Keeping the weight in mind, the strength of the legs and top plate were then calculated. Stress and bending distances were solved for and listed in the below two charts respectively.8
Note that the length used for the legs (17.89) was found by calculating the diagonal of the 10.84in by 14.23in rectangle illustrated below.
While all three thicknesses considered passed the stress test (it takes 6061 alloy aluminum 40,000psi to misshape beyond repair9) the amount each thickness would bend in the legs ranged from .6 to 4.7 inches. To compromise between the weight, stress, and bending tolerance, a thickness of .1875 was selected for the final design.
Conclusion and Future Plans
In conclusion, Spring 2016’s Pathfinder will consist of a rocker bogie suspension system where all parts are simplistically modeled after ServoCity’s Bogie Runt Rover and their measurements follow the procedure documented above. The material used will be alloy 6061 aluminum of thickness .1875in. The complete suspension system is illustrated and dimensioned below and in the future will hold a pan and tilt system, electronics enclosure box, and solar panels on it’s top surface.
