path: root/src/low_can_client.cpp

/*
 * Copyright (c) 2018 TOYOTA MOTOR CORPORATION
 *
 * 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 "low_can_client.hpp"
#include "json_helper.hpp"
#include "hmi-debug.h"

extern "C" {
#include <afb/afb-binding.h>
}


namespace wm {

LowCanClient::LowCanClient() :
  vehicle_speed_(0),
  trans_gear_pos_(0),
  headlamp_status_(FALSE),
  parking_brake_status_(TRUE),
  accel_pedal_pos_(0),
  prv_lamp_state_("lamp_off"),
  crr_lamp_state_("lamp_off"),
  prv_parking_brake_state_("parking_brake_on"),
  crr_parking_brake_state_("parking_brake_on"),
  prv_accel_pedal_state_("accel_pedal_off"),
  crr_accel_pedal_state_("accel_pedal_off"),
  prv_car_state_("car_stop"),
  crr_car_state_("car_stop"),
  is_changed_lamp_state_(false),
  is_changed_parking_brake_state_(false),
  is_changed_accel_pedal_state_(false),
  is_changed_car_state_(false)
{
    HMI_DEBUG("wm:lcc", "Call");
}

void LowCanClient::initialize() {
    HMI_DEBUG("wm:lcc", "Call");

    int ret;

    // Require API "low-can"
    ret = afb_daemon_require_api_v2("low-can", 1);
    if (0 > ret) {
        HMI_INFO("wm:lcc", "Requirement API \"low-can\" failed");
        return;
    }

    // Subscribe low-level-can
    // low-can subscribe { "event": "vehicle.speed" }
    // low-can subscribe { "event": "transmission_gear_position" }
    // low-can subscribe { "event": "headlamp_status" }
    // low-can subscribe { "event": "parking_brake_status" }
    // low-can subscribe { "event": "accelerator.pedal.position" }
    int num_event = this->kEventName_.size();
    for (int i=0; i<num_event; i++) {
        json_object *json_obj = json_object_new_object();
        json_object_object_add(json_obj, "event", json_object_new_string(this->kEventName_[i]));
        HMI_DEBUG("wm:lcc", "subscribe message:%s", json_object_get_string(json_obj));

        json_object *json_result = json_object_new_object();
        ret = afb_service_call_sync("low-can", "subscribe", json_obj, &json_result);
        if (0 > ret) {
            HMI_INFO("wm:lcc", "Could not subscribe to \"low-can\" :%d", ret);
        }
        HMI_DEBUG("wm:lcc", "subscribe result:%s", json_object_get_string(json_result));
    }

    return;
}

void LowCanClient::analyzeCanSignal(struct json_object *object) {
    HMI_DEBUG("wm:lcc", "object:%s", json_object_get_string(object));

    const char* name = jh::getStringFromJson(object, "name");
    HMI_DEBUG("wm:lcc", "CAN signal name:%s", name);

    if (strstr(name, this->kEventName_[0])) {
        HMI_DEBUG("wm:lcc", "Receive %s", this->kEventName_[0]);
        // Update vehicle speed
        int speed = jh::getIntFromJson(object, "value");
        if (this->vehicle_speed_ != speed) {
            this->vehicle_speed_ = speed;
            HMI_DEBUG("wm:lcc", "Update vehicle speed:%d", this->vehicle_speed_);
        }
    }
    else if (strstr(name, this->kEventName_[1])) {
        HMI_DEBUG("wm:lcc", "Receive %s", this->kEventName_[1]);
        // Update transmission gear position
        int gear_pos = jh::getIntFromJson(object, "value");
        if (this->trans_gear_pos_ != gear_pos) {
            this->trans_gear_pos_ = gear_pos;
            HMI_DEBUG("wm:lcc", "Update transmission gear position:%d", this->trans_gear_pos_);
        }
    }
    else if (strstr(name, this->kEventName_[2])) {
        HMI_DEBUG("wm:lcc", "Receive %s", this->kEventName_[2]);
        // Update headlamp status
        json_bool headlamp = jh::getBoolFromJson(object, "value");
        if (this->headlamp_status_ != headlamp) {
            this->headlamp_status_ = headlamp;
            HMI_DEBUG("wm:lcc", "Update headlamp status:%d", this->headlamp_status_);
        }
    }
    else if (strstr(name, this->kEventName_[3])) {
        HMI_DEBUG("wm:lcc", "Receive %s", this->kEventName_[3]);
        // Update parking gear status
        json_bool parking_brake = jh::getBoolFromJson(object, "value");
        if (this->parking_brake_status_ != parking_brake) {
            this->parking_brake_status_ = parking_brake;
            HMI_DEBUG("wm:lcc", "Update parking brake status:%d", this->parking_brake_status_);
        }
    }
    else if (strstr(name, this->kEventName_[4])) {
        HMI_DEBUG("wm:lcc", "Receive %s", this->kEventName_[4]);
        // Update accelerator pedal status
        double accel_pedal_pos = jh::getDoubleFromJson(object, "value");
        if (this->accel_pedal_pos_ != accel_pedal_pos) {
            this->accel_pedal_pos_ = accel_pedal_pos;
            HMI_DEBUG("wm:lcc", "Update accelerator pedal status:%lf", this->accel_pedal_pos_);
        }
    }

    // Update lamp state
    if (true == this->headlamp_status_) {
        this->crr_lamp_state_ = "lamp_on";
    }
    else {
        this->crr_lamp_state_ = "lamp_off";
    }
    HMI_DEBUG("wm:lcc", "Current lamp state:%s", this->crr_lamp_state_.c_str());

    // Update parking brake state
    if (this->parking_brake_status_) {
        this->crr_parking_brake_state_ = "parking_brake_on";
    }
    else {
        this->crr_parking_brake_state_ = "parking_brake_off";
    }
    HMI_DEBUG("wm:lcc", "Current parking brake state:%s", this->crr_parking_brake_state_.c_str());

    // Update accelerator pedal state
    if (0 == this->accel_pedal_pos_) {
        this->crr_accel_pedal_state_ = "accel_pedal_off";
    }
    else {
        this->crr_accel_pedal_state_ = "accel_pedal_on";
    }
    HMI_DEBUG("wm:lcc", "Current accelerator pedal state:%s", this->crr_accel_pedal_state_.c_str());

    // Update car state
    if ((0 == this->vehicle_speed_) || (true == this->parking_brake_status_)) {
        this->crr_car_state_ = "car_stop";
    }
    else {
        this->crr_car_state_ = "car_run";
    }
    HMI_DEBUG("wm:lcc", "Current car state:%s", this->crr_car_state_.c_str());

    // If lamp state is changed,
    // backup current state for previous state and set flag
    if (this->prv_lamp_state_ != this->crr_lamp_state_) {
        HMI_DEBUG("wm:lcc", "Lamp state is changed: %s -> %s",
                  this->prv_lamp_state_.c_str(), this->crr_lamp_state_.c_str());
        this->prv_lamp_state_ = this->crr_lamp_state_;
        this->is_changed_lamp_state_ = true;
    }

    // If parking brake state is changed,
    // backup current state for previous state and set flag
    if (this->prv_parking_brake_state_ != this->crr_parking_brake_state_) {
        HMI_DEBUG("wm:lcc", "Parking Brake state is changed: %s -> %s",
                  this->prv_parking_brake_state_.c_str(), this->crr_parking_brake_state_.c_str());
        this->prv_parking_brake_state_ = this->crr_parking_brake_state_;
        this->is_changed_parking_brake_state_ = true;
    }

    // If accelerator pedal state is changed,
    // backup current state for previous state and set flag
    if (this->prv_accel_pedal_state_ != this->crr_accel_pedal_state_) {
        HMI_DEBUG("wm:lcc", "Accelerator Pedal is changed: %s -> %s",
                  this->prv_accel_pedal_state_.c_str(), this->crr_accel_pedal_state_.c_str());
        this->prv_accel_pedal_state_ = this->crr_accel_pedal_state_;
        this->is_changed_accel_pedal_state_ = true;
    }

    // If car state is changed,
    // backup current state for previous state and set flag
    if (this->prv_car_state_ != this->crr_car_state_) {
        HMI_DEBUG("wm:lcc", "Car state is changed: %s -> %s",
                  this->prv_car_state_.c_str(), this->crr_car_state_.c_str());
        this->prv_car_state_ = this->crr_car_state_;
        this->is_changed_car_state_ = true;
    }
}

bool LowCanClient::isChangedLampState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Return changed flag
    return this->is_changed_lamp_state_;
}

bool LowCanClient::isChangedParkingBrakeState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Return changed flag
    return this->is_changed_parking_brake_state_;
}

bool LowCanClient::isChangedAccelPedalState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Return changed flag
    return this->is_changed_accel_pedal_state_;
}

bool LowCanClient::isChangedCarState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Return changed flag
    return this->is_changed_car_state_;
}

const char* LowCanClient::getCurrentLampState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Clear changed flag
    this->is_changed_lamp_state_ = false;

    // Return current lamp state
    return this->crr_lamp_state_.c_str();
}

const char* LowCanClient::getCurrentParkingBrakeState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Clear changed flag
    this->is_changed_parking_brake_state_ = false;

    // Return current parking brake state
    return this->crr_parking_brake_state_.c_str();
}

const char* LowCanClient::getCurrentAccelPedalState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Clear changed flag
    this->is_changed_accel_pedal_state_ = false;

    // Return current accelerator pedal state
    return this->crr_accel_pedal_state_.c_str();
}

const char* LowCanClient::getCurrentCarState() {
    HMI_DEBUG("wm:lcc", "Call");

    // Clear changed flag
    this->is_changed_car_state_ = false;

    // Return current car state
    return this->crr_car_state_.c_str();
}


} // namespace wm