Human motion detection (PIR sensor) [14% : 8%]

src/Robot/0_Types.ino

@@ -0,0 +1,11 @@
+/*
+ * Custom Types
+ */
+struct uint8_range {
+  uint8_t min;
+  uint8_t max;
+};
+struct uint16_range {
+  uint16_t min;
+  uint16_t max;
+};

src/Robot/1_State.ino

@@ -0,0 +1,56 @@
+/* 
+ * States Definition
+ * =====================
+ */
+
+/*
+ * Decisions
+ * =========
+ */
+struct DECISION {
+    uint16_t  timeSincePreviousDecision = 0;
+    uint8_t   weight = 0;
+};
+
+struct DECISION_STATE {
+  DECISION eyesBlink;
+  DECISION eyesPupils;
+  DECISION sleepMode;
+};
+
+
+// Environment state
+struct ENVIRONMENT_STATE {
+  bool isHumanDetected          = true;
+  uint16_t timeHumanDetected    = 0;
+  uint16_t timeHumanLost        = 0;
+};
+
+// Eyes state
+struct EYES_STATE {
+    byte*   currentFrame;
+    bool    isOpened          = false;
+    uint8_t pupilsPosition[2] = {0, 0};
+    uint8_t pupilsSize[2]     = {2, 2};
+};
+
+// Global state store
+struct STATE {
+  DECISION_STATE Decision;
+  ENVIRONMENT_STATE Environment;
+  EYES_STATE Eyes;
+};
+
+/* 
+ * States Initialization
+ * =====================
+ */
+STATE State = {};
+
+/*
+ * Public Methods
+ */
+
+ uint16_t getTime() {
+  return millis() / 1000;
+ }

src/Robot/2_Animation.ino → src/Robot/3_Animation.ino

@@ -5,8 +5,17 @@
 
 #include <QList.h>
 
+const uint8_t ANIMATION_BUFFER_SIZE = 32;
+
 // Eyes Animation Queue
 QList <byte*> animationQueue;
+//byte animationBuffer[ANIMATION_BUFFER_SIZE][8];
+//
+//void initAnimationQueue() {
+//    for (uint8_t i = 0; i < ANIMATION_BUFFER_SIZE; i++) {
+//      animationBuffer[i] = NULL;
+//    }
+//}
 
 void addAnimationSequence(
     const byte animationBitmap[][8], 
@@ -33,3 +42,13 @@ byte* popFrameFromAnimationQueue() {
 bool isAnimationQueueEmpty() {
     return animationQueue.size() == 0;
 }
+
+//byte findEmptyAnimationBuffer() {
+//    for (uint8_t i = 0; i < ANIMATION_BUFFER_SIZE - 1; i++) {
+//        if(animationBuffer[i] == NULL) {
+//            return i;
+//        }
+//    } 
+//
+//    return ANIMATION_BUFFER_SIZE - 1;
+//}

src/Robot/3_Eyes.ino → src/Robot/4_Eyes.ino

@@ -43,19 +43,25 @@ void initEyes() {
 
 
 void closeEyes() {
+    // Update state
+    State.Eyes.isOpened = false;
+
     // Stop blinking when my eye are closed
-    resetEyesBlinkDecision(false);
+    resetEyesBlinkDecision();
 
     // Add animation sequence to queue
     addAnimationSequence(eyeBlinkAnimationBitmap, EYES_CLOSE_ANIMATION_SEQUENCE, sizeof(EYES_CLOSE_ANIMATION_SEQUENCE));
 }
 
 void openEyes() {
+    // Update state
+    State.Eyes.isOpened = true;
+
     // Add animation sequence to queue
     addAnimationSequence(eyeBlinkAnimationBitmap, EYES_OPEN_ANIMATION_SEQUENCE, sizeof(EYES_OPEN_ANIMATION_SEQUENCE));
 
     // When my eyes are open I want to blink
-    resetEyesBlinkDecision(true);
+    resetEyesBlinkDecision();
 }
 
 /*

src/Robot/5_Environment.ino

@@ -0,0 +1,68 @@
+// Environment sensors thread
+Thread environmentThread = Thread();
+
+const uint16_t ENVIRONMENT_SCAN_FREQUENCY = 500;          // Environment sensors read frequency, in ms
+
+void initEnvironmet() {
+    pinMode(PIN_PIR_SENSOR, INPUT);
+
+    environmentThread.onRun(onEnvironmentUpdate);
+    environmentThread.setInterval(ENVIRONMENT_SCAN_FREQUENCY);
+}
+
+/*
+ * Public Methods
+ */
+bool isHumanDetected() {
+  return State.Environment.isHumanDetected;
+}
+
+uint16_t getTimeSinceHumanDetected() {
+  return getTime() - State.Environment.timeHumanDetected;
+}
+
+uint16_t getTimeSinceHumanLost() {
+  return getTime() - State.Environment.timeHumanLost;
+}
+
+
+/*
+ * Events
+ */
+void onHumanDetected() {
+  if (!State.Environment.isHumanDetected) {
+    // TODO: State change event
+  }
+
+  State.Environment.isHumanDetected = true;
+  State.Environment.timeHumanDetected = getTime();
+}
+
+void onHumanLost() {
+  State.Environment.isHumanDetected = false;
+  State.Environment.timeHumanLost = getTime();
+}
+
+
+/*
+ * Asynchronous thread process
+ * ===========================
+ */
+void runEnvironmentThread() {
+  if(environmentThread.shouldRun()) {
+      environmentThread.run();
+  }
+}
+
+
+/* 
+ * Thread callback 
+ * ---------------
+ */
+void onEnvironmentUpdate() {
+  bool pirSensorValue = digitalRead(PIN_PIR_SENSOR);
+
+  if (pirSensorValue) {
+    onHumanDetected();
+  }
+}