ఇంటర్నెట్ నియంత్రిత మార్స్ రోవర్‌ను ఎలా నిర్మించాలి: 4 దశలు (చిత్రాలతో)

ఈ ఇన్‌స్ట్రక్టబుల్ ఇంటర్నెట్ నియంత్రిత అన్ని భూభాగ రోబోట్‌లను నిర్మించడానికి మీరు తెలుసుకోవలసిన ప్రతిదాన్ని వివరిస్తుంది. ఇది మార్స్ క్యూరియాసిటీ రోవర్‌పై మోడల్‌గా ఉంటుంది. ఈ రోబోట్ ఏదైనా ఇంటర్నెట్ ప్రారంభించబడిన పరికరం నుండి నియంత్రించదగినది, కాబట్టి మీరు ఈ విషయాన్ని గ్రహం యొక్క మరొక వైపు నియంత్రించవచ్చు (లేదా మార్స్ ఇంటర్నెట్ కలిగి ఉంటే మాత్రమే). ఈ ప్రాజెక్ట్ అంతా అద్భుతమైన ఎలక్ట్రిక్ ఇంప్ (ఇంటర్నెట్‌కు ఏదైనా కనెక్ట్ చేయడానికి మిమ్మల్ని అనుమతించే ఒక SD కార్డ్ పరిమాణ పరికరం) మరియు ఒక ఆర్డునో చేత శక్తిని పొందుతుంది.
డుండిలోని ప్రొడక్ట్ డిజైన్ రీసెర్చ్ స్టూడియోలో ఈ ప్రాజెక్ట్ను మైఖేల్ షార్టర్, టామ్ మెట్‌కాల్ఫ్, జోన్ రోజర్స్ మరియు అలీ నేపియర్ రూపొందించారు.

మీకు ఏమి అవసరం:
6WD వైల్డ్ థంపర్ ఆర్డునో చట్రం - http://robosavvy.com/store/product_info.php/products_id/1167?osCsid=5e99bbe12a25938cbf4267ea6bc497ea
వైల్డ్ థంపర్ ఆర్డునో కంట్రోలర్ - http://robosavvy.com/store/product_info.php/products_id/1168
లిపో బ్యాటరీ - 7.2 వి 5000 మహ్
3 మి.మీ యాక్రిలిక్
5 మి.మీ యాక్రిలిక్
10 సెం.మీ వ్యాసం కలిగిన డ్రెయిన్ పైప్
35 మిమీ వ్యాసం కలిగిన పైపు
అల్యూమినియం రాడ్లు
ఎలక్ట్రిక్ ఇంప్
ఎలక్ట్రిక్ ఇంప్ బ్రేక్అవుట్ బోర్డు
కొన్ని జంపర్ కేబుల్స్
స్కేట్బోర్డ్ పట్టు టేప్

సామాగ్రి:

దశ 1: రోవర్ నిర్మించడం

మీకు అవసరమైన అన్ని భాగాలను లేజర్ కట్ చేయడానికి మిమ్మల్ని అనుమతించే అడోబ్ ఇల్లస్ట్రేటర్ ఫైళ్లు జోడించబడ్డాయి. మొత్తం మూడు ఫైళ్లు ఉన్నాయి. అన్ని 3 మిమీ మందపాటి భాగాలకు ఒక ఫైల్, 5 మిమీ మందపాటి భాగాలకు ఒకటి మరియు గ్రిప్ టేప్ భాగాలకు ఒకటి.
మీ వైల్డ్ థంపర్ 6WD కోసం కొత్త చట్రం ఎలా అతుక్కోవచ్చో ఈ క్రింది చిత్రాలు మంచి ఆలోచనను ఇస్తాయని ఆశిద్దాం.
ఆర్డునోకు ఎలక్ట్రిక్ ఇంప్ యొక్క వైరింగ్ సులభం:
ఇంప్ పిన్ 1 - ఆర్డునో పిన్ 10
ఇంప్ పిన్ 2 - ఆర్డునో పిన్ 9
ఇంప్ పిన్ 8 - ఆర్డునో పిన్ 12
ఇంప్ పిన్ 9 - ఆర్డునో పిన్ 2
ఎలక్ట్రిక్ ఇంప్ మీ బ్రేక్అవుట్ బోర్డ్, అలాగే భూమిని బట్టి 5 వి లేదా 3.3 వి అవసరం.
ఆన్ మరియు ఆఫ్ చేయడం సులభం చేయడానికి బ్యాటరీకి అనుగుణంగా టోగుల్ స్విచ్‌లో వైర్ చేయాలని నిర్ణయించుకున్నాను.

దశ 2: వెబ్ సైడ్ ఆఫ్ థింగ్స్

మీ కోసం ఇక్కడ కొన్ని కోడ్ ఉంది….
ఇంప్ కోసం స్క్విరెల్ (నేను ఇకపై కనుగొనలేని ఆన్‌లైన్ మూలం నుండి తీసుకోబడింది…):
================================================
server.show ( "");
// రోవర్ కోసం రిమోట్ కంట్రోల్
ledState <- 0;
ఫంక్షన్ బ్లింక్ ()
{
// స్థితిని మార్చండి
ledState = ledState? 0: 1;
server.log (“ledState val:“ + ledState);
// పిన్‌కు స్థితిని ప్రతిబింబించండి
hardware.pin9.write (ledState);
}
LED నియంత్రణ ఛానెల్ కోసం // ఇన్పుట్ క్లాస్
తరగతి ఇన్పుట్ HTTP ఇన్పుట్పోర్ట్ను విస్తరించింది
{
పేరు = “శక్తి నియంత్రణ”
type = “number”
ఫంక్షన్ సెట్ (httpVal)
{
server.log (“స్వీకరించిన విలువ:“ + httpVal);
if (httpVal == 1) {
hardware.pin9.write (1);
imp.sleep (0.1);
hardware.pin9.write (0);
}
లేకపోతే (httpVal == 2) {
hardware.pin8.write (1);
imp.sleep (0.1);
hardware.pin8.write (0);
}
లేకపోతే (httpVal == 3) {
hardware.pin2.write (1);
imp.sleep (0.1);
hardware.pin2.write (0);
}
లేకపోతే (httpVal == 4) {
hardware.pin1.write (1);
imp.sleep (0.1);
hardware.pin1.write (0);
}
వేరే {
;
}
}
}
ఫంక్షన్ వాచ్డాగ్ () {
imp.wakeup (60, వాచ్డాగ్);
server.log (httpVal);
}
// ప్రతి 60 సెకన్లకు వాచ్డాగ్ రాయడం ప్రారంభించండి
// వాచ్డాగ్ ();
// అంతర్గత పుల్ అప్‌తో పిన్‌లను ఓపెన్ డ్రెయిన్ అవుట్‌పుట్‌గా కాన్ఫిగర్ చేయండి
hardware.pin9.configure (DIGITAL_OUT_OD_PULLUP);
hardware.pin8.configure (DIGITAL_OUT_OD_PULLUP);
hardware.pin2.configure (DIGITAL_OUT_OD_PULLUP);
hardware.pin1.configure (DIGITAL_OUT_OD_PULLUP);
// సర్వర్‌తో నమోదు చేసుకోండి
imp.configure (“రోవర్ కోసం రీమోట్ కంట్రోల్”, inputHTTP (), );
================================================


ఆర్డునో కోడ్ (ధన్యవాదాలు క్రిస్ మార్టిన్!)…
================================================
/*
AnalogReadSerial
పిన్ 0 లో అనలాగ్ ఇన్పుట్ చదువుతుంది, ఫలితాన్ని సీరియల్ మానిటర్కు ప్రింట్ చేస్తుంది.
A0 ను పిన్ చేయడానికి పొటెన్టోమీటర్ యొక్క సెంటర్ పిన్ను, మరియు బయటి పిన్‌లను + 5V మరియు భూమికి అటాచ్ చేయండి.
ఈ ఉదాహరణ కోడ్ పబ్లిక్ డొమైన్‌లో ఉంది.
*/
int పిన్ఫ్ = 2;
పూర్ణాంక పిన్ల్ = 12;
int పిన్ర్ = 10;
int పిన్బ్ = 9;
# LmotorA 3 ని నిర్వచించండి // ఎడమ మోటారు H వంతెన, ఇన్పుట్ A.
# LmotorB 11 ని నిర్వచించండి // ఎడమ మోటారు H వంతెన, ఇన్పుట్ B.
# RmotorA 5 ని నిర్వచించండి // కుడి మోటారు H వంతెన, ఇన్పుట్ A.
# RmotorB 6 ని నిర్వచించండి // కుడి మోటారు H వంతెన, ఇన్పుట్ B.
# v 255 ని నిర్వచించండి
# ఉన్నాయి
// సర్వో మైసర్వో;
// int led = 12;
int pos = 0;
// మీరు రీసెట్ నొక్కినప్పుడు సెటప్ రొటీన్ ఒకసారి నడుస్తుంది:
శూన్య సెటప్ () {
//myservo.attach(9);
// పిన్‌మోడ్ (దారితీసింది, U ట్పుట్);
pinMode (pinf, INPUT); // సెకనుకు 9600 బిట్స్ వద్ద సీరియల్ కమ్యూనికేషన్‌ను ప్రారంభించండి:
pinMode (pinl, INPUT);
pinMode (pinr, INPUT);
pinMode (pinb, INPUT);
Serial.begin (9600);
digitalWrite (pinf, LOW);
digitalWrite (pinl, LOW);
digitalWrite (pinr, LOW);
digitalWrite (pinb, LOW);
//288000
// ఇది సీరియల్ మానిటర్‌లో భిన్నంగా ఉంటుంది, ఇది పైకి లేదా క్రిందికి ఉందో లేదో ఖచ్చితంగా తెలియదు
// సీరియల్.బెగిన్ (14400);
}
int lls = 0;
int rls = 0;
int al = 0;
// లూప్ రొటీన్ ఎప్పటికీ మళ్లీ మళ్లీ నడుస్తుంది:
శూన్య లూప్ () {
// అనలాగ్ పిన్ 0 పై ఇన్‌పుట్ చదవండి:
పూర్ణాంక సెన్సార్వాల్యూ 1 = డిజిటల్ రీడ్ (పిన్ఫ్);
పూర్ణాంక సెన్సార్వాల్యూ 2 = డిజిటల్ రీడ్ (పిన్ల్);
int సెన్సార్‌వాల్యూ 3 = డిజిటల్ రీడ్ (పిన్ర్);
int సెన్సార్వాల్యూ 4 = డిజిటల్ రీడ్ (పిన్బ్);
// మీరు చదివిన విలువను ముద్రించండి:
Serial.print (sensorValue1);
సీరియల్.ప్రింట్ (”:“);
Serial.print (sensorValue2);
సీరియల్.ప్రింట్ (”:“);
Serial.print (sensorValue3);
సీరియల్.ప్రింట్ (”:“);
Serial.println (sensorValue4);
ఆలస్యం (25); // స్థిరత్వం కోసం రీడ్‌ల మధ్య ఆలస్యం
if (సెన్సార్‌వాల్యూ 1 == 1) {
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 120);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 120);
ఆలస్యం (500);
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
// myservo.write (10);
// ఆలస్యం (500);
}
వేరే {
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
}
if (సెన్సార్‌వాల్యూ 2 == 1) {
// డిజిటల్ రైట్ (దారితీసింది, అధికం);
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 250);
analogWrite (LmotorA, 250);
analogWrite (LmotorB, 0);
ఆలస్యం (100);
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
// myservo.write (10);
// ఆలస్యం (500);
}
వేరే
{
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
}
if (సెన్సార్‌వాల్యూ 4 == 1) {
// డిజిటల్ రైట్ (దారితీసింది, అధికం);
analogWrite (RmotorA, 250);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 250);
ఆలస్యం (100);
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
// myservo.write (10);
// ఆలస్యం (500);
}
వేరే
{
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
}
if (సెన్సార్‌వాల్యూ 3 == 1) {
// డిజిటల్ రైట్ (దారితీసింది, అధికం);
analogWrite (RmotorA, 120);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 120);
analogWrite (LmotorB, 0);
ఆలస్యం (500);
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
// myservo.write (10);
// ఆలస్యం (500);
}
వేరే
{
analogWrite (RmotorA, 0);
analogWrite (RmotorB, 0);
analogWrite (LmotorA, 0);
analogWrite (LmotorB, 0);
}
}
================================================

ఇప్పుడు యూజర్ ఇంటర్ఫేస్ కోసం. జత చేసిన ఫోల్డర్‌ను అన్జిప్ చేయండి; అవసరమైన అన్ని కోడ్ అక్కడ ఉండాలి. మీరు చేయాల్సిందల్లా మీ ప్రత్యేకమైన ఎలక్ట్రిక్ ఇంప్ API లో తగిన స్థలంలో index.html ఫైల్‌లో అతికించండి. నేను దీన్ని ఫైల్‌లోనే లేబుల్ చేసాను.

దశ 3: దీనికి కొన్ని విజువల్స్ ఇద్దాం

మార్స్ యొక్క ఫుటేజీని ప్రదర్శించే హెడ్ యూనిట్‌లో పాత ఐఫోన్‌ను ఉంచాలని నిర్ణయించుకున్నాను. ఇది ఏదైనా కావచ్చు, వీడియో కెమెరా కూడా కావచ్చు కాబట్టి మీరు స్కైప్ లేదా ఫేస్‌టైమ్ ద్వారా ఎక్కడ డ్రైవింగ్ చేస్తున్నారో చూడవచ్చు …

దశ 4: రోవింగ్ చేద్దాం!

SWSW 2013 లో నాసా కార్యక్రమంలో ది మినీ మార్స్ రోవర్ యొక్క శీఘ్ర వీడియో ఇక్కడ ఉంది!

Vimeo లో మైఖేల్ చిన్న నుండి SXSW రోవర్.

ఈ ప్రాజెక్ట్ గురించి గొప్ప విషయం ఏమిటంటే, రోబోట్ యొక్క ప్రవర్తనలను లేదా ఇంటర్‌ఫేస్‌ను మార్చడానికి కోడ్‌ను సర్దుబాటు చేయడం సులభం.
ఆనందించండి!
M

లో ఫైనలిస్ట్
రిమోట్ కంట్రోల్ పోటీ