Spring 2017 Mini Pathfinder Final Blog Post

 By: John Her (Project Manager)

Moses Holley (Electronics and Control)

Edgardo Villalobos (Manufacturing-Solar Panel)

Johnathan Chan (Manufacturing-Chassis)

Adan Rodriguez (Mission, Systems, and Test)

Executive Summary

Project Objectives

The Mini Pathfinder project for Spring 2017 is a scaled and modeled after NASA’s 1997 Sojourner rover of the Pathfinder mission. It will utilize the 3Dot board and a custom PCB. It is to be remotely operable with a fully functioning rocker bogie suspension system. It will be able to provide speed and battery telemetry to the user via the arxterra app and have a solar panel that charges the battery.

Mission Profile

Our mission is a scaled version of the Pathfinder project. We will remotely traverse a course of 27.8 meters in length. The course will have 3 stairs it will descend and 3 stairs it will ascend with each stair being 27mm. During this course the Mini Pathfinder will demonstrate electronic differential turning, solar charging, proper rocker bogie mechanics and provide telemetry.

System Design

The Mini Pathfinder will use the 3Dot and a custom PCB for the extra motors and the encoders.

Figure 1. System Block Diagram

Subsystem Design

Modeling Results

Interface Definitions

We have three interface definitions for three different IC’s. The first is for the 3Dot board. The next two are for the custom PCB that will have the two extra motor drivers and the digital io expander for the rotary encoders.

Figure 2. Interface Definitions for the 3Dot Board

Figure 3. Custom PCB IC Motor Driver Interface Definitions

Figure 4. Custom PCB IC Rotary Encoders Interface Definitions

Cable Tree

Our cables will be routed from the motors and encoders through the suspension and into the electronics box. The solar panel will have a mount with a hole where the cable will connect so that it can charge the battery.

Figure 5. Cable Tree

Mission Command and Control

Figure 6.

Figure 7.

Electronics Design

After the trade off studies, we have decided on micro metal gear motors and hall effect sensor based rotary encoders. To control the extra motors not connected directly to the 3Dot, we will be using a custom PCB that is base on the adafruit motorshield which houses a PCA9685 and two TB6612FNG motor drivers. In addition to the motorshield, we will also implement a MCP2301 I/O expander to take the digital input from the rotary encoders. The power for the extra motors will be supplied from the battery boost on the back of the 3Dot board so that we can access the same voltage that is supplied to the motors on board the 3Dot.

Figure 8. Adafruit Motorshield (PCA9685)

Figure 9. Adafruit Motorshield (TB6612FNG)

Firmware

After discussing our project flow chart with an fellow Electronics and Control Engineer, Forest Nutter, we decided to redesign our flow chart. The initial image is the beginning stages of an overall view of the project.

Figure 10. Firmware Flowchart

PCB Schematic

Since the 3DoT only has a single motor driver chip that is capable of driving two motors, we needed to make a custom PCB to interface with the 3DoT that will allow for 4 additional motors and also be able to take digital input for the rotary encoders. We modeled the motor driver off of the adafruit motor shield version 2.3. The motor shield consisted of the PCA9685pw PWM driver and two TB6612FNG dual motor drivers, which is what the 3DoT uses. The PCA9685pw allows for control of PWM outputs through the I2C bus, which is available through the 3DoT, so that we could properly control the motor drivers. For the digital IO expander, we chose the MCP23017 due to it having 16 digital IO channels for our rotary encoders, which use two digital outputs per wheel for a total of 12 outputs.

Figure 11. Custom PCB Schematic

Our first schematic design had many errors that were easy to point out and a few that were only seen if looking very close. Fabian, previous EE 400D student, pointed out the schematic flaws and  gave recommendations. One of the mistakes I made was in forgetting the pull up resistors for the I2C communication. The I2C needs the pull up resistors because most of the devices are active low. Throughout my ICs and the voltage in, (VCC and VBoost), I forgot to place decoupling capacitors for circuit protection and for clean signals. My first completed schematic looked great with labels on the wires. By simply clicking the name of the wire and looking closely, I connected the TB6612FNG dual motor driver outputs to each other which caused them to short. My project manager, Jon Her, advised that we start from scratch. After the irritative process the above image is the finish schematic. It was a tough process, but having the schematic looked over and over ensured that we have a potential working PCB.  

PCB Layout

After the electronics and controls engineer(ENC), was finished with the schematic on EagleCAD, it was suggested that we try to make a printed circuit board(PCB) out of it and mount the PCB onto the 3DoT board like a “shield” because it was a level 2 requirement(See Figure 1). On the EagleCAD, requirements for the power lines had the size of 16mil. Data routes had 10mil. And there was a 20 drill size for vias. All of the lines had a 45 degree turn so that it doesn’t lose its connection when it is printed and powered up. The top and bottom planes of our PCB are ground copper poured planes. After placing all of the parts on the specified size of the layout, we made sure we used the DRC several times to make sure it completed all the requirements. We also ordered the parts and components before the PCB was made, so that it would arrive in a timely manner.

 

Dimension on 3dot board

Figure 12. Dimensions of the Custom PCB Shield

 

Completed PCB Design

Figure 13. Screenshot of the Routing Diagram

Figure 14. Final product with top and bottom ground copper poured planes in red and blue

We created a custom PCB for our 3Dot board(see figure 3). After we did a final DRC on our final PCB, we then sent it to the president, customer, and Fabian for approval. We had to revise our board several times before it was approved, but once it was, it was sent to 4PCB to be manufactured. We then purchased the stencil from OshStecil. The next steps are to use the stencil and put solder paste on the top layer of the custom PCB. Then we will put the parts and components in its respective places. After, we will heat the board up using a heat gun so that the components will attach onto the board.

Hardware Design

Chassis

To ensure that the 3Dot sat correctly into the chassis, small cutouts were made to allow the Bluetooth module room along with a few pins that were sticking out from the battery holder. A channel was also cut out to allow a wire to access the battery boost on the underside of the 3Dot. There were also channels cut out to allow access to the usb port and the power switch on the 3Dot.

Figure 15. Inside the chassis

To allow proper rocker bogie mechanics, a three beveled gearbox was utilized. Each gear has 16 teeth to allow for a 1:1 gear ratio from the left side of the suspension to the right side.

Figure 16. The rocker bogie gearbox

Solar

As a requirement, the Mini Pathfinder was to have a Solar Panel charge the battery on the 3dot board. To accomplish this, the solar panel needed to be scaled to the rover, while also being able to supply enough voltage and current. The solar cells also needed to be encapsulated. The model of the solar panel was closely modeled after the Sojourner Rover.

Figure 17. Solar Cell on the Mini Pathfinder

With the help of the chassis manufacturer for the mini pathfinder, we were able to scale the size in which the solar panel needed to be. The model was scaled using schematic renderings of the real Sojourner that were found on the internet. The size of the solar cell needed to be around 122x52mm.

Once the size of the panel was found, I needed to find solar cells that were able to charge the 3dot battery and that would fit that size and then encapsulate them. To meet this, I used a 5V 200mA already encapsulated cell that was bought in store. The size of the solar cell was 120x70mm, which fit the requirement of size.

Figure 18. 120x70mm 5v 200mA Encapsulated Solar Cell

 

A micro usb was attached to both the positive and negative leads of the solar panel.

Figure 19. Wiring Diagram

 

After finding the type of solar cell I’d be using, a way of holding the cell onto the rover needed to be found. Using Solidworks, I was able to create a holder to house the cell in place with a hole in the bottom to allow for the micro usb plug to pass through to connect to the 3dot board through the outside. This holder allowed for easy replacement of the cell, if needed. The cell could easily be removed by sliding in and out.  

Figure 20. Solar Cell Holder

Figure 21. Solar Cell in Holder

In conclusion, the solar cell needed to be tested more in order to observe how long it really took to charge the battery. Overall the solar cell was a success in looks and functionality as far as charging.

Verification & Validation Test

Verification and validation can be viewed at this link.

https://drive.google.com/open?id=1D4-kNlP_zy35XqHd-88Zd2Wl2X3w6gr05WJnChsNDzU

Project Status

Power Allocation

Figure 22. Power Allocation based on maximum battery current discharge at any given time.

Mass Allocation

Figure 22. Mass allocation

3d Print Allocation

Figure 23. 3d Print time allocation

Cost Report

While we were able to get many parts and pieces for free, what cost the most was the custom PCB parts and the rotary encoders.

Figure 24. Costs of the project

Burndown and Percent Complete

With all our tasks still left to finish and the progress we made on the project. We finished at %62 completion and remained behind schedule.

Figure 25. Project Burndown with completion at 62%

Concluding Thoughts

If there is anything I would change knowing what I know now, it would to ensure that progress is made consistently every week and that the project schedule be updated at every opportunity. Meeting up with Professor Hill is always a good idea as well. He has valuable input, and tries to help. The lectures may not cover everything but that is why there is so much documentation on Professor Hill’s website. I would also suggest reading over all the material and not taking any other classes that require a lot of time, as this class will already eat up all your time.

Project Resources

Project Video: https://youtu.be/HVbv6seOrCA

 

CDR:https://drive.google.com/open?id=1jm68b_I-lYIxEX2KnLQ9umSzJKdmA3KJs0HE2ciRDsY

PDR:https://drive.google.com/open?id=1ROLFfi2FNQnKXeBWZFecfNi36JnrB8bCFhlLQb2EYzE

Project Libre:https://drive.google.com/open?id=0BwLPwnTqIptrcWEwalpwLS1oVzA

Burndown:https://drive.google.com/open?id=0BwLPwnTqIptrWHE0c3lnbHEtYnM

Verification and Validation:https://drive.google.com/open?id=1D4-kNlP_zy35XqHd-88Zd2Wl2X3w6gr05WJnChsNDzU

Solidworks:https://drive.google.com/open?id=0BwLPwnTqIptremdfTTRaNkY5bFE

Fritzing Files: https://drive.google.com/open?id=0BwLPwnTqIptrc2xkWm5tYVdiM0U

EagleCAD:https://drive.google.com/open?id=0BwLPwnTqIptrM1pZbllodXVnbnM

Arduino Firmware: https://drive.google.com/open?id=0BwLPwnTqIptrQldiNFI1cDg3cW8

 

 

Spring 2017 Mini Pathfinder Encoder Testing

By: Moses Holley (Electronics and Control)

Introduction

The objective of this test was to gain an understanding of how RPM encoders work along with the Arduino code to manipulate them. We need the shaft encoders to detect wheel slippage and control the differential turning for the Mini Pathfinder.

Subsystem Relation

The RPM encoder test was first implemented using the OSEPP Motor Encoder. In this test, We gained an understanding of how the two A3144 hall effect sensors on the chip detect the rotating magnets. Then with the Arduino code converts the rotations in to RPMs. This test was used to measure the speed at which the wheels will turn at the 3dot output voltage of 5 volts. The n20 motors are rated at 6v at a speed of 32 rpm. We used an Arduino Uno because the 3Dot was having trouble uploading at the time.

Figure 1. Test Setup

Figure 2. RPM output

Arduino Code

Average RPM reading Code: This code waits for 10 readings then gets the avg of the RPMs.

// read RPM and calculate average every then readings.

// This code was retrieved online and we manipulated the reading[index] to get the correct readings.

const int numreadings = 10;

int readings[numreadings];

unsigned long average = 0;

int index = 0;

unsigned long total;

 

volatile int rpmcount = 0;//see http://arduino.cc/en/Reference/Volatile

unsigned long rpm = 0;

unsigned long lastmillis = 0;

 

void setup(){

Serial.begin(9600);

attachInterrupt(0, rpm_fan, FALLING);

}

 

void loop(){

if (millis() – lastmillis >= 1000){  /*Uptade every one second, this will be equal to reading frecuency (Hz).*/

detachInterrupt(0);    //Disable interrupt when calculating

total = 0;  

readings[index] = rpmcount * 5.45;  /* Convert frecuency to RPM, note: this works for one interruption per full rotation. For two interrups per full rotation use rpmcount * 30.*/

for (int x=0; x<=9; x++){

  total = total + readings[x];

}

average = total / numreadings;

rpm = average;

rpmcount = 0; // Restart the RPM counter

index++;

if(index >= numreadings){

 index=0;

}

if (millis() > 11000){  // wait for RPMs average to get stable

 

Serial.print(” RPM = “);

Serial.println(rpm);

}

lastmillis = millis(); // Uptade lasmillis

 attachInterrupt(0, rpm_fan, FALLING); //enable interrupt

 }

}

 

void rpm_fan(){ /* this code will be executed every time the interrupt 0 (pin2) gets low.*/

 rpmcount++;

}

 

RPM Code: This code gets the RPM of each reading.

// read RPM

// This code was retrieved online and manipulated the RPM.

volatile int rpmcount = 0;//see http://arduino.cc/en/Reference/Volatile

int rpm = 0;

unsigned long lastmillis = 0;

 

void setup(){

Serial.begin(9600);

attachInterrupt(0, rpm_fan, FALLING);//interrupt cero (0) is on pin two(2).

}

 

void loop(){

if (millis() – lastmillis == 1000){  /*Uptade every one second, this will be equal to reading frecuency (Hz).*/

detachInterrupt(0);    //Disable interrupt when calculating

rpm = rpmcount * 5.45;  /* Convert frecuency to RPM, note: this works for one interruption per full rotation. For two interrups per full rotation use rpmcount * 30.*/

Serial.print(“RPM =\t”); //print the word “RPM” and tab.

Serial.print(rpm); // print the rpm value.

Serial.print(“\t Hz=\t”); //print the word “Hz”.

Serial.println(rpmcount); /*print revolutions per second or Hz. And print new line or enter.*/

rpmcount = 0; // Restart the RPM counter

lastmillis = millis(); // Uptade lasmillis

attachInterrupt(0, rpm_fan, FALLING); //enable interrupt

 }

}

void rpm_fan(){ /* this code will be executed every time the interrupt 0 (pin2) gets low.*/

 rpmcount++;

}

// Elimelec Lopez – April 25th 2013

 

Conclusion

Although we gained a lot of understanding of how the RPM encoder works we will not use this model for our design. The shape of the OSEPP encoder is catered to a DC motor placed of it to be very close to the rotating magnets. We will have a different design that has the DC motor encased in the wheel which requires that the rotating magnet rotate around the motor. When we decide what kind of encoder will be used there will be an updated blog post.

Spring 2017 Mini Pathfinder Bogie Degrees of Freedom

By: Johnathan Chan (Manufacturing-Chassis)

Intro

Since the Mini Pathfinder has to be able to climb up stairs as large as the wheels, we need to ensure that the bogie suspension has enough of an angle to pivot to overcome the stairs. Measuring the angle of the pivoting bogie will help us determine if it can do this.

Measurements

We were able to measure the degrees of freedom by laying the suspension flat on a piece of paper and making a mark of where it is when it is flat. Then we marked where it is completely up. After we used a protractor to measure the degrees of freedom which is 87 degrees.

Figure 1. Flat on the Ground

Figure 2. Suspension all the way up

Figure 3. Angle of which the suspension from flat on the ground to all the way up

Conclusion

With the suspension we created, the rover will be able to maneuver through obstacles the size of its wheels.

Spring 2017 Mini Pathfinder Motor no Load Current and Voltage Test

By: Moses Holley (Electronics and Control)

Introduction

In this test, I will be testing the n20 motors at various voltages. The motors are rated for 6 volts, but the operating boosted voltage on the 3Dot board is 5 volts. The battery is rated at 3.6 volts, should we tap directly into the battery, but is typically fully charged at 4.2 volts [1]. The discharge cutoff voltage is at 2.75 volts, but wanted to test it at a slightly higher output of 3 volts.

Figure 1. Applying Voltage to the Motor

Results

Figure 2. Voltage and Current Results

Conclusion

There is no significant change in the current draw from the different voltages on all the motors. Since the 3Dot motor connectors will use the 5 volts from the boost converter, we will most likely utilize the same voltage output so that all the motors will spin at the same rate. This is an easier solution than programming the onboard motors to spin at the same rate that the other motors.

References

[1] http://www.batteryspace.com/prod-specs/1389-RCR123A36.pdf