CANOpenDefs.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_CANOPENDEFS_H_
#define _MLAB_CANOPENDEFS_H_

#include <platform/Types.h>

namespace mira { namespace can {


enum CANOpenError {
    CANOPEN_NO_ERROR                                  = 0x00000000,

    CANOPEN_SDO_ERROR_TOGGLE_BIT_NOT_ALTERNATED       = 0x05030000,
    CANOPEN_SDO_ERROR_SDO_PROTOCOL_TIMEOUT            = 0x05040000,
    CANOPEN_SDO_ERROR_UNKNOWN_COMMAND                 = 0x05040001,
    CANOPEN_SDO_ERROR_INVALID_BLOCK_SIZE              = 0x05040002,
    CANOPEN_SDO_ERROR_INVALID_SEQUENCE_NUMBER         = 0x05040003,
    CANOPEN_SDO_ERROR_CRC_ERROR                       = 0x05040004,
    CANOPEN_SDO_ERROR_OUT_OF_MEMORY                   = 0x05040005,
    CANOPEN_SDO_ERROR_UNSUPPORTED_ACCESS              = 0x06010000,
    CANOPEN_SDO_ERROR_READ_ON_WRITE_ONLY              = 0x06010001,
    CANOPEN_SDO_ERROR_WRITE_ON_READ_ONLY              = 0x06010002,
    CANOPEN_SDO_ERROR_OBJECT_DOES_NOT_EXISTS          = 0x06020000,
    CANOPEN_SDO_ERROR_CANNOT_MAPPED_TO_PDO            = 0x06040041,
    CANOPEN_SDO_ERROR_EXCEED_PDO                      = 0x06040042,
    CANOPEN_SDO_ERROR_PARAMETER_INCOMPATIBILITY       = 0x06040043,
    CANOPEN_SDO_ERROR_INTERNAL_INCOMPATIBILITY        = 0x06040047,
    CANOPEN_SDO_ERROR_HARDWARE_ERROR                  = 0x06060000,
    CANOPEN_SDO_ERROR_SERVICE_PRM_LEN_MISMATCH        = 0x06070010,
    CANOPEN_SDO_ERROR_SERVICE_PRM_LEN_TOO_HIGH        = 0x06070012,
    CANOPEN_SDO_ERROR_SERVICE_PRM_LEN_TOO_LOW         = 0x06070013,
    CANOPEN_SDO_ERROR_SUB_INDEX_DOES_NOT_EXIST        = 0x06090011,
    CANOPEN_SDO_ERROR_VALUE_RANGE_EXCEEDED            = 0x06090030,
    CANOPEN_SDO_ERROR_VALUE_PARAMETER_TOO_HIGH        = 0x06090031,
    CANOPEN_SDO_ERROR_VALUE_PARAMETER_TOO_LOW         = 0x06090032,
    CANOPEN_SDO_ERROR_MAXIMUM_LESS_THAN_MINIMUM       = 0x06090036,
    CANOPEN_SDO_ERROR_GENERAL_ERROR                   = 0x08000000,
    CANOPEN_SDO_ERROR_NO_DATA_TRANSFER                = 0x08000020,
    CANOPEN_SDO_ERROR_NO_DATA_TRANSFER_LOCAL          = 0x08000021,
    CANOPEN_SDO_ERROR_NO_DATA_TRANSFER_DEVICE         = 0x08000022,
    CANOPEN_SDO_ERROR_OBJECT_DICTIONARY_INVALID       = 0x08000023,

    CANOPEN_UNKNOWN_ERROR                             = 0xFFFFFFFF
};


enum CANOpenType {
    CANOPEN_TYPE_BOOLEAN           = 0x01,
    CANOPEN_TYPE_INTEGER8          = 0x02,
    CANOPEN_TYPE_INTEGER16         = 0x03,
    CANOPEN_TYPE_INTEGER32         = 0x04,
    CANOPEN_TYPE_UNSIGNED8         = 0x05,
    CANOPEN_TYPE_UNSIGNED16        = 0x06,
    CANOPEN_TYPE_UNSIGNED32        = 0x07,
    CANOPEN_TYPE_REAL32            = 0x08,
    CANOPEN_TYPE_VISIBLE_STRING    = 0x09,
    CANOPEN_TYPE_OCTET_STRING      = 0x0A,
    CANOPEN_TYPE_UNICODE_STRING    = 0x0B,
    CANOPEN_TYPE_TIME_OF_DAY       = 0x0C,
    CANOPEN_TYPE_TIME_DIFFERENCE   = 0x0D,
    // 0x0E: unused
    CANOPEN_TYPE_DOMAIN            = 0x0F,
    CANOPEN_TYPE_INTEGER24         = 0x10,
    CANOPEN_TYPE_REAL64            = 0x11,
    CANOPEN_TYPE_INTEGER40         = 0x12,
    CANOPEN_TYPE_INTEGER48         = 0x13,
    CANOPEN_TYPE_INTEGER56         = 0x14,
    CANOPEN_TYPE_INTEGER64         = 0x15,
    CANOPEN_TYPE_UNSIGNED24        = 0x16,
    // 0x17: unused
    CANOPEN_TYPE_UNSIGNED40        = 0x18,
    CANOPEN_TYPE_UNSIGNED48        = 0x19,
    CANOPEN_TYPE_UNSIGNED56        = 0x1A,
    CANOPEN_TYPE_UNSIGNED64        = 0x1B,
    // 0x1C .. 0x1F: unused
    CANOPEN_TYPE_PDO_COMM_PARAM    = 0x20,
    CANOPEN_TYPE_PDO_MAPPING       = 0x21,
    CANOPEN_TYPE_SDO_PARAMETER     = 0x22,
    CANOPEN_TYPE_IDENTITY          = 0x23
};


enum CANOpenSDOKind {
    CANOPEN_SDO_KIND_NULL          = 0x00,
    CANOPEN_SDO_KIND_DOMAIN        = 0x02,
    CANOPEN_SDO_KIND_DEFTYPE       = 0x05,
    CANOPEN_SDO_KIND_DEFSTRUCT     = 0x06,
    CANOPEN_SDO_KIND_VAR           = 0x07,
    CANOPEN_SDO_KIND_ARRAY         = 0x08,
    CANOPEN_SDO_KIND_RECORD        = 0x09
};


enum CANOpenAccessMode {
    CANOPEN_ACCESS_MODE_UNKNOWN = 0, 
    CANOPEN_ACCESS_MODE_RW,          
    CANOPEN_ACCESS_MODE_WO,          
    CANOPEN_ACCESS_MODE_RO,          
    CANOPEN_ACCESS_MODE_CONST        
};


enum CANOpenNodeStatus {
    CANOPEN_STATUS_UNKNOWN = 0,    
    CANOPEN_STATUS_BOOTUP,         
    CANOPEN_STATUS_STOPPED,        
    CANOPEN_STATUS_OPERATIONAL,    
    CANOPEN_STATUS_PRE_OPERATIONAL 
};


struct CANOpenNodeInfo
{
    CANOpenNodeInfo() :
        node(0),
        deviceType(0),
        hardwareVersion(0),
        softwareVersion(0),
        heartbeat(0),
        vendorID(0),
        productCode(0),
        revisionNumber(0),
        serialNumber(0),
        status(CANOPEN_STATUS_BOOTUP)
    {
        memset(&deviceName, 0x00, sizeof(deviceName));
    }

    uint8  node;
    uint32 deviceType;
    char   deviceName[5];
    uint32 hardwareVersion;
    uint32 softwareVersion;
    uint16 heartbeat;
    uint32 vendorID;
    uint32 productCode;
    uint32 revisionNumber;
    uint32 serialNumber;
    CANOpenNodeStatus status;
};


}} // namespaces

#endif