CANOpenUtil.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 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_CANOPENUTIL_H_
#define _MLAB_CANOPENUTIL_H_

#include <string>

#include <can/CANDefs.h>
#include <can/CANOpenDefs.h>

namespace mira { namespace can {


namespace CANOpenUtil
{


MLAB_CAN_EXPORT std::string getErrorMsg(CANOpenError pError);

MLAB_CAN_EXPORT std::string getTypeString(CANOpenType pType);

MLAB_CAN_EXPORT std::string getAccessModeString(CANOpenAccessMode pMode);

MLAB_CAN_EXPORT std::string getSDOKindString(CANOpenSDOKind pKind);

MLAB_CAN_EXPORT std::string getNodeStatusString(CANOpenNodeStatus pStatus);


template<typename T>
T read(const CANMessage& message, std::size_t offset)
{
    static_assert(sizeof(T) == 0, "Not implemented for this type.");
}

template<> MLAB_CAN_EXPORT int8 read<int8>(const CANMessage& message,
                                           std::size_t offset);

template<> MLAB_CAN_EXPORT int16 read<int16>(const CANMessage& message,
                                             std::size_t offset);

template<> MLAB_CAN_EXPORT int32 read<int32>(const CANMessage& message,
                                             std::size_t offset);

template<> MLAB_CAN_EXPORT int64 read<int64>(const CANMessage& message,
                                             std::size_t offset);

template<> MLAB_CAN_EXPORT uint8 read<uint8>(const CANMessage& message,
                                             std::size_t offset);

template<> MLAB_CAN_EXPORT uint16 read<uint16>(const CANMessage& message,
                                               std::size_t offset);

template<> MLAB_CAN_EXPORT uint32 read<uint32>(const CANMessage& message,
                                               std::size_t offset);

template<> MLAB_CAN_EXPORT uint64 read<uint64>(const CANMessage& message,
                                               std::size_t offset);

template<> MLAB_CAN_EXPORT float read<float>(const CANMessage& message,
                                             std::size_t offsete);

template<> MLAB_CAN_EXPORT double read<double>(const CANMessage& message,
                                               std::size_t offset);


template<typename T>
std::size_t write(CANMessage& ioMmessage, std::size_t offset, T value)
{
    static_assert(sizeof(T) == 0, "Not implemented for this type.");
    return(0);
}

template<> MLAB_CAN_EXPORT std::size_t write<int8>(CANMessage& ioMmessage,
                                                   std::size_t offset,
                                                   int8 value);

template<> MLAB_CAN_EXPORT std::size_t write<int16>(CANMessage& ioMmessage,
                                                    std::size_t offset,
                                                    int16 value);

template<> MLAB_CAN_EXPORT std::size_t write<int32>(CANMessage& ioMmessage,
                                                    std::size_t offset,
                                                    int32 value);

template<> MLAB_CAN_EXPORT std::size_t write<int64>(CANMessage& ioMmessage,
                                                    std::size_t offset,
                                                    int64 value);

template<> MLAB_CAN_EXPORT std::size_t write<uint8>(CANMessage& ioMmessage,
                                                    std::size_t offset,
                                                    uint8 value);

template<> MLAB_CAN_EXPORT std::size_t write<uint16>(CANMessage& ioMmessage,
                                                     std::size_t offset,
                                                     uint16 value);

template<> MLAB_CAN_EXPORT std::size_t write<uint32>(CANMessage& ioMmessage,
                                                     std::size_t offset,
                                                     uint32 value);

template<> MLAB_CAN_EXPORT std::size_t write<uint64>(CANMessage& ioMmessage,
                                                     std::size_t offset,
                                                     uint64 value);

template<> MLAB_CAN_EXPORT std::size_t write<float>(CANMessage& ioMmessage,
                                                    std::size_t offset,
                                                    float value);

template<> MLAB_CAN_EXPORT std::size_t write<double>(CANMessage& ioMmessage,
                                                     std::size_t offset,
                                                     double value);


} // namespace CANOpenUtil


}} // namespaces

#endif