User/dominic/embedded teaser

Dominic Choi.txt

@@ -0,0 +1 @@
+Solar Car!

Recruit-Training/Advanced-Recruit-Training/Embedded-Teaser/Training/Core/Src/Training.c

@@ -1,9 +1,116 @@
 #include "Training.h"
 
-uint8_t outputArray[3];
-uint8_t validData; // Set bits 0, 1, 2 if the input array elements were valid
+uint8_t outputArray[3] = {0,0,0};
+uint8_t validData = 0; // Set bits 0, 1, 2 if the input array elements were valid
+
+// Defines for Motors
+#define MOTOR_FWD 0b10000001
+#define MOTOR_BWD 0b11000001
+#define MOTOR_ON 0b10000000
+#define VELOCITY 0b111110
+#define VELOCITY_SIGN  0b1000000
+#define DIRECTION 0b1
+
+// Defines for Headlights
+#define HEADS 0b111
+#define OFF 0b1
+#define LOW 0b10
+#define HIGH 0b100
+
+// Defines for Blinkers
+#define BLINKERS 0b111000
+#define RIGHT 0b1
+#define LEFT 0b10
+#define HAZARDS 0b100
 
 void trainingTask(uint8_t* data)
 {
+    // Extract Data
+    uint8_t motor1 = data[0];
+    uint8_t motor2 = data[1];
+    uint8_t lights = data[2];
+
+    // Velocities
+    uint8_t m1_velocity = (motor1 & VELOCITY) >> 1;
+    uint8_t m2_velocity = (motor2 & VELOCITY) >> 1;
+
+    // Motor On/Off
+    uint8_t m1_status = (motor1 & MOTOR_ON) >> 7;
+    uint8_t m2_status = (motor2 & MOTOR_ON) >> 7;
+
+    // Motors are synced if velocities are the same 
+    // and both on or both off
+    uint8_t isSynced = (m1_velocity == m2_velocity) // Velocities Equal
+                    && (m1_status == m2_status);    // Both on or both off
+
+    if(isSynced){ // Velocity and Status are equal
+        // Separate motor directions
+        uint8_t m1_dir = motor1 & DIRECTION;
+        uint8_t m2_dir = motor2 & DIRECTION;
+
+        // Sign bit of velocity
+        uint8_t m1_vnbit = motor1 & VELOCITY_SIGN;
+        uint8_t m2_vnbit = motor2 & VELOCITY_SIGN;
+
+        if(m1_dir != m1_vnbit       // If direction is opposite to the velocity sign
+        && m2_dir != m2_vnbit) {    
+            if(m1_dir == m2_dir){    // Directions are the same
+                outputArray[0] = data[0];
+                outputArray[1] = data[1];
+                validData |= 0b00000011;
+            }
+        } else if ((m1_status && m2_status) == 0){     // or both motors are off
+            outputArray[0] = data[0];
+            outputArray[1] = data[1];
+            validData |= 0b00000011;
+
+        } else {
+            outputArray[0] = 0;
+            outputArray[1] = 0;
+            validData = 0b000000000;
+        }
+    }
+
+    // Valid Positive/Negative Velocity
+    uint8_t headlights = (lights & HEADS);
+    uint8_t blinkers = (lights & BLINKERS) >> 3;
+
+    // Separate Headlight Bits
+    uint8_t off = headlights & OFF;
+    uint8_t low = headlights & LOW;
+    uint8_t high = headlights & HIGH;
+
+    // Separate Blinker Bits
+    uint8_t right = blinkers & RIGHT;
+    uint8_t left = blinkers & LEFT;
+    uint8_t hazards = blinkers & HAZARDS;
+
+    // Valid Booleans
+    uint8_t isValidHead = 0;
+    uint8_t isValidBlink = 0;
+
+    // Check Headights validity
+    // Boolean for Valid Headlights: 
+        // ~High*~Low*Off + ~High*Low*~Off + High*~Low*~Off
+        // high XOR low XOR off AND NOT(high AND low AND off)
+    if ((high ^ low ^ off) 
+        && !(high && low && off)){
+        isValidHead = 1;
+    }
+
+    // L = Left, R = Right, H = Hazards
+    // Boolean for Valid Blinkers: 
+        // Right*Low*Haz + ~Right~Left + ~Right~Haz + ~Left~Haz
+    if((left && right && hazards)
+        || (!right && !left)
+        || (!right && !hazards)
+        || (!left && !hazards)){
+            isValidBlink = 1;
+    }
 
+    // If Headlights and Blinkers are both valid
+    if(isValidHead && isValidBlink){
+            outputArray[2] = data[2];
+            validData |= 0b00000100;
+    }
 }

Recruit-Training/Advanced-Recruit-Training/Embedded-Teaser/Training/Test/TrainingTest.c

@@ -5,27 +5,117 @@
 extern uint8_t outputArray[3];
 extern uint8_t validData;
 
+uint8_t expected_output[3] = {0, 0, 0};
+
+#define VALID 0b111
+#define INVALID 0
+#define INVALID_MOTORS 0b100
+#define INVALID_LIGHTS 0b11
+
+void resetOutput();
+
 void runTrainingTests()
 {
-    // Run all the tests here using RUN_TEST()
+    UNITY_BEGIN();
+    RUN_TEST(test_EverythingValid);
+    RUN_TEST(test_EverythingInvalid);
+    RUN_TEST(test_OnlyLightsInvalid);
+    RUN_TEST(test_OnlyMotorsInvalid);
+    return UNITY_END();
 }
 
-void test_EverythingValid()
-{
+void test_EverythingValid(void) {
+    uint8_t m1, m2;
+    m1 = m2 = 0b1001001;
 
-}
+    uint8_t l = 0b0001100;
 
-void test_EverythingInvalid()
-{
+    uint8_t valid_data[3] = {m1, m2, l};
+
+    trainingTask(valid_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(valid_data, outputArray, 3, "Everything Valid Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(0b00000111, validData, "Everything Valid validData Incorrect");
+
+    resetOutput(0,0,0);
+
+    m1 = 0b00000001;
+    m2 = 0b01000001;
+
+    valid_data[0] = expected_output[0] = m1;
+    valid_data[1] = expected_output[1] = m2;
+
+    trainingTask(valid_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(valid_data, outputArray, 3, "Everything Valid Array incorrect 2");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(0b00000111, validData, "Everything Valid validData Incorrect2");
 
 }
 
-void test_OnlyLightsInvalid()
-{
+void test_EverythingInvalid(void) {
+    resetOutput();
+    uint8_t invalid_data[3] = {0xFF, 0xF0, 0xFF};   // Invalid data, should not change outputArray
+    uint8_t expected_output[3] = {0, 0, 0};         // Expected output for invalid data
+    trainingTask(invalid_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_output, outputArray, 3, "Everything Invalid Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(0, validData, "Invalid Data Flag Incorrect");
+}
 
+void test_OnlyLightsInvalid(void) {
+    uint8_t m1, m2;
+
+    resetOutput();
+    m1 = m2 = 0b10010111;
+    uint8_t expected_output[3] = {m1, m2, 0};          // Expected output for invalid data
+
+    uint8_t invalid_lights_data[3] = {m1, m2, 0b1000000};
+    trainingTask(invalid_lights_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_output, outputArray, 3, "Headlights in no states Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(INVALID_LIGHTS, validData, "Headlights in no states not caught");
+
+    resetOutput();
+    invalid_lights_data[2] = 0b1100000;
+    trainingTask(invalid_lights_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_output, outputArray, 3, "Headlights in multiple states Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(INVALID_LIGHTS, validData, "Headlights in multiple states not caught");
+
+    resetOutput();
+    invalid_lights_data[2] = 0b10011000;
+    trainingTask(invalid_lights_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_output, outputArray, 3, "Both blinkers without hazards Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(INVALID_LIGHTS, validData, "Both blinkers without hazards not caught");
+
+    resetOutput();
+    invalid_lights_data[2] = 0b1101010;
+    trainingTask(invalid_lights_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_output, outputArray, 3, "Not both blinkers with hazards Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(INVALID_LIGHTS, validData, "Not both blinkers with Hazards on not caught");
 }
 
-void test_OnlyMotorsInvalid()
-{
+void test_OnlyMotorsInvalid(void) {
+    uint8_t l = 0b0000001;
+    uint8_t expected_output[3] = {0, 0, l};
 
+    resetOutput();
+    uint8_t invalid_motors_data[3] = {0b11100111, 0b10101001, l};
+    trainingTask(invalid_motors_data);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_output, outputArray, 3, "Unsynced Motors Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(INVALID_MOTORS, validData, "Unsynced Motors validData incorrect");
+
+    resetOutput();
+    uint8_t invalid_motors_data2[3] = {0b11001001, 0b01001001, l};
+    trainingTask(invalid_motors_data2);
+    TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected_output, outputArray, 3, "Both Motors not on: Array incorrect");
+    TEST_ASSERT_EQUAL_UINT8_MESSAGE(INVALID_MOTORS, validData, "Both Motors not on: validData incorrect");
 }
+
+//
+void resetOutput(){
+    outputArray[0] = 0;
+    outputArray[1] = 0;
+    outputArray[2] = 0;
+
+    // expected_output[0] = a;
+    // expected_output[1] = b;
+    // expected_output[2] = c;
+
+    validData = 0;
+}