diff --git a/pldmtool/pldm_platform_cmd.cpp b/pldmtool/pldm_platform_cmd.cpp
index 46d0744..6a75cf8 100644
--- a/pldmtool/pldm_platform_cmd.cpp
+++ b/pldmtool/pldm_platform_cmd.cpp
@@ -1643,6 +1643,163 @@
     uint8_t sensorRearm;
 };
 
+class GetSensorReading : public CommandInterface
+{
+  public:
+    ~GetSensorReading() = default;
+    GetSensorReading() = delete;
+    GetSensorReading(const GetSensorReading&) = delete;
+    GetSensorReading(GetSensorReading&&) = default;
+    GetSensorReading& operator=(const GetSensorReading&) = delete;
+    GetSensorReading& operator=(GetSensorReading&&) = delete;
+
+    explicit GetSensorReading(const char* type, const char* name,
+                              CLI::App* app) :
+        CommandInterface(type, name, app)
+    {
+        app->add_option(
+               "-i, --sensor_id", sensorId,
+               "Sensor ID that is used to identify and access the sensor")
+            ->required();
+        app->add_option("-r, --rearm", rearm,
+                        "Manually re-arm EventState after "
+                        "responding to this request")
+            ->required();
+    }
+
+    std::pair<int, std::vector<uint8_t>> createRequestMsg() override
+    {
+        std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
+                                        PLDM_GET_SENSOR_READING_REQ_BYTES);
+        auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
+
+        auto rc = encode_get_sensor_reading_req(instanceId, sensorId, rearm,
+                                                request);
+
+        return {rc, requestMsg};
+    }
+
+    void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
+    {
+        uint8_t completionCode = 0;
+        uint8_t sensorDataSize = 0;
+        uint8_t sensorOperationalState = 0;
+        uint8_t sensorEventMessageEnable = 0;
+        uint8_t presentState = 0;
+        uint8_t previousState = 0;
+        uint8_t eventState = 0;
+        std::array<uint8_t, sizeof(uint32_t)>
+            presentReading{}; // maximum size for the present Value is uint32
+                              // according to spec DSP0248
+
+        auto rc = decode_get_sensor_reading_resp(
+            responsePtr, payloadLength, &completionCode, &sensorDataSize,
+            &sensorOperationalState, &sensorEventMessageEnable, &presentState,
+            &previousState, &eventState, presentReading.data());
+
+        if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
+        {
+            std::cerr << "Response Message Error: "
+                      << "rc=" << rc << ",cc=" << (int)completionCode
+                      << std::endl;
+            return;
+        }
+
+        ordered_json output;
+        output["sensorDataSize"] = getSensorState(sensorDataSize,
+                                                  &sensorDataSz);
+        output["sensorOperationalState"] =
+            getSensorState(sensorOperationalState, &sensorOpState);
+        output["sensorEventMessageEnable"] =
+            getSensorState(sensorEventMessageEnable, &sensorEventMsgEnable);
+        output["presentState"] = getSensorState(presentState, &sensorPresState);
+        output["previousState"] = getSensorState(previousState,
+                                                 &sensorPresState);
+        output["eventState"] = getSensorState(eventState, &sensorPresState);
+
+        switch (sensorDataSize)
+        {
+            case PLDM_SENSOR_DATA_SIZE_UINT8:
+            {
+                output["presentReading"] =
+                    *(reinterpret_cast<uint8_t*>(presentReading.data()));
+                break;
+            }
+            case PLDM_SENSOR_DATA_SIZE_SINT8:
+            {
+                output["presentReading"] =
+                    *(reinterpret_cast<int8_t*>(presentReading.data()));
+                break;
+            }
+            case PLDM_SENSOR_DATA_SIZE_UINT16:
+            {
+                output["presentReading"] =
+                    *(reinterpret_cast<uint16_t*>(presentReading.data()));
+                break;
+            }
+            case PLDM_SENSOR_DATA_SIZE_SINT16:
+            {
+                output["presentReading"] =
+                    *(reinterpret_cast<int16_t*>(presentReading.data()));
+                break;
+            }
+            case PLDM_SENSOR_DATA_SIZE_UINT32:
+            {
+                output["presentReading"] =
+                    *(reinterpret_cast<uint32_t*>(presentReading.data()));
+                break;
+            }
+            case PLDM_SENSOR_DATA_SIZE_SINT32:
+            {
+                output["presentReading"] =
+                    *(reinterpret_cast<int32_t*>(presentReading.data()));
+                break;
+            }
+            default:
+            {
+                std::cerr << "Unknown Sensor Data Size : "
+                          << static_cast<int>(sensorDataSize) << std::endl;
+                break;
+            }
+        }
+
+        pldmtool::helper::DisplayInJson(output);
+    }
+
+  private:
+    uint16_t sensorId;
+    uint8_t rearm;
+
+    const std::map<uint8_t, std::string> sensorDataSz = {
+        {PLDM_SENSOR_DATA_SIZE_UINT8, "uint8"},
+        {PLDM_SENSOR_DATA_SIZE_SINT8, "uint8"},
+        {PLDM_SENSOR_DATA_SIZE_UINT16, "uint16"},
+        {PLDM_SENSOR_DATA_SIZE_SINT16, "uint16"},
+        {PLDM_SENSOR_DATA_SIZE_UINT32, "uint32"},
+        {PLDM_SENSOR_DATA_SIZE_SINT32, "uint32"}};
+
+    static inline const std::map<uint8_t, std::string> sensorEventMsgEnable{
+        {PLDM_NO_EVENT_GENERATION, "Sensor No Event Generation"},
+        {PLDM_EVENTS_DISABLED, "Sensor Events Disabled"},
+        {PLDM_EVENTS_ENABLED, "Sensor Events Enabled"},
+        {PLDM_OP_EVENTS_ONLY_ENABLED, "Sensor Op Events Only Enabled"},
+        {PLDM_STATE_EVENTS_ONLY_ENABLED, "Sensor State Events Only Enabled"}};
+
+    std::string getSensorState(uint8_t state,
+                               const std::map<uint8_t, std::string>* cont)
+    {
+        auto typeString = std::to_string(state);
+        try
+        {
+            return cont->at(state);
+        }
+        catch (const std::out_of_range& e)
+        {
+            return typeString;
+        }
+    }
+};
+
 class GetNumericEffecterValue : public CommandInterface
 {
   public:
@@ -1825,6 +1982,11 @@
         "GetNumericEffecterValue", "get the numeric effecter value");
     commands.push_back(std::make_unique<GetNumericEffecterValue>(
         "platform", "getNumericEffecterValue", getNumericEffecterValue));
+
+    auto getSensorReading = platform->add_subcommand(
+        "GetSensorReading", "get the numeric sensor reading");
+    commands.push_back(std::make_unique<GetSensorReading>(
+        "platform", "getSensorReading", getSensorReading));
 }
 
 void parseGetPDROption()