Merge branch 'master' into aron

Author: aronhoff

.gitattributes

@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

Buggy/Buggy.cpp

@@ -4,7 +4,7 @@ void Buggy::go(bool silent) {
   if (going) {
     return;
   }
-  motor.go();
+  motor->go();
   lastGoTime = millis();
   if (!silent) {
     comms->writeXbee("GOING");
@@ -16,7 +16,7 @@ void Buggy::stop(bool silent) {
   if (!going) {
     return;
   }
-  motor.stop();
+  motor->stop();
   travelledTime += millis() - lastGoTime;
   if (!silent) {
     comms->writeXbee("STOPPED");
@@ -102,16 +102,16 @@ void Buggy::updateParking() {
   }
 
   if (parkingState == BEFORE_INTERSECTION) {
-    if (travelDirection == CLOCKWISE && motor.getState() != LEFT_OVERRIDE) {
-      motor.leftOverride();
-    } else if (travelDirection == ANTI_CLOCKWISE && motor.getState() != RIGHT_OVERRIDE) {
-      motor.rightOverride();
+    if (travelDirection == CLOCKWISE && motor->getState() != LEFT_OVERRIDE) {
+      motor->leftOverride();
+    } else if (travelDirection == ANTI_CLOCKWISE && motor->getState() != RIGHT_OVERRIDE) {
+      motor->rightOverride();
     }
   }
 
   unsigned long sinceGantry = timeTravelledSinceGantry();
   if (parkingState == BEFORE_INTERSECTION && sinceGantry > parking_overrideOffAt) {
-    motor.go();
+    motor->go();
     parkingState = AFTER_INTERSECTION;
   } else if (parkingState == AFTER_INTERSECTION && sinceGantry > parking_stopAt) {
     stop(true);

Buggy/Buggy.h

@@ -22,7 +22,7 @@ class Buggy {
     const unsigned int parking_stopAt = 7000;
 
     const CommTrans *comms;
-    MotorControls motor;
+    MotorControls *motor;
 
     bool going = false;
     Direction travelDirection;
@@ -44,10 +44,10 @@ class Buggy {
     static const short LED_PIN = 13;
 
     Buggy() = delete;
-    Buggy(short ID, CommTrans *c) : comms(c) {
+    Buggy(short ID, MotorControls *m, CommTrans *c) : motor(m), comms(c) {
       pinMode(LED_PIN, OUTPUT);
       pinMode(IR_PIN, INPUT);
-      motor.stop();
+      motor->stop();
       if (ID == 1) {
         travelDirection = CLOCKWISE;
       } else {

Buggy/Buggy.ino

@@ -1,33 +1,41 @@
 #include "CommTrans.h"
 #include "Buggy.h"
 #include "UltraSonic.h"
+#include "Lights.h"
 
-CommTrans* comm;
-Buggy* buggy;
+CommTrans *comm;
+MotorControls *motors;
+Buggy *buggy;
 UltraSonic *sonic;
+Lights *christmasTree;
 
 void setup() {
-  MotorControls().stop();
+  motors = new MotorControls();
+  christmasTree = new Lights();
+  christmasTree->setMotor(motors);
+
   short buggyID = 1;
   comm = new CommTrans(buggyID);
   comm->init();
-  buggy = new Buggy(buggyID, comm);
-  comm->setDefaultHandler(   [] { comm->writeXbee("INVALID"); });
-  comm->addHandler("PING",   [] { comm->writeXbee("PONG"); });
-  comm->addHandler("PONG",   [] { comm->writeXbee("PING"); });
-  comm->addHandler("SYN",    [] { });
-  comm->addHandler("GO",     [] { buggy->go(); });
-  comm->addHandler("STOP",   [] { buggy->stop(); });
-  comm->addHandler("PARK",   [] { buggy->park(); });
+  buggy = new Buggy(buggyID, motors, comm);
+  comm->setDefaultHandler( [] (const String & command) { comm->writeXbee("INVALID: " + command); });
+  comm->addHandler("PING", [] { comm->writeXbee("PONG"); });
+  comm->addHandler("PONG", [] { comm->writeXbee("PING"); });
+  comm->addHandler("SYN",  [] { });
+  comm->addHandler("GO",   [] { buggy->go(); });
+  comm->addHandler("STOP", [] { buggy->stop(); });
+  comm->addHandler("PARK", [] { buggy->park(); });
 
   attachInterrupt(digitalPinToInterrupt(Buggy::IR_PIN), IR_ISR, RISING);
 
   sonic = new UltraSonic(buggy, comm);
+  christmasTree->setUltrasonic(sonic);
 }
 
 void loop() {
   buggy->update();
   sonic->ultraLoop();
+  christmasTree->update();
 }
 
 void serialEvent() {

Buggy/CommTrans.cpp

@@ -37,13 +37,12 @@ void CommTrans::processCommand(char c) {
   if (command != "ACK") {
     writeXbee("ACK");
   }
-  // writeXbee(String("Recieved command: ") + command);
 
   VoidFunction f = handlers.get(command);
   if (f != NULL) {
     f();
   } else if (defaultHandler != NULL) {
-    defaultHandler();
+    defaultHandler(command);
   }
 }
 
@@ -60,6 +59,6 @@ void CommTrans::addHandler(String command, VoidFunction handler) {
   handlers.add(command, handler);
 }
 
-void CommTrans::setDefaultHandler(VoidFunction handler) {
+void CommTrans::setDefaultHandler(StringVoidFunction handler) {
   defaultHandler = handler;
 }

Buggy/CommTrans.h

@@ -13,11 +13,11 @@ class CommTrans {
     void writeXbee(String command) const;
     void processCommand(char c);
     void addHandler(String command, VoidFunction handler);
-    void setDefaultHandler(VoidFunction handler);
+    void setDefaultHandler(StringVoidFunction handler);
 
  private:
     String message;
     HashMap handlers;
-    VoidFunction defaultHandler = NULL;
+    StringVoidFunction defaultHandler = NULL;
     const short my_ID;
 };

Buggy/Functions.h

@@ -1,3 +1,6 @@
 #pragma once
 
+#include <Arduino.h>
+
 typedef void (*VoidFunction)();
+typedef void (*StringVoidFunction)(const String &);

Buggy/Lights.cpp

@@ -0,0 +1,56 @@
+#include "Lights.h"
+
+const int16_t Lights::loopDuration = 500;
+const int16_t Lights::indicatorPeriod = 800;
+const int8_t Lights::leftIndicatorPin = 12;
+const int8_t Lights::rightIndicatorPin = 13;
+const int8_t Lights::pins[] = {5, 6, 7, 8, 9, 10, 11};
+const int8_t Lights::nPins = 7;
+
+Lights::Lights() {
+  for (const auto &pin : pins) {
+    pinMode(pin, OUTPUT);
+    off(pin);
+  }
+  pinMode(leftIndicatorPin, OUTPUT);
+  pinMode(rightIndicatorPin, OUTPUT);
+  on(leftIndicatorPin);
+  on(rightIndicatorPin);
+}
+
+void Lights::setMotor(const MotorControls *motor) {
+  motor_ = motor;
+}
+
+void Lights::setUltrasonic(const UltraSonic *ultra) {
+  ultra_ = ultra;
+}
+
+void Lights::update() {
+  if (motor_ && motor_->getState() == MotorState::STOPPED) {
+    for (int8_t i = 0; i < nPins; i++) {
+      on(pins[i]);
+    }
+    const bool obstacle = (ultra_ && ultra_->isBlockedByObstacle());
+    setLightState(leftIndicatorPin, obstacle);
+    setLightState(rightIndicatorPin, obstacle);
+  } else {
+    const int16_t progress = ((millis() % loopDuration) / (loopDuration / nPins)) % nPins;
+    bool pinOn;
+    for (int8_t i = 0; i < nPins; i++) {
+      pinOn = (progress == i || ((progress + nPins / 2) % nPins) == i);
+      setLightState(pins[i], pinOn);
+    }
+    off(leftIndicatorPin);
+    off(rightIndicatorPin);
+    if(motor_ && motor_->getState() == MotorState::RIGHT_OVERRIDE) {
+      const bool indicatorOn = (millis() % indicatorPeriod) < indicatorPeriod / 2;
+      setLightState(leftIndicatorPin, indicatorOn);
+      off(rightIndicatorPin);
+    } else if(motor_ && motor_->getState() == MotorState::LEFT_OVERRIDE) {
+      const bool indicatorOn = (millis() % indicatorPeriod) < indicatorPeriod / 2;
+      off(leftIndicatorPin);
+      setLightState(rightIndicatorPin, indicatorOn);
+    }
+  }
+}

Buggy/Lights.h

@@ -0,0 +1,28 @@
+#include <Arduino.h>
+
+#include "MotorControls.h"
+#include "UltraSonic.h"
+
+class Lights {
+ public:
+    Lights();
+    void setMotor(const MotorControls *);
+    void setUltrasonic(const UltraSonic *);
+    void update();
+
+ private:
+    const MotorControls* motor_;
+    const UltraSonic* ultra_;
+
+    static const int16_t loopDuration;
+    static const int16_t indicatorPeriod;
+    static const int8_t leftIndicatorPin;
+    static const int8_t rightIndicatorPin;
+    static const int8_t nPins;
+    static const int8_t pins[];
+
+    // May have to use non-intuitive polarities if using an NPN emitter follower
+    void setLightState(uint8_t pin, bool on) const { digitalWrite(pin, on ? LOW : HIGH); }
+    void on(uint8_t pin) const { setLightState(pin, true); }
+    void off(uint8_t pin) const { setLightState(pin, false); }
+};

Buggy/UltraSonic.h

@@ -32,4 +32,6 @@ class UltraSonic {
   }
 
   void ultraLoop();
+
+  bool isBlockedByObstacle() { return obstacle; }
 };