PowerSupplyPort.h

Go to the documentation of this file.

/*
 * Copyright (C) MetraLabs GmbH (MLAB), GERMANY.
 * All rights reserved.
 * Contact: info@MetraLabs.com
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MetraLabs.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file.  Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MetraLabs (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
 * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
 * OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLABS" HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN
 * "AS IS" BASIS, AND "MLAB" HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
 * SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MLAB_SCITOS_FUNCTION_BLOCK_POWER_SUPPLY_PORT_H_
#define _MLAB_SCITOS_FUNCTION_BLOCK_POWER_SUPPLY_PORT_H_

#include <FunctionBlock.h>

namespace mira { namespace robot {


class PowerSupplyPort_v0 : public FunctionBlock
{
    MIRA_OBJECT(PowerSupplyPort_v0)

public:

    PowerSupplyPort_v0() :
        subIndexIsCharging(0x08),
        subIndexVoltage(0xA),
        subIndexCurrent(0x0B)
    {
        functionBlockID = 0x02010001;   // firmware < 1.2.0
    }

    virtual ~PowerSupplyPort_v0() {}

    template <typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, FunctionBlock);

        r.roproperty("Charging",
                     getter<bool>(boost::bind(&PowerSupplyPort_v0::isCharging, this)),
                     "Current status");

        r.roproperty("Voltage",
                     getter<float>(boost::bind(&PowerSupplyPort_v0::getVoltage, this)),
                     "Current voltage [V]");

        r.roproperty("Current",
                     getter<float>(boost::bind(&PowerSupplyPort_v0::getCurrent, this)),
                     "Current current [A]");
    }

public:
    bool isCharging()
    {
        return sdoClient->readSync<uint32>(nodeID, index, subIndexIsCharging) > 0x00;
    }

    float getVoltage()
    {
        return 0.001f * sdoClient->readSync<uint32>(nodeID, index, subIndexVoltage);
    }

    float getCurrent()
    {
        return 0.001f * sdoClient->readSync<int32>(nodeID, index, subIndexCurrent);
    }

protected:
    uint8 subIndexIsCharging;

    uint8 subIndexVoltage;

    uint8 subIndexCurrent;
};


class PowerSupplyPort_v01 : public PowerSupplyPort_v0
{
    MIRA_OBJECT(PowerSupplyPort_v01)
public:
    PowerSupplyPort_v01() : PowerSupplyPort_v0()
    {
        functionBlockID = 0x01040001; // firmware >= 1.2.0
    }
};


class PowerSupplyPort_v1 : public PowerSupplyPort_v01
{
    MIRA_OBJECT(PowerSupplyPort_v1)
public:
    PowerSupplyPort_v1() : PowerSupplyPort_v01()
    {
        functionBlockID = 0x01040101;
    }
};


class PowerSupplyPort_v2 : public PowerSupplyPort_v1
{
    MIRA_OBJECT(PowerSupplyPort_v2)
public:
    PowerSupplyPort_v2() : PowerSupplyPort_v1()
    {
        functionBlockID = 0x01040201;
    }
};


class PowerSupplyPort_v3 : public PowerSupplyPort_v0
{
    MIRA_OBJECT(PowerSupplyPort_v3)

public:

    PowerSupplyPort_v3() : PowerSupplyPort_v0()
    {
        subIndexIsCharging         = 0x08;
        subIndexVoltage            = 0x04,
        subIndexCurrent            = 0x05;
        subIndexMaxCurrent         = 0x0A;
        subIndexEnable             = 0x06;
        subIndexMaxDissipatedPower = 0x0d;

        functionBlockID = 0x01040300;
    }

    virtual ~PowerSupplyPort_v3() {}

    template <typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, PowerSupplyPort_v0);

        r.roproperty("MaxCurrent",
                     getter<float>(boost::bind(&PowerSupplyPort_v3::getMaxCurrent, this)),
                     "Maximum current [A]");

        r.property("Enabled",
                   getter<bool>(boost::bind(&PowerSupplyPort_v3::isEnabled, this)),
                   setter<bool>(boost::bind(&PowerSupplyPort_v3::enable, this, _1)),
                   "Is port enabled", serialization::IgnoreMissing());

        r.roproperty("MaxDissipatedPower",
                     getter<float>(boost::bind(&PowerSupplyPort_v3::getMaxDissipatedPower, this)),
                     "Maximum allowed dissipated power in [W]");
    }

public:
    float getMaxCurrent()
    {
        return 0.001f * sdoClient->readSync<uint32>(nodeID, index, subIndexMaxCurrent);
    }

    void enable(bool enable)
    {
        sdoClient->writeSync<uint32>(nodeID, index, subIndexEnable, enable ? 0x01 : 0x00);
    }

    bool isEnabled()
    {
        return sdoClient->readSync<uint32>(nodeID, index, subIndexEnable) > 0x00;
    }

    float getMaxDissipatedPower()
    {
        return 1.0f * sdoClient->readSync<uint16>(nodeID, index, subIndexMaxDissipatedPower);
    }

protected:
    uint8 subIndexMaxCurrent;

    uint8 subIndexEnable;

    uint8 subIndexMaxDissipatedPower;
};


class PowerSupplyPort_v4 : public PowerSupplyPort_v3
{
    MIRA_OBJECT(PowerSupplyPort_v4)

public:

    PowerSupplyPort_v4() : PowerSupplyPort_v3()
    {
        subIndexCurrentDissipatedPower = 0x0e;

        functionBlockID = 0x01040302;
    }

    virtual ~PowerSupplyPort_v4() {}

public:
    template <typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, PowerSupplyPort_v3);

        r.roproperty("CurrentDissipatedPower",
                     getter<float>(boost::bind(&PowerSupplyPort_v4::getCurrentDissipatedPower, this)),
                     "Current dissipated power in [W]");
    }

public:
    float getCurrentDissipatedPower()
    {
        return 0.001f * sdoClient->readSync<uint16>(nodeID, index, subIndexCurrentDissipatedPower);
    }

public:
    uint8 subIndexCurrentDissipatedPower;
};


}}

#endif