The Martian

We detect the moisture, rigidity, and the slope to test whether the surface is suitable for constructions on Mars.

IntermediateShowcase (no instructions)Over 1 day747

Things used in this project

Hardware components

Arduino UNO

Servo Module (Generic)

9V battery (generic)

Seeed Studio Grove starter kit plus for Intel Edison

Story

Reasons to do this model of finding optimized locations of building on Mars:

For a long time, Mars has been recognized as one of the most livable planets that we have discovered so far, with relatively high humidity and eligible atmosphere component. NASA is holding acompetition to gather all solutions that can help build 3D-printed houses for human beings on Mars, and now the competition is in its third phase ‑‑‑- to design habitat virtually and prepare for 3D-printed houses. We looked through the all five winners’ videos regarding their products. They are super scientific and convenient if people can live in them, but a big question is that, none of the videos talks about how to find the optimized location for their buildings. So to perfect this competition, we decided to simulate the way we design to choose a better place to live, avoiding wasting the great architectures.

What we started with and What we decided to include:

We went through the environment restriction on Mars, especially the ones related to human beings’ safety and convenience and searched for the best solution according to those aspects.

First, we found that unlike presented in the movies, wind on Mars is actually even milder than that on Earth due to relatively low pressure. So apparently we do not need to include wind level in our simulation.

Then, we wanted to measure the humidity since we can find liquid water on Mars. Even though the amount of water cannot support daily lives of people on Mars, it still matters since it can affect the quality of soil and whether buildings can be constructed successfully. So we decided test the moisture as well as rigidity of nearby soil.

Thirdly, we considered the temperature. Temperature on Mars is about -243 °F to 68 °F. While this is a challenge for people to live in an environment with such a broad range of temperature, we cannot monitor it by changing the location of buildings, so this is not our point in this project.

Finally, the slope of surface the building is located on can matter seriously. The construction documents on Internet shows that the maximum slope of building on the lowest level on earth, the safest and easiest to handle, is that the slope cannot rise more than 1 foot every 10 feet on ground. Generally, the tangent of the slope cannot exceed 1/10, so the maximum degree is approximately 5.7°. Since the wind on Mars largely will not affect the buildings, we do not need to change this value. And Mars is mostly unknown to us, so it is better to use a safer estimation at the beginning.

How we accomplished these goals:

For chassis: The initial design is to make a tricycle. That is a big wheel on left and right sides, and an assistant small wheel at the back, which can simplify the codes when the vehicle is changing directions. We first wanted to use 3-phase DC servos because they can provide energy strong enough when climbing small hills. However, the DC servos consistently reversed their direction once they completed a revolution. So we changed tosteppers. Even though steppers will lose nearly all their torque and much less efficient, we don’t need to use it with high speed and our vehicle is not that heavy, so it is not an issue for us.

For slope detection: The initial design is to use a MPU-6050 Gyro Scope sensor to test the current tilting degree of the vehicle. However, we cannot find any MPU-6050 gyroscope sensor, so we changed to mercury tilt switch sensor. When tilting the mercury module, it will complete the circuit and switch on.

For moisture and rigidity detection: The initial task is simply to detect the rigidity, so the initial design is to usea four-bar linkage connected with a servo and two fixed point outside the servo, and then we can find out whether it is soft enough for buildings by reading the degrees the servo rotates. However, when we were doing this, it turned out that the servo can keep rotate even when placed on rigid plate, because our vehicleis light and it will lift itself up. So we turned to the gyro moisture sensor. Once they the close environment is humid enough, it will stop going down becauseit can tell that it has touched the soil. Also, we can find out whether the humidity is suitable for constructions.

Shortcomings

For demo:

a. The actual measured slope is the slopeof vehicle instead of the hills, because the vehicle is relatively bigger.

b. Lack of good wheels and gyroscope sensor.

For project:

a. There is no pattern how the vehicle will move: we should design a program to let the vehicle move in the shortest distance and find optimized location quickly (what kind of soil will have the right soil surrounded).

b. When the vehicle is at the top of a mountain, the slope is zero but it is actually not a right place to have construction.

c. The kind of water is not tested: some kind of water may be harmful for human beings.

// wheels to move

#include <Stepper.h>

const int stepsPerRevolution = 1000;  // change this to fit the number of steps per revolution
// for your motor


// initialize the stepper library on pins 8 through 11:
Stepper myStepper1(stepsPerRevolution, 4, 5, 6, 7 );
Stepper myStepper2(stepsPerRevolution, 8, 9, 10, 11);

int stepCount = 0;  // number of steps the motor has taken

void setup() {
  // nothing to do inside the setup
}

void loop() {
  // read the sensor value:
  int sensorReading = analogRead(A0);
  // map it to a range from 0 to 100:
  int motorSpeed = map(sensorReading, 0, 1023, 0, 100);
  // set the motor speed:
  if (motorSpeed >= 0) {
    myStepper1.setSpeed(motorSpeed);
    // step 1/100 of a revolution:
    myStepper1.step(stepsPerRevolution / 100);
    myStepper2.setSpeed(motorSpeed);
    // step 1/100 of a revolution:
    myStepper2.step(stepsPerRevolution / 100);
  }
}

// moisture

/*
 Grove Moisture Sensor

 The following sketch demonstrates a simple application of sensing 
 the moisture of the soil. You can determine whether a plant needs water 
 or not by observing the results that the sensor outputs.
 
 The circuit:
 * 4-Digit Display attached to Pin 38 and 39 (J14 plug on Grove Base BoosterPack)
 * Moisture Sensor attached to Pin 24 (J6 plug on Grove Base BoosterPack)
 
 * Note:  
 
 This example code is in the public domain.
 
 http://www.seeedstudio.com/depot/Grove-Moisture-Sensor-p-955.html

*/
//4-Digit Display library
#include "TM1637.h"

/* Macro Define */
#define CLK               	39          /* 4-Digit Display clock pin */
#define DIO               	38          /* 4-Digit Display data pin */
#define MOISTURE_PIN      	43          /* pin of Moisture Sensor */
#define THRESHOLD_VALUE   	300         /* threshold for watering the plant */
#define LED 			RED_LED

/* Global Variables */
TM1637 tm1637(CLK, DIO);                  /* 4-Digit Display object */
int analog_value = 0;                     /* variable to store the value coming from Moisture Sensor */
int8_t bits[4] = {0};                     /* array to store the single digits of the value */

/* the setup() method runs once, when the sketch starts */
void setup() 
{
  /* Initialize 4-Digit Display */
  tm1637.init();
  tm1637.set(BRIGHT_TYPICAL);
  
  /* declare the LED pin as an OUTPUT */
  pinMode(LED, OUTPUT);  
}

/* the loop() method runs over and over again */
void loop() 
{
    analog_value = analogRead(MOISTURE_PIN);      /* read the value from the sensor */
  
    /* if the value is smaller than threshold, turn on LED */
    if(analog_value < THRESHOLD_VALUE) 
    {
        digitalWrite(LED, HIGH);
    } 
    else 
    {
        digitalWrite(LED, LOW);
    }
    
    memset(bits, 0, 4);                             /* reset array before we use it */
    for(int i = 3; i >= 0; i--) 
    {
        /* Convert the value to individual decimal digits for display */
        bits[i] = analog_value % 10;
        analog_value = analog_value / 10;  
        tm1637.display(i, bits[i]);                 /* display on 4-Digit Display */
    }
    delay(200);  //small delay so that the number doesn't change too quickly to read
}

Credits

Peggy Lee

1 project • 0 followers

Contact

The Martian