add get_device_type function

Author: liam-teale

include/common/result.hpp

@@ -41,20 +41,6 @@ class ResultError {
     std::optional<RuntimeData> runtime_data;
 };
 
-/**
- * @brief Unknown Error
- *
- */
-class UnknownError : public ResultError {
-  public:
-    template<typename T>
-        requires std::convertible_to<T, std::string>
-    UnknownError(T&& message)
-        : message(std::forward<T>(message)) {}
-
-    std::string message;
-};
-
 /**
  * @brief Trait to define a "sentinel" value for types indicating an error state.
  * @tparam T Type to provide a sentinel value for.

include/pros/devices/devices.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "common/result.hpp"
+#include "pros/devices/port.hpp"
 
 namespace zest {
 
@@ -22,27 +23,34 @@ enum class DeviceType {
     Rotation,
     Serial,
     Vision,
+    Invalid,
     None,
     Unknown,
 };
 
+/**
+ * @brief Get the type of the device connected to the given smart port
+ *
+ * @param port
+ * @return DeviceType
+ */
+DeviceType get_device_type(SmartPort port);
+
 /**
  * @brief V5 Port Mismatch Error
  *
  */
-class V5PortMismatchError : public ResultError {
+class SmartPortError : public ResultError {
   public:
     /**
      * @brief Construct a new V5 Port Mismatch Error object
      *
      * @param expected the device expected to be on the port
      * @param actual the device that is actually on the port
      */
-    V5PortMismatchError(DeviceType expected, DeviceType actual)
-        : expected(expected),
-          actual(actual) {}
+    SmartPortError(DeviceType expected, std::optional<DeviceType> actual = std::nullopt);
 
     DeviceType expected;
-    DeviceType actual;
+    std::optional<DeviceType> actual;
 };
 } // namespace zest

src/devices/devices.cpp

@@ -0,0 +1,55 @@
+#include "pros/devices/devices.hpp"
+
+#include "v5_api_patched.h"
+#include "v5_apitypes_patched.h"
+
+namespace zest {
+DeviceType get_device_type(SmartPort port) {
+    // if the port number is greater than 21, return invalid
+    if (port.as_number() > 21)
+        return DeviceType::Invalid;
+
+    // vexDeviceGetStatus writes a buffer of V5_DeviceType that is V5_MAX_DEVICE_PORTS long.
+    // This is the only way to get the device type on a port
+    std::array<V5_DeviceType, V5_MAX_DEVICE_PORTS> types;
+    vexDeviceGetStatus(types.data());
+
+    // get the device type on the given port
+    switch (types.at(port.as_index())) {
+        case kDeviceTypeNoSensor:
+            return DeviceType::None;
+        case kDeviceTypeMotorSensor:
+            return DeviceType::Motor;
+        case kDeviceTypeAbsEncSensor:
+            return DeviceType::Rotation;
+        case kDeviceTypeImuSensor:
+            return DeviceType::Imu;
+        case kDeviceTypeDistanceSensor:
+            return DeviceType::Distance;
+        case kDeviceTypeRadioSensor:
+            return DeviceType::Radio;
+        case kDeviceTypeTetherSensor:
+            return DeviceType::Controller;
+        case kDeviceTypeVisionSensor:
+            return DeviceType::Vision;
+        case kDeviceTypeAdiSensor:
+            return DeviceType::AdiExpander;
+        case kDeviceTypeOpticalSensor:
+            return DeviceType::Optical;
+        case kDeviceTypeGpsSensor:
+            return DeviceType::Gps;
+        case kDeviceTypeAiVisionSensor:
+            return DeviceType::AiVision;
+        case kDeviceTypeBumperSensor:
+            return DeviceType::Bumper;
+        case kDeviceTypeGenericSerial:
+            return DeviceType::Serial;
+        default:
+            return DeviceType::Unknown;
+    }
+}
+
+SmartPortError::SmartPortError(DeviceType expected, std::optional<DeviceType> actual)
+    : expected(expected),
+      actual(actual) {}
+} // namespace zest