CAN-binder/low-can-binding/low-can-binding.cpp

   1 /*
   2  * Copyright (C) 2015, 2016 "IoT.bzh"
   3  * Author "Romain Forlot" <romain.forlot@iot.bzh>
   4  * Author "Loic Collignon" <loic.collignon@iot.bzh>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *       http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include "low-can-binding.hpp"
  20
  21 #include <map>
  22 #include <queue>
  23 #include <mutex>
  24 #include <vector>
  25 #include <thread>
  26 #include <time.h>
  27 #include <linux/can.h>
  28 #include <json-c/json.h>
  29
  30 #include "openxc.pb.h"
  31 #include "configuration.hpp"
  32 #include "can/can-bus.hpp"
  33 #include "can/can-signals.hpp"
  34 #include "can/can-message.hpp"
  35 #include "utils/timer.hpp"
  36 #include "utils/signals.hpp"
  37 #include "diagnostic/diagnostic-message.hpp"
  38 #include "utils/openxc-utils.hpp"
  39
  40 extern "C"
  41 {
  42         #include <afb/afb-service-itf.h>
  43 };
  44
  45 // Interface between the daemon and the binding
  46 const struct afb_binding_interface *binder_interface;
  47
  48 void on_no_clients(std::string message)
  49 {
  50         DiagnosticRequest* diag_req = configuration_t::instance().get_request_from_diagnostic_message(message);
  51         if(diag_req != nullptr)
  52         {
  53                 active_diagnostic_request_t* adr = configuration_t::instance().get_diagnostic_manager().find_recurring_request(diag_req);
  54                 if( adr != nullptr)
  55                         configuration_t::instance().get_diagnostic_manager().cleanup_request(adr, true);
  56         }
  57 }
  58
  59 ///******************************************************************************
  60 ///
  61 ///             Subscription and unsubscription
  62 ///
  63 ///*******************************************************************************/
  64
  65 static int make_subscription_unsubscription(struct afb_req request, const std::string& sig_name, std::map<std::string, struct afb_event>& s, bool subscribe)
  66 {
  67         /* Make the subscription or unsubscription to the event */
  68         if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[sig_name])) < 0)
  69         {
  70                 ERROR(binder_interface, "%s: Operation goes wrong for signal: %s", __FUNCTION__, sig_name.c_str());
  71                 return 0;
  72         }
  73         return 1;
  74 }
  75
  76 static int create_event_handle(const std::string& sig_name, std::map<std::string, struct afb_event>& s)
  77 {
  78         s[sig_name] = afb_daemon_make_event(binder_interface->daemon, sig_name.c_str());
  79         if (!afb_event_is_valid(s[sig_name]))
  80         {
  81                 ERROR(binder_interface, "%s: Can't create an event for %s, something goes wrong.", __FUNCTION__, sig_name.c_str());
  82                 return 0;
  83         }
  84         return 1;
  85 }
  86
  87 static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, const std::string& sig)
  88 {
  89         int ret;
  90
  91         utils::signals_manager_t& sm = utils::signals_manager_t::instance();
  92
  93         std::lock_guard<std::mutex> subscribed_signals_lock(sm.get_subscribed_signals_mutex());
  94         std::map<std::string, struct afb_event>& s = sm.get_subscribed_signals();
  95         if (s.find(sig) != s.end())
  96         {
  97                 if (!afb_event_is_valid(s[sig]) && !subscribe)
  98                 {
  99                         NOTICE(binder_interface, "%s: Event isn't valid, it can't be unsubscribed.", __FUNCTION__);
 100                         ret = -1;
 101                 }
 102                 /*else
 103                 {
 104                         // Event it isn't valid annymore, recreate it
 105                         ret = create_event_handle(sig, s);
 106                 }*/
 107         }
 108         else
 109         {
 110                 /* Event doesn't exist , so let's create it */
 111                 struct afb_event empty_event = {nullptr, nullptr};
 112                 s[sig] = empty_event;
 113                 ret = create_event_handle(sig, s);
 114         }
 115
 116         /* Check whether or not the event handler has been correctly created and
 117          * make the subscription/unsubscription operation is so.
 118          */
 119         if (ret <= 0)
 120                 return ret;
 121         return make_subscription_unsubscription(request, sig, s, subscribe);
 122 }
 123
 124 ///
 125 /// @fn static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector<can_signal_t>& signals)
 126 /// @brief subscribe to all signals in the vector signals
 127 ///
 128 /// @param[in] afb_req request : contain original request use to subscribe or unsubscribe
 129 /// @param[in] subscribe boolean value used to chose between a subscription operation or an unsubscription
 130 /// @param[in] can_signal_t  vector with can_signal_t to subscribe
 131 ///
 132 /// @return Number of correctly subscribed signal
 133 ///
 134 static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const struct utils::signals_found& signals)
 135 {
 136         int ret,  rets = 0;
 137
 138         //TODO: Implement way to dynamically call the right function no matter
 139         // how much signals types we have.
 140         configuration_t& conf = configuration_t::instance();
 141
 142         for(const auto& sig : signals.diagnostic_messages)
 143         {
 144                 DiagnosticRequest* diag_req = conf.get_request_from_diagnostic_message(sig->get_name());
 145
 146                 // If the requested diagnostic message isn't supported by the car then unssubcribe.
 147                 // no matter what we want, worse case will be a fail unsubscription but at least we don't
 148                 // poll a PID for nothing.
 149                 if(sig->get_supported() && subscribe)
 150                 {
 151                                 float frequency = sig->get_frequency();
 152                                 subscribe = conf.get_diagnostic_manager().add_recurring_request(
 153                                         diag_req, sig->get_name().c_str(), false, sig->get_decoder(), sig->get_callback(), (float)frequency);
 154                                         //TODO: Adding callback requesting ignition status:     diag_req, sig.c_str(), false, diagnostic_message_t::decode_obd2_response, diagnostic_message_t::check_ignition_status, frequency);
 155                 }
 156                 else
 157                 {
 158                         conf.get_diagnostic_manager().cleanup_request(
 159                                 conf.get_diagnostic_manager().find_recurring_request(diag_req), true);
 160                         WARNING(binder_interface, "%s: signal: %s isn't supported. Canceling operation.", __FUNCTION__, sig->get_name().c_str());
 161                         return -1;
 162                 }
 163
 164                 ret = subscribe_unsubscribe_signal(request, subscribe, sig->get_name());
 165                 if(ret <= 0)
 166                         return ret;
 167                 rets++;
 168                 DEBUG(binder_interface, "%s: Signal: %s subscribed", __FUNCTION__, sig->get_name().c_str());
 169         }
 170
 171         for(const auto& sig: signals.can_signals)
 172         {
 173                 ret = subscribe_unsubscribe_signal(request, subscribe, sig->get_name());
 174                 if(ret <= 0)
 175                         return ret;
 176                 rets++;
 177                 DEBUG(binder_interface, "%s: signal: %s subscribed", __FUNCTION__, sig->get_name().c_str());
 178         }
 179         return rets;
 180 }
 181
 182 static int subscribe_unsubscribe_name(struct afb_req request, bool subscribe, const char *name)
 183 {
 184         struct utils::signals_found signals;
 185         int ret = 0;
 186
 187         openxc_DynamicField search_key = build_DynamicField(std::string(name));
 188         signals = utils::signals_manager_t::instance().find_signals(search_key);
 189         if (signals.can_signals.empty() && signals.diagnostic_messages.empty())
 190                 ret = 0;
 191
 192         ret = subscribe_unsubscribe_signals(request, subscribe, signals);
 193         NOTICE(binder_interface, "%s: Subscribed/unsubscribe correctly to %d/%d signal(s).", __FUNCTION__, ret, (int)(signals.can_signals.size() + signals.diagnostic_messages.size())  );
 194
 195         return ret;
 196 }
 197
 198 static void subscribe_unsubscribe(struct afb_req request, bool subscribe)
 199 {
 200         int ok, i, n;
 201         struct json_object *args, *a, *x;
 202
 203         /* makes the subscription/unsubscription */
 204         args = afb_req_json(request);
 205         if (args == NULL || !json_object_object_get_ex(args, "event", &a)) {
 206                 ok = subscribe_unsubscribe_name(request, subscribe, "*");
 207         } else if (json_object_get_type(a) != json_type_array) {
 208                 ok = subscribe_unsubscribe_name(request, subscribe, json_object_get_string(a));
 209         } else {
 210                 n = json_object_array_length(a);
 211                 ok = 0;
 212                 for (i = 0 ; i < n ; i++) {
 213                         x = json_object_array_get_idx(a, i);
 214                         if (subscribe_unsubscribe_name(request, subscribe, json_object_get_string(x)))
 215                                 ok++;
 216                 }
 217                 ok = (ok == n);
 218         }
 219
 220         /* send the report */
 221         if (ok)
 222                 afb_req_success(request, NULL, NULL);
 223         else
 224                 afb_req_fail(request, "error", NULL);
 225 }
 226
 227 extern "C"
 228 {
 229         static void subscribe(struct afb_req request)
 230         {
 231                 subscribe_unsubscribe(request, true);
 232         }
 233
 234         static void unsubscribe(struct afb_req request)
 235         {
 236                 subscribe_unsubscribe(request, false);
 237         }
 238
 239         static const struct afb_verb_desc_v1 verbs[]=
 240         {
 241                 { .name= "subscribe",   .session= AFB_SESSION_NONE, .callback= subscribe,       .info= "subscribe to notification of CAN bus messages." },
 242                 { .name= "unsubscribe", .session= AFB_SESSION_NONE, .callback= unsubscribe,     .info= "unsubscribe a previous subscription." }
 243         };
 244
 245         static const struct afb_binding binding_desc {
 246                 AFB_BINDING_VERSION_1,
 247                 {
 248                         "Low level CAN bus service",
 249                         "low-can",
 250                         verbs
 251                 }
 252         };
 253
 254         const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf)
 255         {
 256                 binder_interface = itf;
 257
 258                 return &binding_desc;
 259         }
 260
 261         /// @brief Initialize the binding.
 262         ///
 263         /// @param[in] service Structure which represent the Application Framework Binder.
 264         ///
 265         /// @return Exit code, zero if success.
 266         int afbBindingV1ServiceInit(struct afb_service service)
 267         {
 268                 can_bus_t& can_bus_manager = configuration_t::instance().get_can_bus_manager();
 269
 270                 /// Initialize CAN socket
 271                 if(can_bus_manager.init_can_dev() == 0)
 272                 {
 273                         can_bus_manager.start_threads();
 274
 275                         /// Initialize Diagnostic manager that will handle obd2 requests.
 276                         /// We pass by default the first CAN bus device to its Initialization.
 277                         /// TODO: be able to choose the CAN bus device that will be use as Diagnostic bus.
 278                         if(configuration_t::instance().get_diagnostic_manager().initialize())
 279                                 return 0;
 280                 }
 281
 282                 ERROR(binder_interface, "%s: There was something wrong with CAN device Initialization. Check your config file maybe", __FUNCTION__);
 283                 return 1;
 284         }
 285 };