Ik beëindigde omhoog met een andere motor configuratie. Mijn voorste motor omlaag wijst en verandert een beetje kwartaal versnelling die dan de voorwielen draait. Dit betekende dat geen van Randy's code voor mijn project was.
Ik begon op zoek naar de enigszins icky wereld van de programmering van Arduino. Het is allemaal globale variabelen en één bestand projecten. Ik vond het moeilijk te begrijpen veel van de voorbeelden beschikbaar online, niet omdat ze bijzonder moeilijke begrippen waren, maar omdat ze waren zulke slechte voorbeelden van programmering die mijn geraffineerde zintuigen kunnen niet zinvol zijn van het.
Ook laat de Arduino programmeer omgeving veel te wensen over. Dat leidt mij tot het uitstekende embedXcode-project, dat kon ik XCode gebruiken in plaats.
Zodra ik had een mooie omgeving begon ik op zoek naar betere manieren om code te schrijven voor de Arduino. Blijkt dat het hele ding is gewoon C++, waarvan ik weet veel over. De klasse van de MotorControl die ik schreef, die gebruik maakt van een klasse DasPing, zijn beide hieronder.
Schoonmaken van de code als dit ingeschakeld mijn definitieve schets van de Arduino te laten uitzien als de volgende:
#include "Arduino.h" #include "DasPing.h" #include "MotorControl.h" MotorControl *mc; void setup() { Serial.begin(9600); mc = new MotorControl(7, 100, 125); mc->setUp(); } void loop() { mc->checkDistance(); if (mc->distance > 12 || mc->distance == 0) { mc->straighten(); mc->forward(mc->getBaseSpeed()); } else { mc->right(); mc->backward(); } } Hier ziet u de werkelijke gedrag van de robot is er. Abstraheren van de klassen MotorControl en DasPing, om het verkeer en het gevoel van afstand respectievelijk ingeschakeld me om te werken met de veel leuker probleem om een robot tot leven.
Het fundamentele gedrag getoond in deze video is afgeleid van ongeveer 10 regels code, zodra u alles wat die u hoeft te maken over abstract.
Hier zijn de MotorControl en DasPing klassendefinities, gevolgd door hun respectieve implementatie bestanden.
MotorControl.h
// // MotorControl.h // // // Created by David Worley on 1/1/13. // // #ifndef ____MotorControl__ #define ____MotorControl__ #include "Arduino.h" #include "DasPing.h" class MotorControl { public: MotorControl(int pingPin, int defaultDelay, int baseSpeed); void setUp(); int distance; int getBaseSpeed(); void setBaseSpeed(int baseSpeed); void forward(int goSpeed); void backward(); void left(); void right(); void stop(); void checkDistance(); void easeToBaseSpeed(); void slowFromBaseSpeed(); void straighten(); protected: int _baseSpeed; int _turnSpeed; // for controlling the turn motor int _distance; int _defaultDelay; DasPing *_pinger; // motor 1, turning int _brake1; int _direction1; int _speed1; // motor 2, forward & reverse int _brake2; int _direction2; int _speed2; }; #endif /* defined(____MotorControl__) */ MotorControl.cpp
// // MotorControl.cpp // // A class for controlling a particular motor configuration // using the Arduino motor shield and a Parallax Ping sensor. // // Created by David Worley on 1/1/13. // // #include "MotorControl.h" MotorControl::MotorControl(int pingPin, int defaultDelay, int baseSpeed) { Serial.println("MotorControl init."); _pinger = new DasPing(pingPin); this->checkDistance(); _defaultDelay = defaultDelay; this->setBaseSpeed(baseSpeed); // since we're using a specific configuration, we know // what values to use based on the motor shield documentation _brake1 = 9; _direction1 = 12; _speed1 = 3; _brake2 = 8; _direction2 = 13; _speed2 = 11; _turnSpeed = 255; // set to max for the turn motor } void MotorControl::setUp() { Serial.println("MotorControl setUp."); // establish motor direction pins pinMode(_direction1, OUTPUT); pinMode(_direction2, OUTPUT); // brakes pinMode(_brake1, OUTPUT); pinMode(_brake2, OUTPUT); digitalWrite(_brake1, HIGH); digitalWrite(_brake2, HIGH); } void MotorControl::forward(int goSpeed) { digitalWrite(_brake2, LOW); digitalWrite(_direction2, LOW); analogWrite(_speed2, goSpeed); delay(_defaultDelay); } void MotorControl::backward() { digitalWrite(_brake2, LOW); digitalWrite(_direction2, HIGH); analogWrite(_speed2, 155); // back up at high speed delay(_defaultDelay); } void MotorControl::left() { digitalWrite(_brake2, LOW); digitalWrite(_direction2, HIGH); analogWrite(_speed2, _turnSpeed); delay(_defaultDelay); } void MotorControl::right() { digitalWrite(_brake1, LOW); digitalWrite(_direction1, LOW); analogWrite(_speed1, _turnSpeed); } void MotorControl::stop() { digitalWrite(_brake1, HIGH); digitalWrite(_brake2, HIGH); analogWrite(_speed1, 0); analogWrite(_speed2, 0); delay(_defaultDelay); } void MotorControl::straighten() { digitalWrite(_brake1, HIGH); analogWrite(_speed1, 0); } void MotorControl::checkDistance() { _pinger->pingDistance(); _distance = _pinger->distance(); distance = _distance; } int MotorControl::getBaseSpeed() { return _baseSpeed; } void MotorControl::setBaseSpeed(int baseSpeed) { _baseSpeed = baseSpeed; } void MotorControl::easeToBaseSpeed() { for (int i = 0; i <= _baseSpeed; i++) { forward(i); delay(100); // every 1/10th of a second, speed up } } void MotorControl::slowFromBaseSpeed() { for (int i = _baseSpeed; i >= 0; i = i - 10) { forward(i); delay(50); } this->stop(); } DasPing.h
// // DasPing.h // // // Created by David Worley on 1/2/13. // // #ifndef ____DasPing__ #define ____DasPing__ #include "Arduino.h" class DasPing { public: DasPing(int pingPin); void pingDistance(); int distance(); protected: int _distance; int _pin; int microsecondsToInches(long microseconds); }; #endif /* defined(____DasPing__) */ DasPing.cpp
// // DasPing.cpp // // A class for controlling the Parallax Ping sensor // // Created by David Worley on 1/2/13. // // #include "DasPing.h" DasPing::DasPing(int pingPin) { _distance = 0; _pin = pingPin; } void DasPing::pingDistance() { int duration; // The PING))) is triggered by a HIGH pulse of 2 or more microseconds. // Give a short LOW pulse beforehand to ensure a clean HIGH pulse: pinMode(_pin, OUTPUT); digitalWrite(_pin, LOW); delayMicroseconds(2); digitalWrite(_pin, HIGH); delayMicroseconds(5); digitalWrite(_pin, LOW); // The same pin is used to read the signal from the PING))): a HIGH // pulse whose duration is the time (in microseconds) from the sending // of the ping to the reception of its echo off of an object. pinMode(_pin, INPUT); duration = pulseIn(_pin, HIGH); // convert the time into a distance _distance = this->microsecondsToInches(duration); } int DasPing::distance() { return _distance; } int DasPing::microsecondsToInches(long microseconds) { // According to Parallax's datasheet for the PING))), there are // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per // second). This gives the distance travelled by the ping, outbound // and return, so we divide by 2 to get the distance of the obstacle. // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf return microseconds/74/2; } 
