Billig Robot med Arduino

Jag slutade med en annan motor konfiguration. Min front motor pekar ner och vänder lite kvartalet växel som vänder sedan framhjulen. Detta betydde att ingen av Randys kod var tillämplig på mitt projekt.

Jag började titta in i något icky världen av Arduino programmering. Det är alla globala variabler och enda fil projekt. Jag fann det svårt att förstå många av exempel som finns tillgängliga online, inte för att de var särskilt svåra begrepp, men eftersom de var så dåliga exempel på programmering som känner av min raffinerade kunde inte vettigt av det.

Också lämnar den Arduino programmeringsmiljön mycket att önska. Som leder mig till utmärkt embedXcode projektetsom möjligt för mig att använda XCode i stället.

När jag hade en trevlig miljö börjat jag titta på bättre sätt att skriva kod för Arduino. Visar sig hela är bara C++, som jag vet gott om. MotorControl klassen jag skrev, som utnyttjar en DasPing klass, är båda nedan.

Städa upp koden så här aktiverat min slutliga Arduino skiss se ut som följande:

#include "Arduino.h"

#include "DasPing.h"
#include "MotorControl.h"

MotorControl * mc;

void setup() {
Serial.BEGIN(9600);
MC = nya MotorControl (7, 100, 125);
MC -> setUp();
}

void loop() {
MC -> checkDistance();
om (mc -> avstånd > 12 || mc -> avstånd == 0) {
MC -> straighten();
MC -> framåt (mc -> getBaseSpeed());
} annat {
MC -> right();
MC -> backward();
}
}

Du kan se roboten det faktiska beteende. Abstrahera klasserna MotorControl och DasPing, för att kontrollera rörelser och vettigt avstånd respektive aktiverat mig att arbeta med mycket roligare problemet med att en robot till liv.

Den grundläggande beteende visas i denna video kommer från ca 10 rader med kod, när du abstrakt ut allt du inte behöver oroa dig.

Här är MotorControl och DasPing klassdefinitioner, följt av sina respektive genomförandet filer.

MotorControl.h

//
MotorControl.h
//
//
Skapad av David Worley på 1/1/13.
//
//

#ifndef ___MotorControl__
#define ___MotorControl__

#include "Arduino.h"
#include "DasPing.h"

klass MotorControl
{
offentlig:
MotorControl (int pingPin, int defaultDelay, int baseSpeed);
void setUp();

int avstånd;

int getBaseSpeed();
void setBaseSpeed (int baseSpeed);
utan laga kraft framåt (int goSpeed);
void backward();
void left();
void right();
void stop();
void checkDistance();

void easeToBaseSpeed();
void slowFromBaseSpeed();

void straighten();
skyddad:
int _baseSpeed;
int _turnSpeed; för att kontrollera tur motorn
int _distance;
int _defaultDelay;
DasPing * _pinger;

motor 1, vrida
int _brake1;
int _direction1;
int _speed1;

motor 2, fram & vända
int _brake2;
int _direction2;
int _speed2;
};

#endif / * defined(___MotorControl__) * /

MotorControl.cpp

//
MotorControl.cpp
//
En klass för att styra en viss motor konfiguration
använda Arduino motor skölden och en Parallax Ping sensor.
//
Skapad av David Worley på 1/1/13.
//
//

#include "MotorControl.h"

MotorControl::MotorControl (int pingPin, int defaultDelay, int baseSpeed)
{
Serial.println ("MotorControl init.");
_pinger = ny DasPing(pingPin);
This -> checkDistance();

_defaultDelay = defaultDelay;
This -> setBaseSpeed(baseSpeed);

eftersom vi använder en särskild konfiguration, vet vi
Vad värden som ska användas utifrån dokumentationen till motor sköld
_brake1 = 9;
_direction1 = 12;
_speed1 = 3;

_brake2 = 8;
_direction2 = 13.
_speed2 = 11;

_turnSpeed = 255; set till max för tur motorn
}

void MotorControl::setUp()
{
Serial.println ("MotorControl installationen.").
upprätta motor riktning pins
pinMode (_direction1, produktionen);
pinMode (_direction2, produktionen);

bromsar
pinMode (_brake1, produktionen);
pinMode (_brake2, produktionen);

digitalWrite (_brake1, hög);
digitalWrite (_brake2, hög);
}

void MotorControl::forward (int goSpeed)
{
digitalWrite (_brake2, låg);
digitalWrite (_direction2, låg);

analogWrite (_speed2, goSpeed);

Delay(_defaultDelay);
}

void MotorControl::backward()
{
digitalWrite (_brake2, låg);
digitalWrite (_direction2, hög);

analogWrite (_speed2, 155); tillbaka upp i hög hastighet

Delay(_defaultDelay);
}

void MotorControl::left()
{
digitalWrite (_brake2, låg);
digitalWrite (_direction2, hög);
analogWrite (_speed2, _turnSpeed);

Delay(_defaultDelay);
}

void MotorControl::right()
{
digitalWrite (_brake1, låg);
digitalWrite (_direction1, låg);
analogWrite (_speed1, _turnSpeed);
}

void MotorControl::stop()
{
digitalWrite (_brake1, hög);
digitalWrite (_brake2, hög);

analogWrite (_speed1, 0);
analogWrite (_speed2, 0);

Delay(_defaultDelay);
}

void MotorControl::straighten()
{
digitalWrite (_brake1, hög);
analogWrite (_speed1, 0);
}

void MotorControl::checkDistance()
{
_pinger -> pingDistance();
_distance = _pinger -> distance();
avståndet = _distance;
}

int MotorControl::getBaseSpeed()
{
återvända _baseSpeed;
}
void MotorControl::setBaseSpeed (int baseSpeed)
{
_baseSpeed = baseSpeed;
}

void MotorControl::easeToBaseSpeed()
{
för (int jag = 0; jag < = _baseSpeed; i ++) {
Forward(i);
Delay(100); varje 1/10th av en sekund, påskynda
}
}

void MotorControl::slowFromBaseSpeed()
{
för (int jag = _baseSpeed; jag > = 0; jag = i - 10) {
Forward(i);
Delay(50);
}
Detta -> stop();
}

DasPing.h

//
DasPing.h
//
//
Skapad av David Worley på 1/2/13.
//
//

#ifndef ___DasPing__
#define ___DasPing__

#include "Arduino.h"

klass DasPing
{
offentlig:
DasPing (int pingPin);
void pingDistance();
int distance();
skyddad:
int _distance;
int _pin;
int microsecondsToInches (lång mikrosekunder);
};

#endif / * defined(___DasPing__) * /

DasPing.cpp

//
DasPing.cpp
//
En klass för att kontrollera Parallax Ping sensor
//
Skapad av David Worley på 1/2/13.
//
//

#include "DasPing.h"

DasPing::DasPing (int pingPin)
{
_distance = 0;
_pin = pingPin;
}

void DasPing::pingDistance()
{
int varaktighet;

PING))) utlöses av en hög puls av 2 eller fler mikrosekunder.
Ge en kort låg puls förhand för att säkerställa en ren hög puls:
pinMode (_pin, produktionen);
digitalWrite (_pin, låg);
delayMicroseconds(2);
digitalWrite (_pin, hög);
delayMicroseconds(5);
digitalWrite (_pin, låg);

Samma PIN-koden används för att läsa signalen från PING))): en hög
puls vars längd är tid (i mikrosekunder) från den sändande
ping till mottagning av dess eko av ett objekt.
pinMode (_pin, ingång);
längd = pulseIn (_pin, hög);

konvertera tiden till ett avstånd
_distance = denna -> microsecondsToInches(duration);
}

int DasPing::distance()
{
återvända _distance;
}

int DasPing::microsecondsToInches (lång mikrosekunder)
{
Enligt Parallaxs datablad för PING))), det finns
73.746 mikrosekunder per tum (dvs. ljud resor på 1130 fot per
det andra). Detta ger vägsträcka som ping, utgående
och tillbaka, så vi delar med 2 att få distansera av hindret.
Se: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
återvända mikrosekunder/74/2;
}