common.h

Go to the documentation of this file.

/*      File: common.h
 *       This file is part of the program ethercatcpp-shadow
 *       Program description : EtherCAT driver library for shadow hand.
 *       Copyright (C) 2018-2022 -  Robin Passama (CNRS/LIRMM) Arnaud Meline
 * (CNRS/LIRMM) Benjamin Navarro (CNRS/LIRMM). All Right reserved.
 *
 *       This software is free software: you can redistribute it and/or modify
 *       it under the terms of the CeCILL-C license as published by
 *       the CEA CNRS INRIA, either version 1
 *       of the License, or (at your option) any later version.
 *       This software is distributed in the hope that it will be useful,
 *       but WITHOUT ANY WARRANTY without even the implied warranty of
 *       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *       CeCILL-C License for more details.
 *
 *       You should have received a copy of the CeCILL-C License
 *       along with this software. If not, it can be found on the official
 * website of the CeCILL licenses family (http://www.cecill.info/index.en.html).
 */
#pragma once
 
#include <cstdint>
#include <array>
 
namespace ethercatcpp::shadow {
 
// Number of motors in shadow hand
constexpr int NUM_MOTORS = 20;
// Number of ADC sensors in the robot.
constexpr int SENSORS_NUM_0220 = 36;
// Number of ADC positions sensors (0..25)
constexpr int POSITION_SENSOR_NUM = 26;
 
enum class HandType { Right, Left };
 
enum class HandID {
    LirmmRight,
    LirmmLeft,
    Count 
};
 
constexpr std::array<uint32_t, static_cast<int>(HandID::Count)>
    hand_serial_numbers = {
        842, // LirmmRight
        858  // LirmmLeft
};
 
constexpr std::array<HandType, static_cast<int>(HandID::Count)> hand_types = {
    HandType::Right, // LirmmRight
    HandType::Left   // LirmmLeft
};
 
enum class BiotacMode {
    WithElectrodes,   
    WithoutElectrodes 
};
 
enum class ControlMode { Torque, PWM };
 
struct BiotacPressures {
    int16_t Pac0{0}; 
    int16_t Pac1{0}; 
    int16_t Pdc{0};  
};
 
struct BiotacTemperatures {
    int16_t Tac{0}; 
    int16_t Tdc{0}; 
};
 
struct BiotacElectrodes : public std::array<int16_t, 19> {
    BiotacElectrodes() {
        fill(0);
    }
};
 
enum class JointNames {
    FFJ4,
    FFJ3,
    FFJ2,
    MFJ4,
    MFJ3,
    MFJ2,
    RFJ4,
    RFJ3,
    RFJ2,
    LFJ5,
    LFJ4,
    LFJ3,
    LFJ2,
    THJ5,
    THJ4,
    THJ3,
    THJ2,
    WRJ2,
    WRJ1,
};
 
enum class JointGroupsNames {
    FirstFinger,
    MiddleFinger,
    RingFinger,
    LittleFinger,
    Thumb,
    Wrist
};
 
constexpr std::size_t first_finger_joint_count = 3;
constexpr std::size_t middle_finger_joint_count = 3;
constexpr std::size_t ring_finger_joint_count = 3;
constexpr std::size_t little_finger_joint_count = 4;
constexpr std::size_t thumb_finger_joint_count = 4;
constexpr std::size_t wrist_joint_count = 2;
constexpr std::size_t joint_count =
    first_finger_joint_count + middle_finger_joint_count +
    ring_finger_joint_count + little_finger_joint_count +
    thumb_finger_joint_count + wrist_joint_count;
constexpr std::size_t joint_groups_count = 6;
constexpr std::size_t biotac_count = 5;
 
constexpr std::array<const char*, joint_count> joint_names{
    "FFJ4", "FFJ3", "FFJ2", "MFJ4", "MFJ3", "MFJ2", "RFJ4",
    "RFJ3", "RFJ2", "LFJ5", "LFJ4", "LFJ3", "LFJ2", "THJ5",
    "THJ4", "THJ3", "THJ2", "WRJ2", "WRJ1"};
 
constexpr std::array<const char*, joint_groups_count> joint_groups_names{
    "FirstFinger",  "MiddleFinger", "RingFinger",
    "LittleFinger", "Thumb",        "Wrist"};
 
constexpr std::size_t index_of(JointNames name) {
    return static_cast<std::size_t>(name);
}
 
constexpr std::size_t index_of(JointGroupsNames name) {
    return static_cast<std::size_t>(name);
}
 
constexpr std::size_t index_of(HandID id) {
    return static_cast<std::size_t>(id);
}
 
struct RawHandState {
    RawHandState() {
        joint_torques.fill(0);
        raw_joint_positions.fill(0);
        joint_positions.fill(0.);
        biotac_presures.fill(BiotacPressures{});
        biotac_temperatures.fill(BiotacTemperatures{});
        biotac_electrodes.fill(BiotacElectrodes{});
    }
 
    std::array<int16_t, joint_count> joint_torques;
    std::array<uint16_t, joint_count> raw_joint_positions;
    std::array<double, joint_count> joint_positions;
    std::array<BiotacPressures, biotac_count> biotac_presures;
    std::array<BiotacTemperatures, biotac_count> biotac_temperatures;
    std::array<BiotacElectrodes, biotac_count> biotac_electrodes;
};
 
struct RawHandCommand {
    explicit RawHandCommand(ControlMode mode) : control_mode{mode} {
        joint_torques.fill(0);
        joint_pwm.fill(0);
    }
 
    ControlMode control_mode;
    std::array<int16_t, joint_count> joint_torques;
    std::array<int16_t, joint_count> joint_pwm;
};
 
} // namespace ethercatcpp::shadow