unsigned short commandCount; /*!< commandCount - The number of CanCommmands defined for this message set.*/
} CanMessageSet;
+class can_message_set_t
+{
+ private:
+ uint8_t index; /*!<index - A numerical ID for the message set, ideally the index in an array
+ * for fast lookup*/
+ const std::string name; /*!< name - The name of the message set.*/
+ uint8_t can_bus_count; /*!< busCount - The number of CAN buses defined for this message set.*/
+ unsigned short can_message_count; /*!< messageCount - The number of CAN messages (across all buses) defined for
+ * this message set.*/
+ unsigned short can_signal_count; /*!< signalCount - The number of CAN signals (across all messages) defined for
+ * this message set.*/
+ unsigned short can_command_count; /*!< commandCount - The number of CanCommmands defined for this message set.*/
+ unsigned short obd2_signal_count; /*!< commandCount - The number of obd2 signals defined for this message set.*/
+};
+
/** Public: Return the currently active CAN configuration. */
CanMessageSet* getActiveMessageSet();
#include "obd2/obd2-signals.hpp"
#include "low-can-binding.hpp"
-std::vector<std::vector<CanMessageDefinition>> CAN_MESSAGES = {
- {
- {0x620, CanMessageFormat::STANDARD, {10, 0, nullptr}, false, (uint8_t)NULL},
- {0x442, CanMessageFormat::STANDARD, {10, 0, nullptr}, false, (uint8_t)NULL},
- },
-};
-
-/**
- * @brief Dumb SIGNALS array. It is composed by CanMessageSet
- * SIGNALS[MESSAGE_SET_ID][CanSignal]
- */
-std::vector<std::vector<CanSignal>> SIGNALS = {
- {
- {&(CAN_MESSAGES[MESSAGE_SET_ID][0]), "can.driver_door.open", 2, 4, 1.000000, 0.000000, 0.000000, 0.000000, {10, 0, nullptr}, false, true, nullptr, 0, false, decoder_t::booleanDecoder, nullptr, false, 0.0},
- {&(CAN_MESSAGES[MESSAGE_SET_ID][1]), "can.driver_door.close", 0, 4, 1.000000, 0.000000, 0.000000, 0.000000, {10, 0, nullptr}, false, true, nullptr, 0, false, decoder_t::booleanDecoder, nullptr, false, 0.0}
- },
-};
-
-/**
- * @fn std::vector<CanSignal>& get_can_signals()
- *
- * @return A reference to a vector of signals
- */
-std::vector<CanSignal>& get_can_signals()
-{
- return SIGNALS[MESSAGE_SET_ID];
-}
-
-/**
- * @fn size_t getSignalCount()
- *
- * @return the length of the array returned by get_can_signals().
- */
-size_t getSignalCount()
-{
- return SIGNALS[MESSAGE_SET_ID].size();
-}
-
-/**
- * @brief Retrieve can arbitration id of a given CanSignal
- *
- * @param[in] CanSignal& - a const reference to a CanSignal
- *
- * @return uint32_t - unsigned integer representing the arbitration id.
- */
-uint32_t get_signal_id(const CanSignal& sig)
-{
- return sig.message->id;
-}
-
/**
* @fn void find_can_signals(const openxc_DynamicField& key, std::vector<CanSignal*>& found_signals)
* @brief return signals name found searching through CAN_signals and OBD2 pid
#define MESSAGE_SET_ID 0
-extern std::mutex subscribed_signals_mutex;
-std::mutex& get_subscribed_signals_mutex();
-
-/**
- * @brief return the subscribed_signals map.
- *
- * return std::map<std::string, struct afb_event> - map of subscribed signals.
- */
-extern std::map<std::string, struct afb_event> subscribed_signals;
-std::map<std::string, struct afb_event>& get_subscribed_signals();
-
/**
* @brief The type signature for a CAN signal decoder.
*
};
typedef struct CanSignal CanSignal;
-std::vector<CanSignal>& get_can_signals();
-
-size_t getSignalCount();
-
void find_can_signals(const openxc_DynamicField &key, std::vector<CanSignal*>& found_signals);
-
-uint32_t get_signal_id(const CanSignal& sig);
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <configuration.hpp>
+
+#define OBD2_FUNCTIONAL_BROADCAST_ID 0x7df
+
+/*
+* Pre-defined OBD-II PIDs to query for if supported by the vehicle.
+*/
+ std::vector<obd2_signals_t> OBD2_PIDS = {
+ { 0x04, "obd2.engine.load", 0, 100, POURCENT, 5, false},
+ { 0x05, "obd2.engine.coolant.temperature", -40, 215, DEGREES_CELSIUS, 1, false},
+ { 0x0a, "obd2.fuel.pressure", 0, 765, KPA, 1, false},
+ { 0x0b, "obd2.intake.manifold.pressure", 0, 255, KPA, 1, false},
+ { 0x0c, "obd2.engine.speed", 0, 16383, RPM, 5, false},
+ { 0x0d, "obd2.vehicle.speed", 0, 255, KM_H, 5, false},
+ { 0x0f, "obd2.intake.air.temperature", -40, 215, DEGREES_CELSIUS, 1, false},
+ { 0x10, "obd2.mass.airflow", 0, 655, GRAMS_SEC, 5, false},
+ { 0x11, "obd2.throttle.position", 0, 100, POURCENT, 5, false},
+ { 0x1f, "obd2.running.time", 0, 65535, SECONDS, 1, false},
+ { 0x2d, "obd2.EGR.error", -100, 99, POURCENT, 0, false},
+ { 0x2f, "obd2.fuel.level", 0, 100, POURCENT, 1, false},
+ { 0x33, "obd2.barometric.pressure", 0, 255, KPA, 1, false},
+ { 0x4c, "obd2.commanded.throttle.position", 0, 100, POURCENT, 1, false},
+ { 0x52, "obd2.ethanol.fuel.percentage", 0, 100, POURCENT, 1, false},
+ { 0x5a, "obd2.accelerator.pedal.position", 0, 100, POURCENT, 5, false},
+ { 0x5b, "obd2.hybrid.battery-pack.remaining.life", 0, 100, POURCENT, 5, false},
+ { 0x5c, "obd2.engine.oil.temperature",-40, 210, DEGREES_CELSIUS, 1, false},
+ { 0x63, "obd2.engine.torque", 0, 65535, NM, 1, false}
+};
+
+std::vector<can_message_set_t> CAN_MESSAGE_SET =
+{
+ {0, "example_messages", 1, 2, 2, 0, 19},
+};
+
+std::vector<std::vector<can_message_definition_t>> CAN_MESSAGES_DEFINTION = {
+ {
+ {0x620, CanMessageFormat::STANDARD, {10, 0, nullptr}, false, (uint8_t)NULL},
+ {0x442, CanMessageFormat::STANDARD, {10, 0, nullptr}, false, (uint8_t)NULL},
+ },
+};
+
+/**
+ * @brief Dumb SIGNALS array. It is composed by CanMessageSet
+ * SIGNALS[MESSAGE_SET_ID][CanSignal]
+ */
+std::vector<std::vector<can_signal_t>> SIGNALS = {
+ {
+ {&(CAN_MESSAGES_DEFINTION[MESSAGE_SET_ID][0]), "can.driver_door.open", 2, 4, 1.000000, 0.000000, 0.000000, 0.000000, {10, 0, nullptr}, false, true, nullptr, 0, false, decoder_t::booleanDecoder, nullptr, false, 0.0},
+ {&(CAN_MESSAGES_DEFINTION[MESSAGE_SET_ID][1]), "can.driver_door.close", 0, 4, 1.000000, 0.000000, 0.000000, 0.000000, {10, 0, nullptr}, false, true, nullptr, 0, false, decoder_t::booleanDecoder, nullptr, false, 0.0}
+ },
+};
+
+configuration_t::configuration_t()
+ : obd2_signals_{OBD2_PIDS}, can_message_set_{CAN_MESSAGE_SET}, can_signals_{SIGNALS}, can_message_definition_{CAN_MESSAGES_DEFINTION}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (C) 2015, 2016 "IoT.bzh"
+ * Author "Romain Forlot" <romain.forlot@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <vector>
+
+#include "can/can-bus.hpp"
+#include "can/can-signals.hpp"
+#include "obd2/diagnostic-manager.hpp"
+
+/**
+ * @brief Class representing a configuration attached to the binding.
+ *
+ * @desc It regroups all needed objects instance from other class
+ * that will be used along the binding life. It gets a global vision
+ * on which signals are implemented for that binding.
+ * Here, it is only the definition of the class with predefined accessors
+ * methods used in the binding.
+ *
+ * It will be the reference point to needed objects.
+ */
+
+#include "low-can-binding.hpp"
+
+class configuration_t
+{
+ private:
+ can_bus_t can_bus_manager_(afb_daemon_rootdir_open_locale(binder_interface->daemon, "can_buses.json", O_RDONLY, NULL));
+ diagnostic_manager_t diagnostic_manager_;
+ uint8_t active_message_set_ = 0;
+
+ public:
+ const std::vector<obd2_signals_t> obd2_signals_;
+ const std::vector<can_message_set_t> can_message_set_;
+ const std::vector<std::vector<can_signal_t>> can_signals_;
+ const std::vector<std::vector<can_message_definition_t>> can_message_definition_;
+
+ configuration_t& get_configuration()
+ {
+ return this;
+ }
+
+ can_bus_t& get_can_bus_manager()
+ {
+ return can_bus_manager_;
+ }
+
+ diagnostic_manager_t& get_diagnostic_manager()
+ {
+ return diagnostic_manager_;
+ }
+
+ uint8_t get_active_message_set()
+ {
+ return active_message_set_;
+ }
+
+ std::vector<can_message_set>& get_can_message_set()
+ {
+ return can_message_set_;
+ }
+
+ std::vector<can_signal>& get_can_signals()
+ {
+ return can_signal_[active_message_set_];
+ }
+
+ std::vector<CanSignal>& get_can_signals()
+ {
+ return SIGNALS[active_message_set_];
+ }
+
+ std::vector<can_message_definition>& get_can_message_definition()
+ {
+ return can_message_definition_[active_message_set_];
+ }
+
+ std::vector<obd2_signals_t>& get_obd2_signals()
+ {
+ return obd2_signals_;
+ }
+
+ std::vector<obd2_signals_t>& get_obd2_signals()
+ {
+ return OBD2_PIDS;
+ }
+
+ uint32_t get_signal_id(obd2_signals_t& sig)
+ {
+ return sig.get_pid();
+ }
+
+ uint32_t get_signal_id(const CanSignal& sig)
+ {
+ return sig.message->id;
+ }
+
+ void set_active_message_set(uint8_t id)
+ {
+ active_message_set_ = id;
+ }
+};
\ No newline at end of file
#include "utils/signals.hpp"
-#define OBD2_FUNCTIONAL_BROADCAST_ID 0x7df
-
const char *UNIT_NAMES[10] = {
"POURCENT",
"DEGREES_CELSIUS",
"NM"
};
-/*
-* Pre-defined OBD-II PIDs to query for if supported by the vehicle.
-*/
- std::vector<obd2_signals_t> OBD2_PIDS = {
- { 0x04, "obd2.engine.load", 0, 100, POURCENT, 5, false},
- { 0x05, "obd2.engine.coolant.temperature", -40, 215, DEGREES_CELSIUS, 1, false},
- { 0x0a, "obd2.fuel.pressure", 0, 765, KPA, 1, false},
- { 0x0b, "obd2.intake.manifold.pressure", 0, 255, KPA, 1, false},
- { 0x0c, "obd2.engine.speed", 0, 16383, RPM, 5, false},
- { 0x0d, "obd2.vehicle.speed", 0, 255, KM_H, 5, false},
- { 0x0f, "obd2.intake.air.temperature", -40, 215, DEGREES_CELSIUS, 1, false},
- { 0x10, "obd2.mass.airflow", 0, 655, GRAMS_SEC, 5, false},
- { 0x11, "obd2.throttle.position", 0, 100, POURCENT, 5, false},
- { 0x1f, "obd2.running.time", 0, 65535, SECONDS, 1, false},
- { 0x2d, "obd2.EGR.error", -100, 99, POURCENT, 0, false},
- { 0x2f, "obd2.fuel.level", 0, 100, POURCENT, 1, false},
- { 0x33, "obd2.barometric.pressure", 0, 255, KPA, 1, false},
- { 0x4c, "obd2.commanded.throttle.position", 0, 100, POURCENT, 1, false},
- { 0x52, "obd2.ethanol.fuel.percentage", 0, 100, POURCENT, 1, false},
- { 0x5a, "obd2.accelerator.pedal.position", 0, 100, POURCENT, 5, false},
- { 0x5b, "obd2.hybrid.battery-pack.remaining.life", 0, 100, POURCENT, 5, false},
- { 0x5c, "obd2.engine.oil.temperature",-40, 210, DEGREES_CELSIUS, 1, false},
- { 0x63, "obd2.engine.torque", 0, 65535, NM, 1, false}
-};
-
-uint32_t get_signal_id(obd2_signals_t& sig)
-{
- return sig.get_pid();
-}
-
-std::vector<obd2_signals_t>& get_obd2_signals()
-{
- return OBD2_PIDS;
-}
-
obd2_signals_t::obd2_signals_t(uint8_t pid, const char* generic_name, const int min, const int max, enum UNIT unit, int frequency, bool supported)
: pid_{pid}, generic_name_{generic_name}, min_{min}, max_{max}, unit_{unit}, frequency_{frequency}, supported_{supported}
{
class obd2_signals_t {
private:
uint8_t pid_; /*!< pid - The 1 byte PID.*/
- const char* generic_name_; /*!< generic_name_ - A human readable name to use for this PID when published.*/
+ const std::string generic_name_; /*!< generic_name_ - A human readable name to use for this PID when published.*/
const int min_; /*!< min_ - Minimum value that can take this pid */
const int max_; /*!< max_ - Maximum value that can take this pid */
enum UNIT unit_; /*!< unit_ : Which unit system is used by that pid. See enum UNIT above.*/
bool supported_; /*!< supported_ - boolean indicating whether this pid is supported by the vehicle or not.*/
public:
- const char* generic_name = generic_name_;
+ const char* generic_name = generic_name_.c_str();
obd2_signals_t(uint8_t pid, const char* generic_name, const int min_, const int max_, enum UNIT unit, int frequency, bool supported);
uint32_t get_pid();
#include <afb/afb-service-itf.h>
};
-/*
- * Interface between the daemon and the binding
- */
+// Interface between the daemon and the binding
const struct afb_binding_interface *binder_interface;
-can_bus_t *can_bus_handler;
-
/********************************************************************************
*
* Subscription and unsubscription
*/
int afbBindingV1ServiceInit(struct afb_service service)
{
- int fd_conf;
- fd_conf = afb_daemon_rootdir_open_locale(binder_interface->daemon, "can_buses.json", O_RDONLY, NULL);
+ configuration_t config;
- /* Initialize the CAN bus handler */
- can_bus_handler = new can_bus_t(fd_conf);
+ can_bus_manager = config.get_can_bus_manager();
/* Open CAN socket */
- if(can_bus_handler->init_can_dev() == 0)
+ if(can_bus_manager.init_can_dev() == 0)
{
- can_bus_handler->start_threads();
+ can_bus_manager.start_threads();
return 0;
}
ERROR(binder_interface, "There was something wrong with CAN device Initialization. Check your config file maybe");
#include "can/can-signals.hpp"
#include "obd2/obd2-signals.hpp"
+extern std::mutex subscribed_signals_mutex;
+std::mutex& get_subscribed_signals_mutex();
+
+/**
+ * @brief return the subscribed_signals map.
+ *
+ * return std::map<std::string, struct afb_event> - map of subscribed signals.
+ */
+extern std::map<std::string, struct afb_event> subscribed_signals;
+std::map<std::string, struct afb_event>& get_subscribed_signals();
+
template <typename T>
void lookup_signals_by_name(const std::string& key, std::vector<T>& signals, std::vector<T*>& found_signals)
{
Code Review / apps / agl-service-can-low-level.git / commitdiff