return getActiveMessageSet()->messageCount;
}
-CanSignal* openxc::signals::getSignals() {
+CanSignal* openxc::signals::get_can_signals() {
return SIGNALS[getActiveMessageSet()->index];
}
#include <fnmatch.h>
+#include "signals.hpp"
+#include "obd2-signals.hpp"
#include "can-decoder.hpp"
#include "low-can-binding.hpp"
*/
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, (float)NULL},
- {&(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, (float)NULL}
+ {&(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}
},
};
return subscribed_signals;
}
-const std::vector<CanSignal>& getSignals()
+std::vector<CanSignal>& get_can_signals()
{
return SIGNALS[MESSAGE_SET_ID];
}
return SIGNALS[MESSAGE_SET_ID].size();
}
-std::vector<CanSignal> find_can_signals(const openxc_DynamicField &key)
+uint32_t get_signal_id(const CanSignal& sig)
{
- std::vector<CanSignal> found_signals = {};
- std::vector<CanSignal> active_signals = getSignals();
- /* STL container my love ! Welcome to the printf debugging venerable technique !
- * use those DEBUG message if you need to !
- DEBUG(binder_interface, "We get %d signal(s) to process", (int)active_signals.size()); */
+ return sig.message->id;
+}
+/**
+ * @fn std::vector<std::string> find_signals(const openxc_DynamicField &key)
+ * @brief return signals name found searching through CAN_signals and OBD2 pid
+ *
+ * @param[in] const openxc_DynamicField : can contain numeric or string value in order to search against
+ * can signals or obd2 signals name.
+ *
+ * @return std::vector<std::string> Vector of signals name found.
+ */
+void find_can_signals(const openxc_DynamicField& key, std::vector<CanSignal*>& found_signals)
+{
switch(key.type)
{
case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
- for(const CanSignal& s : active_signals)
- {
- //DEBUG(binder_interface, "Processing signal: %s", s.generic_name);
- if(::fnmatch(key.string_value, s.generic_name, FNM_CASEFOLD) == 0)
- {
- //DEBUG(binder_interface, "Matched signal: %s", s.generic_name);
- found_signals.push_back(s);
- }
- }
+ lookup_signals_by_name(key.string_value, get_can_signals(), found_signals);
break;
case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
- for(const CanSignal& s : active_signals)
- {
- CanMessageDefinition *msg_def = s.message;
- if(msg_def->id == key.numeric_value)
- found_signals.push_back(s);
- }
+ lookup_signals_by_id(key.numeric_value, get_can_signals(), found_signals);
break;
default:
- ERROR(binder_interface, "find_can_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
- return found_signals;
+ ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
break;
}
DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals.size());
- return found_signals;
}
-
-inline uint32_t get_CanSignal_id(const CanSignal& sig)
-{
- return sig.message->id;
-}
\ No newline at end of file
#include <vector>
#include <string>
+#include "obd2-signals.hpp"
#include "timer.hpp"
#include "openxc.pb.h"
#include "can-bus.hpp"
/* Public: Return signals from an signals array filtered on name.
*/
-const std::vector<CanSignal>& getSignals();
+std::vector<CanSignal>& get_can_signals();
-/* Public: Return the length of the array returned by getSignals(). */
+/* Public: Return the length of the array returned by get_can_signals(). */
size_t getSignalCount();
/**
*
* @return std::vector<std::string> return found CanSignal generic name vector.
*/
-std::vector<CanSignal> find_can_signals(const openxc_DynamicField &key);
+void find_can_signals(const openxc_DynamicField &key, std::vector<CanSignal*>& found_signals);
/**
* @brief Retrieve can arbitration id of a given CanSignal
*
* @return uint32_t - unsigned integer representing the arbitration id.
*/
-inline uint32_t get_CanSignal_id(const CanSignal& sig);
\ No newline at end of file
+uint32_t get_signal_id(const CanSignal& sig);
\ No newline at end of file
#include <systemd/sd-event.h>
#include "timer.hpp"
-#include "openxc.pb.h"
+#include "signals.hpp"
#include "can-bus.hpp"
+#include "openxc.pb.h"
#include "can-signals.hpp"
#include "can-message.hpp"
#include "openxc-utils.hpp"
*
*********************************************************************************/
-static int make_subscription_unsubscription(struct afb_req request, const char* sig_name, std::map<std::string, struct afb_event>& s, bool subscribe)
+static int make_subscription_unsubscription(struct afb_req request, const std::string& sig_name, std::map<std::string, struct afb_event>& s, bool subscribe)
{
/* Make the subscription or unsubscription to the event */
- if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[std::string(sig_name)])) < 0)
+ if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[sig_name.c_str()])) < 0)
{
ERROR(binder_interface, "Operation goes wrong for signal: %s", sig_name);
return 0;
}
-static int create_event_handle(const char* sig_name, std::map<std::string, struct afb_event>& s)
+static int create_event_handle(const std::string& sig_name, std::map<std::string, struct afb_event>& s)
{
- s[std::string(sig_name)] = afb_daemon_make_event(binder_interface->daemon, sig_name);
- if (!afb_event_is_valid(s[std::string(sig_name)]))
+ s[sig_name] = afb_daemon_make_event(binder_interface->daemon, sig_name.c_str());
+ if (!afb_event_is_valid(s[sig_name]))
{
ERROR(binder_interface, "Can't create an event, something goes wrong.");
return 0;
return 1;
}
-static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, const CanSignal& sig)
+static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, const std::string& sig)
{
int ret;
std::lock_guard<std::mutex> subscribed_signals_lock(get_subscribed_signals_mutex());
std::map<std::string, struct afb_event>& s = get_subscribed_signals();
- if (s.find(sig.generic_name) != s.end() && !afb_event_is_valid(s[std::string(sig.generic_name)]))
+ if (s.find(sig) != s.end() && !afb_event_is_valid(s[std::string(sig)]))
{
if(!subscribe)
{
}
else
/* Event it isn't valid annymore, recreate it */
- ret = create_event_handle(sig.generic_name, s);
+ ret = create_event_handle(sig, s);
}
else
{
/* Event don't exist , so let's create it */
struct afb_event empty_event = {nullptr, nullptr};
- subscribed_signals[sig.generic_name] = empty_event;
- ret = create_event_handle(sig.generic_name, s);
+ subscribed_signals[sig] = empty_event;
+ ret = create_event_handle(sig, s);
}
/* Check whether or not the event handler has been correctly created and
*/
if (ret <= 0)
return ret;
- return make_subscription_unsubscription(request, sig.generic_name, s, subscribe);
+ return make_subscription_unsubscription(request, sig, s, subscribe);
}
/**
*
* @return Number of correctly subscribed signal
*/
-static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector<CanSignal>& signals)
+static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, std::vector<std::string>& signals)
{
int rets = 0;
- for(const auto& signal_i : signals)
+ for(auto& signal_i : signals)
{
int ret = subscribe_unsubscribe_signal(request, subscribe, signal_i);
if(ret <= 0)
return ret;
rets++;
- DEBUG(binder_interface, "Signal: %s subscribed", signal_i.generic_name);
+ DEBUG(binder_interface, "Signal: %s subscribed", signal_i.c_str());
}
return rets;
}
-// TODO
-static int subscribe_unsubscribe_all(struct afb_req request, bool subscribe)
-{
- int e = 0;
-
- //for (const auto& sig : SIGNALS)
- // e += !subscribe_unsubscribe_signals(request, subscribe, sig);
- e += !subscribe_unsubscribe_signals(request, subscribe, getSignals());
-
- return e == 0;
-}
-
static int subscribe_unsubscribe_name(struct afb_req request, bool subscribe, const char *name)
{
- std::vector<CanSignal> sig;
+ std::vector<std::string> sig;
int ret = 0;
- if (!::strcmp(name, "*"))
- ret = subscribe_unsubscribe_all(request, subscribe);
- else
- {
- //if(obd2_handler_c.is_obd2_signal(name))
- if(false)
- {
- // TODO
- }
- else
- {
- openxc_DynamicField search_key = build_DynamicField(std::string(name));
- sig = find_can_signals(search_key);
- if (sig.empty())
- ret = 0;
- }
- ret = subscribe_unsubscribe_signals(request, subscribe, sig);
- NOTICE(binder_interface, "Subscribed correctly to %d/%d signal(s).", ret, (int)sig.size());
- }
+ openxc_DynamicField search_key = build_DynamicField(std::string(name));
+ sig = find_signals(search_key);
+ if (sig.empty())
+ ret = 0;
+
+ ret = subscribe_unsubscribe_signals(request, subscribe, sig);
+ NOTICE(binder_interface, "Subscribed correctly to %d/%d signal(s).", ret, (int)sig.size());
+
return ret;
}
/* makes the subscription/unsubscription */
args = afb_req_json(request);
if (args == NULL || !json_object_object_get_ex(args, "event", &a)) {
- ok = subscribe_unsubscribe_all(request, subscribe);
+ ok = subscribe_unsubscribe_name(request, subscribe, "*");
} else if (json_object_get_type(a) != json_type_array) {
ok = subscribe_unsubscribe_name(request, subscribe, json_object_get_string(a));
} else {
--- /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 "obd2-signals.hpp"
+
+#include "signals.hpp"
+
+const char *UNIT_NAMES[10] = {
+ "POURCENT",
+ "DEGREES_CELSIUS",
+ "KPA",
+ "RPM",
+ "GRAMS_SEC",
+ "SECONDS",
+ "KM",
+ "KM_H",
+ "PA",
+ "NM"
+};
+
+/*
+* Pre-defined OBD-II PIDs to query for if supported by the vehicle.
+*/
+ std::vector<Obd2Pid> 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}
+};
+
+/**
+ * @fn std::vector<std::string> find_signals(const openxc_DynamicField &key)
+ * @brief return signals name found searching through CAN_signals and OBD2 pid
+ *
+ * @param[in] const openxc_DynamicField : can contain numeric or string value in order to search against
+ * can signals or obd2 signals name.
+ *
+ * @return std::vector<std::string> Vector of signals name found.
+ */
+void find_signals(const openxc_DynamicField &key, std::vector<Obd2Pid*>& found_signals)
+{
+ switch(key.type)
+ {
+ case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
+ lookup_signals_by_name(key.string_value, get_obd2_signals(), found_signals);
+ break;
+ case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
+ lookup_signals_by_id(key.numeric_value, get_obd2_signals(), found_signals);
+ break;
+ default:
+ ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
+ break;
+ }
+ DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals.size());
+}
+
+std::vector<Obd2Pid>& get_obd2_signals()
+{
+ return OBD2_PIDS;
+}
+
+uint32_t get_signal_id(const Obd2Pid& sig)
+{
+ return (uint32_t)sig.pid;
+}
+
+void shims_logger(const char* m, const struct afb_binding_interface *interface)
+{
+ DEBUG(interface, "%s", m);
+}
+
+void shims_timer()
+{
+}
+
+/*
+ * Will scan for supported Obd2 pids
+ *
+obd2_handler_t::obd2_handler_t()
+{
+ DiagnosticShims shims_ = diagnostic_init_shims(shims_logger, can_bus.send_can_message, NULL);
+
+ int n_pids_, i_;
+
+ n_pids_ = size(Obd2Pid);
+ for(i_=0; i_<=n_pids_; i_++)
+ {
+ }
+}
+
+void obd2_handler_t::add_request(int pid)
+{
+ DiagnosticRequest request = {
+ arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
+ mode: 0x1, has_true, pid};
+}
+
+bool obd2_handler_t::is_obd2_request(DiagnosticRequest* request)
+{
+ return request->mode == 0x1 && request->has_pid && request->pid < 0xff;
+}
+
+bool obd2_handler_t::is_obd2_signal(const char *name)
+{
+ if(fnmatch("obd2.*", name, FNM_CASEFOLD) == 0)
+ return true;
+ return false;
+}
+
+bool obd2_handler_t::decode_obd2_response(DiagnosticResponse* responce)
+{
+ return diagnostic_decode_obd2_pid(response);
+}*/
\ No newline at end of file
#pragma once
#include <vector>
+
#include "uds/uds.h"
#include "can-bus.hpp"
-extern "C"
-{
- #include <afb/afb-binding.h>
-}
+#include "low-can-binding.hpp"
enum UNIT {
POURCENT,
KM,
KM_H,
PA,
- NM
-};
-
-const char *UNIT_NAMES[10] = {
- "POURCENT",
- "DEGREES_CELSIUS",
- "KPA",
- "RPM",
- "GRAMS_SEC",
- "SECONDS",
- "KM",
- "KM_H",
- "PA",
- "NM"
+ NM,
+ INVALID
};
/**
* frequency - The frequency to request this PID if supported by the vehicle
* when automatic, recurring OBD-II requests are enabled.
* supported - is it supported by the vehicle. Initialized after scan
- * event - application framework event handler.
*/
typedef struct _Obd2Pid {
uint8_t pid;
bool supported;
} Obd2Pid;
-/*
-* Pre-defined OBD-II PIDs to query for if supported by the vehicle.
-*/
-const std::vector<Obd2Pid> OBD2_PIDS {
- { pid: 0x04, name: "obd2.engine.load", min:0, max: 100, unit: POURCENT, frequency: 5, supported: false},
- { pid: 0x05, name: "obd2.engine.coolant.temperature", min: -40, max: 215, unit: DEGREES_CELSIUS, frequency: 1, supported: false},
- { pid: 0x0a, name: "obd2.fuel.pressure", min: 0, max: 765, unit: KPA, frequency: 1, supported: false},
- { pid: 0x0b, name: "obd2.intake.manifold.pressure", min: 0, max: 255, unit: KPA, frequency: 1, supported: false},
- { pid: 0x0c, name: "obd2.engine.speed", min: 0, max: 16383, unit: RPM, frequency: 5, supported: false},
- { pid: 0x0d, name: "obd2.vehicle.speed", min: 0, max: 255, unit: KM_H, frequency: 5, supported: false},
- { pid: 0x0f, name: "obd2.intake.air.temperature", min: -40, max:215, unit: DEGREES_CELSIUS, frequency: 1, supported: false},
- { pid: 0x10, name: "obd2.mass.airflow", min: 0, max: 655, unit: GRAMS_SEC, frequency: 5, supported: false},
- { pid: 0x11, name: "obd2.throttle.position", min: 0, max: 100, unit: POURCENT, frequency: 5, supported: false},
- { pid: 0x1f, name: "obd2.running.time", min: 0, max: 65535, unit: SECONDS, frequency: 1, supported: false},
- { pid: 0x2d, name: "obd2.EGR.error", min: -100, max: 99, unit: POURCENT, frequency: 0, supported: false},
- { pid: 0x2f, name: "obd2.fuel.level", min: 0, max: 100, unit: POURCENT, frequency: 1, supported: false},
- { pid: 0x33, name: "obd2.barometric.pressure", min: 0, max: 255, unit: KPA, frequency: 1, supported: false},
- { pid: 0x4c, name: "obd2.commanded.throttle.position", min: 0, max: 100, unit: POURCENT, frequency: 1, supported: false},
- { pid: 0x52, name: "obd2.ethanol.fuel.percentage", min: 0, max: 100, unit: POURCENT, frequency: 1, supported: false},
- { pid: 0x5a, name: "obd2.accelerator.pedal.position", min: 0, max: 100, unit: POURCENT, frequency: 5, supported: false},
- { pid: 0x5b, name: "obd2.hybrid.battery-pack.remaining.life", min: 0, max: 100, unit: POURCENT, frequency: 5, supported: false},
- { pid: 0x5c, name: "obd2.engine.oil.temperature",min: -40, max: 210, unit: DEGREES_CELSIUS, frequency: 1, supported: false},
- { pid: 0x63, name: "obd2.engine.torque", min: 0, max: 65535, unit: NM, frequency: 1, supported: false}
-};
+std::vector<Obd2Pid>& get_obd2_signals();
+uint32_t get_signal_id(const Obd2Pid& sig);
+void find_obd2_signals(const openxc_DynamicField &key, std::vector<Obd2Pid*>& found_signals);
/**
* @brief - Object to handle obd2 session with pre-scan of supported pid
private:
public:
+ obd2_handler_t();
/**
* @brief:
*
+++ /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 "obd2.hpp"
-
-void shims_logger(const char* m, const struct afb_binding_interface *interface)
-{
- DEBUG(interface, "%s", m);
-}
-
-void shims_timer()
-{
-}
-
-/*
- * Will scan for supported Obd2 pids
- */
-obd2_handler_t::obd2_handler_t(const struct afb_binding_interface *interface, can_bus_t can_bus)
- : can_bus_{can_bus}
-{
- can_bus_t can_bus_ = can_bus;
- DiagnosticShims shims_ = diagnostic_init_shims(shims_logger, can_bus.send_can_message, NULL);
-
- int n_pids_, i_;
-
- n_pids_ = size(Obd2Pid);
- for(i_=0; i_<=n_pids_; i_++)
- {
- }
-}
-
-void obd2_handler_t::add_request(int pid)
-{
- DiagnosticRequest request = {
- arbitration_id: OBD2_FUNCTIONAL_BROADCAST_ID,
- mode: 0x1, has_pid: true, pid: pid};
-}
-
-bool obd2_handler_t::is_obd2_request(DiagnosticRequest* request)
-{
- return request->mode == 0x1 && request->has_pid && request->pid < 0xff;
-}
-
-bool obd2_handler_t::is_obd2_signal(const char *name)
-{
- if(fnmatch("obd2.*", name, FNM_CASEFOLD) == 0)
- return true;
- return false;
-}
-
-bool obd2_handler_t::decode_obd2_response(DiagnosticResponse* responce)
-{
- return diagnostic_decode_obd2_pid(response);
-}
--- /dev/null
+
+#include "signals.hpp"
+
+/**
+ * @fn std::vector<std::string> find_signals(const openxc_DynamicField &key)
+ * @brief return signals name found searching through CAN_signals and OBD2 pid
+ *
+ * @param[in] const openxc_DynamicField : can contain numeric or string value in order to search against
+ * can signals or obd2 signals name.
+ *
+ * @return std::vector<std::string> Vector of signals name found.
+ */
+std::vector<std::string> find_signals(const openxc_DynamicField &key)
+{
+ std::vector<std::string> found_signals_name;
+
+ switch(key.type)
+ {
+ case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
+ lookup_signals_by_name(key.string_value, get_can_signals(), found_signals_name);
+ lookup_signals_by_name(key.string_value, get_obd2_signals(), found_signals_name);
+ break;
+ case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
+ lookup_signals_by_id(key.numeric_value, get_can_signals(), found_signals_name);
+ lookup_signals_by_id(key.numeric_value, get_obd2_signals(), found_signals_name);
+ break;
+ default:
+ ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
+ break;
+ }
+ DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals_name.size());
+ return found_signals_name;
+}
--- /dev/null
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fnmatch.h>
+
+#include "openxc.pb.h"
+#include "can-signals.hpp"
+#include "obd2-signals.hpp"
+
+template <typename T>
+void lookup_signals_by_name(const std::string& key, std::vector<T>& signals, std::vector<T*>& found_signals)
+{
+ for(T& s : signals)
+ {
+ if(::fnmatch(key.c_str(), s.generic_name, FNM_CASEFOLD) == 0)
+ found_signals.push_back(&s);
+ }
+}
+
+template <typename T>
+void lookup_signals_by_name(const std::string& key, std::vector<T>& signals, std::vector<std::string>& found_signals_name)
+{
+ for(const T& s : signals)
+ {
+ if(::fnmatch(key.c_str(), s.generic_name, FNM_CASEFOLD) == 0)
+ found_signals_name.push_back(s.generic_name);
+ }
+}
+
+template <typename T>
+void lookup_signals_by_id(const double key, std::vector<T>& signals, std::vector<T*>& found_signals)
+{
+ for(T& s : signals)
+ {
+ if(get_signal_id(s) == key)
+ {
+ found_signals.push_back(&s);
+ }
+ }
+}
+
+template <typename T>
+void lookup_signals_by_id(const double key, std::vector<T>& signals, std::vector<std::string>& found_signals_name)
+{
+ for(T& s : signals)
+ {
+ if(get_signal_id(s) == key)
+ {
+ found_signals_name.push_back(s.generic_name);
+ }
+ }
+}
+
+std::vector<std::string> find_signals(const openxc_DynamicField &key);
Code Review / apps / agl-service-can-low-level.git / commitdiff