Method processPID

src/ELMduino.cpp:686–750

double ELM327::processPID(const uint8_t& service, const uint16_t& pid, const uint8_t& num_responses, const uint8_t& numExpectedBytes, const float& scaleFactor, const float& bias) Description: ------------ * Queries ELM327 for a specific type of vehicle telemetry data Inputs: ------- * uint8_t service - The diagnostic service ID. 01 is "Show current data" * uint16_t pi

  * double - The PID value if successfully received, else 0.0
*/
double ELM327::processPID(const uint8_t&  service,
                          const uint16_t& pid,
                          const uint8_t&  num_responses,
                          const uint8_t&  numExpectedBytes,
                          const double&   scaleFactor,
                          const float&    bias)
{
    if (nb_query_state == SEND_COMMAND)
    {
        queryPID(service, pid, num_responses);
        nb_query_state = WAITING_RESP;
    }
    else if (nb_query_state == WAITING_RESP)
    {
        get_response();
        if (nb_rx_state == ELM_SUCCESS)
        {
            nb_query_state = SEND_COMMAND; // Reset the query state machine for next command
            findResponse();
            
            /* This data manipulation seems duplicative of the responseByte_0, responseByte_1, etc vars and it is.
               The duplcation is deliberate to provide a clear way for the calculator functions to access the relevant
               data bytes from the response in the format they are commonly expressed in and without breaking backward
               compatability with existing code that may be using the responseByte_n vars. 
               
               In addition, we need to place the response values into static vars that can be accessed by the (static) 
               calculator functions. A future (breaking!) change could be made to eliminate this duplication. 
            */
            uint8_t responseBits = numExpectedBytes * 8;
            uint8_t extractedBytes[8] = {0};  // Store extracted bytes

            // Extract bytes only if shift is non-negative
            for (int i = 0; i < numExpectedBytes; i++)
            {
                int shiftAmount = responseBits - (8 * (i + 1));             // Compute shift amount
                if (shiftAmount >= 0) {                                     //  Ensure valid shift
                    extractedBytes[i] = (response >> shiftAmount) & 0xFF;   // Extract byte
                }
            }

            // Assign extracted values to response_A, response_B, ..., response_H safely
            response_A = extractedBytes[0];
            response_B = extractedBytes[1];
            response_C = extractedBytes[2];
            response_D = extractedBytes[3];
            response_E = extractedBytes[4];
            response_F = extractedBytes[5];
            response_G = extractedBytes[6];
            response_H = extractedBytes[7];
            
            double (*calculator)() = selectCalculator(pid);

            if (nullptr == calculator) {
                //Use the default scaleFactor + Bias calculation
                return conditionResponse(numExpectedBytes, scaleFactor, bias);
            }
            else {
                return conditionResponse(calculator);