src/obd2-signals.hpp

   1 /*
   2  * Copyright (C) 2015, 2016 "IoT.bzh"
   3  * Author "Romain Forlot" <romain.forlot@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #pragma once
  19
  20 #include <vector>
  21
  22 #include "uds/uds.h"
  23 #include "can-bus.hpp"
  24 #include "can-message.hpp"
  25
  26 #include "low-can-binding.hpp"
  27
  28 enum UNIT {
  29         POURCENT,
  30         DEGREES_CELSIUS,
  31         KPA,
  32         RPM,
  33         GRAMS_SEC,
  34         SECONDS,
  35         KM,
  36         KM_H,
  37         PA,
  38         NM,
  39         INVALID
  40 };
  41
  42 /**
  43  *      @brief A representation of an OBD-II PID.
  44  *
  45  * pid - The 1 byte PID.
  46  * name - A human readable name to use for this PID when published.
  47  * min - minimum value for this pid
  48  * max - maximum value for this pid
  49  * unit - unit used
  50  * frequency - The frequency to request this PID if supported by the vehicle
  51  *              when automatic, recurring OBD-II requests are enabled.
  52  *      supported - is it supported by the vehicle. Initialized after scan
  53  */
  54 typedef struct _Obd2Pid {
  55         uint8_t pid;
  56         const char* generic_name;
  57         const int min;
  58         const int max;
  59         enum UNIT unit;
  60         int frequency;
  61         bool supported;
  62 } Obd2Pid;
  63
  64 std::vector<Obd2Pid>& get_obd2_signals();
  65 uint32_t get_signal_id(const Obd2Pid& sig);
  66 void find_obd2_signals(const openxc_DynamicField &key, std::vector<Obd2Pid*>& found_signals);
  67
  68 bool is_obd2_response(can_message_t can_message);
  69
  70 /**
  71  * @brief - Object to handle obd2 session with pre-scan of supported pid
  72  * then request them regularly
  73  */
  74 class obd2_handler_t {
  75         private:
  76
  77         public:
  78                 obd2_handler_t();
  79                 /**
  80                  * @brief:
  81                  *
  82                  * Returns
  83                  */
  84                 void find_obd2_pid(const char *name, std::vector<Obd2Pid> *pids);
  85
  86                 /**
  87                  * @brief Check if a request is an OBD-II PID request.
  88                  *
  89                  * @return true if the request is a mode 1 request and it has a 1 byte PID.
  90                  */
  91                 bool is_obd2_request(DiagnosticRequest *request);
  92
  93                 /**
  94                 * @brief Check if requested signal name is an obd2 pid
  95                 *
  96                 * @return true if name began with obd2 else false.
  97                 */
  98                 bool is_obd2_signal(const char *name);
  99
 100                 /**
 101                 * @brief Decode the payload of an OBD-II PID.
 102                 *
 103                 * This function matches the type signature for a DiagnosticResponseDecoder, so
 104                 * it can be used as the decoder for a DiagnosticRequest. It returns the decoded
 105                 * value of the PID, using the standard formulas (see
 106                 * http://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_01).
 107                 *
 108                 * @param[in] DiagnosticResponse response - the received DiagnosticResponse (the data is in response.payload,
 109                 *  a byte array). This is most often used when the byte order is
 110                 *  signiticant, i.e. with many OBD-II PID formulas.
 111                 * @param[in] float parsed_payload - the entire payload of the response parsed as an int.
 112                 */
 113                 float handle_obd2_pid(const DiagnosticResponse* response, float parsedPayload);
 114 };