UseMCACan.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------
// This file is part of FZIs ic_workspace.
//
// This program is free software licensed under the LGPL
// (GNU LESSER GENERAL PUBLIC LICENSE Version 3).
// You can find a copy of this license in LICENSE folder in the top
// directory of the source code.
//
// © Copyright 2016 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef _icl_hardware_can_UseMCACan_h_
#define _icl_hardware_can_UseMCACan_h_

#ifdef _SYSTEM_LINUX_
# include <errno.h>
# include <fcntl.h>
# include <unistd.h>
# include <sys/ioctl.h>
# include <string.h>
# include <stdlib.h>
#endif

#include "icl_hardware_can/tCanMessage.h"
typedef icl_hardware::can::tCanMessage tCanMessage;

#ifdef _SYSTEM_LXRT_
# include "CAN-lxrt.h"
#else
# include "icl_hardware_can/UseCanNoLxrt.h"
#endif

#ifdef _IC_BUILDER_CAN_MCA_HAS_IOCTL_H_
# include "CAN-ioctl.h"
#else
# define IOCTL_CAN_IOCRESET    0x01
# define IOCTL_CAN_SETBAUDRATE 0x02
# define IOCTL_CAN_IOCSETRMASK 0x03
# define IOCTL_CAN_SETSENDFIFOSIZE 0x04
# define IOCTL_CAN_SETRECEIVEFIFOSIZE 0x05
#endif

namespace icl_hardware {
namespace can {

typedef int tCanDescriptor;

inline bool CanDescriptorValid(tCanDescriptor can_device)
{
  return can_device >= 0;
}

inline tCanDescriptor InvalidCanDescriptor()
{
  return -1;
}

inline const char* CanDriverName()
{
  return "MCA-CAN";
}

#ifdef _SYSTEM_LXRT_

inline bool CanDriverLxrtSupport()
{
  return true;
}
#endif

#ifdef _SYSTEM_LINUX_


inline tCanDescriptor CanDeviceOpen(const char *device_name, int flags,
                                    unsigned char acceptance_code, unsigned char acceptance_mask, unsigned int baud_rate,
                                    unsigned send_fifo_size, unsigned receive_fifo_size)
{
  int can_device = open(device_name, flags);
  if (can_device >= 0)
  {
    long value = receive_fifo_size;
    if (ioctl(can_device, IOCTL_CAN_SETRECEIVEFIFOSIZE, value) < 0)
    {
      close(can_device);
      return -1;
    }
    value = send_fifo_size;
    if (ioctl(can_device, IOCTL_CAN_SETSENDFIFOSIZE, value) < 0)
    {
      close(can_device);
      return -1;
    }
    value = acceptance_mask;
    value = ((value << 8)) | (acceptance_code);
    if (ioctl(can_device, IOCTL_CAN_IOCSETRMASK, value) < 0)
    {
      close(can_device);
      return -1;
    }
    value = baud_rate;
    if (ioctl(can_device, IOCTL_CAN_SETBAUDRATE, value) < 0)
    {
      close(can_device);
      return -1;
    }
  }
  return can_device;
}


inline int CanDeviceClose(tCanDescriptor can_device)
{
  return close(can_device);
}

inline int CanDeviceSend(tCanDescriptor can_device, const tCanMessage &msg)
{
  return write(can_device, &msg, sizeof(tCanMessage));
}

inline int CanDeviceReceive(tCanDescriptor can_device, tCanMessage &msg)
{
  return read(can_device, &msg, sizeof(tCanMessage));
}


inline int CanDeviceReset(tCanDescriptor can_device)
{
  long value = 0;
  return ioctl(can_device, IOCTL_CAN_IOCRESET, value);
}
#endif

}
}

#endif