//-----------------------------------------------
void CanPeakSys::init()
{
std::string sCanDevice;
if( m_IniFile.GetKeyString( "TypeCan", "DevicePath", &sCanDevice, false) != 0) {
sCanDevice = "/dev/pcan32";
} else std::cout << "CAN-device path read from ini-File: " << sCanDevice << std::endl;
m_handle = LINUX_CAN_Open(sCanDevice.c_str(), O_RDWR);
if (! m_handle)
{
// Fatal error
std::cout << "Cannot open CAN-dongle on parallel port: " << strerror(errno) << std::endl;
sleep(3);
exit(0);
}
int ret = CAN_ERR_OK;
int iBaudrateVal = 0;
m_IniFile.GetKeyInt( "CanCtrl", "BaudrateVal", &iBaudrateVal, true);
switch(iBaudrateVal)
{
case 0:
ret = CAN_Init(m_handle, CAN_BAUD_1M, CAN_INIT_TYPE_ST);
break;
case 2:
ret = CAN_Init(m_handle, CAN_BAUD_500K, CAN_INIT_TYPE_ST);
break;
case 4:
ret = CAN_Init(m_handle, CAN_BAUD_250K, CAN_INIT_TYPE_ST);
break;
case 6:
ret = CAN_Init(m_handle, CAN_BAUD_125K, CAN_INIT_TYPE_ST);
break;
case 9:
ret = CAN_Init(m_handle, CAN_BAUD_50K, CAN_INIT_TYPE_ST);
break;
case 11:
ret = CAN_Init(m_handle, CAN_BAUD_20K, CAN_INIT_TYPE_ST);
break;
case 13:
ret = CAN_Init(m_handle, CAN_BAUD_10K, CAN_INIT_TYPE_ST);
break;
}
if(ret)
{
std::cout << "CanPeakSys::CanPeakSys(), error in init" << std::endl;
}
else
{
std::cout << "CanPeakSys::CanpeakSys(), init ok" << std::endl;
m_bInitialized = true;
}
}
//-----------------------------------------------
void CANPeakSysUSB::init()
{
//m_handle = LINUX_CAN_Open("/dev/pcan32", O_RDWR | O_NONBLOCK);
m_handle = LINUX_CAN_Open("/dev/pcan32", O_RDWR);
if (! m_handle)
{
// Fatal error
std::cout << "Cannot open CAN on USB: " << strerror(errno) << std::endl;
sleep(3);
exit(0);
}
int ret = CAN_ERR_OK;
int iBaudrateVal = 0;
m_IniFile.GetKeyInt( "CanCtrl", "BaudrateVal", &iBaudrateVal, true);
switch(iBaudrateVal)
{
case 0:
ret = CAN_Init(m_handle, CAN_BAUD_1M, CAN_INIT_TYPE_ST);
break;
case 2:
ret = CAN_Init(m_handle, CAN_BAUD_500K, CAN_INIT_TYPE_ST);
break;
case 4:
ret = CAN_Init(m_handle, CAN_BAUD_250K, CAN_INIT_TYPE_ST);
break;
case 6:
ret = CAN_Init(m_handle, CAN_BAUD_125K, CAN_INIT_TYPE_ST);
break;
case 9:
ret = CAN_Init(m_handle, CAN_BAUD_50K, CAN_INIT_TYPE_ST);
break;
case 11:
ret = CAN_Init(m_handle, CAN_BAUD_20K, CAN_INIT_TYPE_ST);
break;
case 13:
ret = CAN_Init(m_handle, CAN_BAUD_10K, CAN_INIT_TYPE_ST);
break;
}
if(ret)
{
std::cout << "CANPeakSysUSB::CANPeakSysUSB(), error in init" << std::endl;
}
else
{
std::cout << "CANPeakSysUSB::CanpeakSys(), init ok" << std::endl;
m_bInitialized = true;
}
}
//-----------------------------------------------
CANPeakSys2PCI::CANPeakSys2PCI(int iBaudRate, std::string strDeviceName)
{
m_bInitialized = false;
m_handle = LINUX_CAN_Open(strDeviceName.c_str(), O_RDWR);
if (! m_handle)
{
LOGERROR("can not open CANPeakSys2PCI device : " << strerror(errno));
Sleep(3000);
exit(0);
}
init(iBaudRate);
}
//-----------------------------------------------
CANPeakSysDongle::CANPeakSysDongle(int iBaudRate, std::string strDeviceName)
{
m_bInitialized = false;
m_handle = LINUX_CAN_Open(strDeviceName.c_str(), O_RDWR | O_NONBLOCK);
if (!m_handle)
{
// Fatal error
LOGERROR("can not open CANPeakSysDongle device : "<<strDeviceName<< " " << strerror(errno));
Sleep(3000);
exit(0);
}
OUTPUTINFO("baudrate: %i", iBaudRate);
init(iBaudRate);
}
//-----------------------------------------------
bool ros_for_can::init_ret()
{
bool ret = true;
// init() - part
m_handle = LINUX_CAN_Open(p_cDevice, O_RDWR);
if (! m_handle)
{
std::cout << "Cannot open CAN on USB: " << strerror(errno) << std::endl;
ret = false;
}
else
{
ret = initCAN();
}
return ret;
}
// open the CAN port
int open_can(bool bDevNodeGiven,bool bTypeGiven,const char *szDevNode,int nType,__u32 dwPort,__u16 wIrq)
{
int err = 0;
if ((bDevNodeGiven) || (!bDevNodeGiven && !bTypeGiven))
h = LINUX_CAN_Open(szDevNode, O_RDWR);
else
{
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
// HW_USB
h = CAN_Open(nType, dwPort, wIrq);
}
if (!h)
return 1;
return err;
}
CAN_HANDLE canOpen_driver(s_BOARD *board)
{
HANDLE fd0 = NULL;
char busname[64];
char* pEnd;
int baudrate;
if(strtol(board->busname, &pEnd,0) >= 0)
{
sprintf(busname,"/dev/pcan%s",board->busname);
fd0 = LINUX_CAN_Open(busname, O_RDWR);
}
if(fd0 && (baudrate = TranslateBaudeRate(board->baudrate)))
{
CAN_Init(fd0, baudrate, CAN_INIT_TYPE_ST);
}else{
fprintf(stderr, "canOpen_driver (Peak_Linux) : error opening %s\n", busname);
}
return (CAN_HANDLE)fd0;
}
/****************************************************************************
* Name: arm_caninit(void)
****************************************************************************/
int arm_caninit(){
/* Initialization of the CAN hardware is performed by logic external to
* this test.
*/
const char *szDeviceNode = DEFAULT_NODE;
errno = 0;
/* Open the CAN device for reading */
// open the CAN port
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
h = LINUX_CAN_Open(szDeviceNode, O_RDWR);
if (!h)
{
errno = nGetLastError();
perror("bitratetest: CAN_Open()");
return 0;
}
/*set the bitrate*/
errno = CAN_Init(h,CAN_BAUD_1M,CAN_INIT_TYPE_ST);
if(errno)
{
perror("set can speed error");
CAN_Close(h);
return 0;
}
/* Now loop the appropriate number of times, performing one loopback test
* on each pass.
*/
printf("can init is ok!\n");
//return 1 is ok;
return 1;
}
//-----------------------------------------------
void CANPeakSysUSB::init()
{
std::string sCanDevice;
if( m_IniFile.GetKeyString( "TypeCan", "DevicePath", &sCanDevice, false) != 0) {
sCanDevice = "/dev/pcan32";
} else std::cout << "CAN-device path read from ini-File: " << sCanDevice << std::endl;
//m_handle = LINUX_CAN_Open("/dev/pcan32", O_RDWR | O_NONBLOCK);
m_handle = LINUX_CAN_Open(sCanDevice.c_str(), O_RDWR);
if (! m_handle)
{
// Fatal error
std::cout << "Cannot open CAN on USB: " << strerror(errno) << std::endl;
sleep(3);
exit(0);
}
m_iBaudrateVal = 0;
m_IniFile.GetKeyInt( "CanCtrl", "BaudrateVal", &m_iBaudrateVal, true);
initCAN();
}
HANDLE initCAN(void)
{
const char *szDevNode = PCAN_DEVICE;
uint16_t wBTR0BTR1 = CAN_BAUD_RATE_REG_VAL;
HANDLE h;
h = LINUX_CAN_Open(szDevNode, O_RDWR);
if (!h)
{
printf("transmitest: can't open %s\n", szDevNode);
return NULL;
}
// init to a user defined bit rate
if (wBTR0BTR1)
{
errno = CAN_Init(h, wBTR0BTR1, CAN_INIT_TYPE_ST);
if (errno)
{
perror("transmitest: CAN_Init()");
return NULL;
}
}
return h;
}
// here all is done
int main(int argc, char *argv[])
{
char *ptr;
int i;
int nType = HW_PCI;
__u32 dwPort = 0;
__u16 wIrq = 0;
__u16 wBTR0BTR1 = 0;
int nExtended = CAN_INIT_TYPE_ST;
const char *szDevNode = DEFAULT_NODE;
bool bDevNodeGiven = false;
bool bTypeGiven = false;
bool bDisplayOn = true;
char txt[VERSIONSTRING_LEN];
errno = 0;
current_release = CURRENT_RELEASE;
disclaimer("receivetest");
init();
// decode command line arguments
for (i = 1; i < argc; i++) {
char c;
ptr = argv[i];
while (*ptr == '-')
ptr++;
c = *ptr;
ptr++;
if (*ptr == '=')
ptr++;
switch(tolower(c)) {
case 'f':
szDevNode = ptr;
bDevNodeGiven = true;
break;
case 'd':
if (strcmp(ptr, "no") == 0)
bDisplayOn = false;
break;
case 't':
nType = getTypeOfInterface(ptr);
if (!nType) {
errno = EINVAL;
printf("receivetest: unknown type of interface!\n");
goto error;
}
bTypeGiven = true;
break;
case 'p':
dwPort = strtoul(ptr, NULL, 16);
break;
case 'i':
wIrq = (__u16)strtoul(ptr, NULL, 10);
break;
case 'e':
nExtended = CAN_INIT_TYPE_EX;
break;
case '?':
case 'h':
hlpMsg();
goto error;
break;
case 'b':
wBTR0BTR1 = (__u16)strtoul(ptr, NULL, 16);
break;
default:
errno = EINVAL;
perror("receivetest: unknown command line argument!\n");
goto error;
break;
}
}
// simple command input check
if (bDevNodeGiven && bTypeGiven) {
errno = EINVAL;
perror("receivetest: device node and type together is useless");
goto error;
}
// give some information back
if (!bTypeGiven) {
printf("receivetest: device node=\"%s\"\n", szDevNode);
} else {
printf("receivetest: type=%s", getNameOfInterface(nType));
switch (nType) {
case HW_USB:
case HW_USB_PRO:
case HW_USB_FD:
case HW_USB_PRO_FD:
if (dwPort)
printf(", %d. device\n", dwPort);
else
printf(", standard device\n");
break;
default:
if (dwPort) {
if (nType == HW_PCI)
printf(", %d. PCI device", dwPort);
else
printf(", port=0x%08x", dwPort);
} else
printf(", port=default");
if ((wIrq) && !(nType == HW_PCI))
printf(" irq=0x%04x\n", wIrq);
else
printf(", irq=default\n");
break;
}
}
if (nExtended == CAN_INIT_TYPE_EX)
printf(" Extended frames are accepted");
else
printf(" Only standard frames are accepted");
if (wBTR0BTR1)
printf(", init with BTR0BTR1=0x%04x\n", wBTR0BTR1);
else
printf(", init with 500 kbit/sec.\n");
/* open CAN port */
if ((bDevNodeGiven) || (!bDevNodeGiven && !bTypeGiven)) {
h = LINUX_CAN_Open(szDevNode, O_RDWR);
if (!h) {
printf("receivetest: can't open %s\n", szDevNode);
goto error;
}
} else {
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
h = CAN_Open(nType, dwPort, wIrq);
if (!h) {
printf("receivetest: can't open %s device.\n",
getNameOfInterface(nType));
goto error;
}
}
/* clear status */
// CAN_Status(h);
// get version info
errno = CAN_VersionInfo(h, txt);
if (!errno)
printf("receivetest: driver version = %s\n", txt);
else {
perror("receivetest: CAN_VersionInfo()");
goto error;
}
// init to a user defined bit rate
if (wBTR0BTR1) {
errno = CAN_Init(h, wBTR0BTR1, nExtended);
if (errno) {
perror("receivetest: CAN_Init()");
goto error;
}
}
errno = read_loop(bDisplayOn);
if (!errno)
return 0;
error:
do_exit(errno);
return errno;
}
bool openConnection(std::string devName) {
h = LINUX_CAN_Open(devName.c_str(), O_RDWR);
if (!h) return false;
errno = CAN_Init(h, CAN_BAUD_500K, CAN_INIT_TYPE_ST);
return true;
}
// here all is done
int main(int argc, char *argv[])
{
char *ptr;
int i;
const char *szDeviceNode = DEFAULT_NODE;
errno = 0;
current_release = CURRENT_RELEASE;
disclaimer("bitratetest");
// decode command line arguments
for (i = 1; i < argc; i++)
{
char c;
ptr = argv[i];
while (*ptr == '-')
ptr++;
c = *ptr;
ptr++;
if (*ptr == '=')
ptr++;
switch(tolower(c))
{
case 'f':
szDeviceNode = ptr;
break;
case '?':
case 'h':
hlpMsg();
my_private_exit(0);
break;
default:
errno = EINVAL;
perror("bitratetest: unknown command line argument");
my_private_exit(errno);
break;
}
}
// open the CAN port
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
h = LINUX_CAN_Open(szDeviceNode, O_RDWR);
if (h)
{
char txt[VERSIONSTRING_LEN];
// get version info
errno = CAN_VersionInfo(h, txt);
if (!errno)
printf("bitratetest: driver version = %s\n", txt);
else
{
perror("bitratetest: CAN_VersionInfo()");
my_private_exit(errno);
}
printf("\n");
// calculate BTR0BTR1 from bitrates
for (i = 1000000; i > 2500; i /= 2)
{
if (i == 62500)
i = 100000;
if (i == 6250)
i = 10000;
printf("bitratetest: %d bits/sec \t->BTR0BTR1=0x%04x\n", i + 1, LINUX_CAN_BTR0BTR1(h, i + 1));
printf(" %d bits/sec \t->BTR0BTR1=0x%04x\n", i , LINUX_CAN_BTR0BTR1(h, i));
printf(" %d bits/sec \t->BTR0BTR1=0x%04x\n", i - 1, LINUX_CAN_BTR0BTR1(h, i - 1));
};
printf("\n");
}
else
{
errno = nGetLastError();
perror("bitratetest: CAN_Open()");
}
my_private_exit(errno);
return errno;
}
void BVCan::initializeCan( ){
#ifdef USE_CAN
WORD awBTR0BTR1=0x0014;
int aCANMsgType=0;
h = NULL;
errno = 0;
device = string("/dev/pcan32");
// open the device
// // O_RDWR which request opening the file read/write
h = LINUX_CAN_Open((char*)(device.c_str()), O_RDWR);
if (h==0)
{
device = string("/dev/pcan0");
h = LINUX_CAN_Open((char*)(device.c_str()), O_RDWR);
}
if(h==0){
cerr<< "PCan_Device nicht gefunden !!!"<<endl;
exit(37);
}
if(h){
PCAN_DESCRIPTOR *desc= (PCAN_DESCRIPTOR *)h;
BV_ASSERT( desc->nFileNo>0 );
BV_DEBUGINFO4NNL("BVCan::ctor device=[" << desc->szDevicePath << "]");
BV_DEBUGINFO4C(" fd=[" << desc->nFileNo << "]" << endl);
setfd(desc->nFileNo);
CAN_Status(h);
// -----------------------------------------------------------
// returns a text string with driver version info
errno = CAN_VersionInfo(h, info);
if (!errno){
string infostr( string(info) );
BV_DEBUGINFO4("BVCan::ctor driver version=[" << infostr << "]");
}
else
perror("BVCan::ctor CAN_VersionInfo()");
wBTR0BTR1 = 0x401c;
if(LINUX_CAN_BTR0BTR1(h,wBTR0BTR1)==0)
BV_WARNING("BVCan::ctor 0x" << hex << wBTR0BTR1 << dec << " is not possible" );
else
BV_DEBUGINFO4("BVCan::ctor baudrate changes to 0x" << hex << wBTR0BTR1 << dec );
}
else
BV_DEBUGINFO4("BVCan::ctor cannot open the can device");
BV_WARNING("BVCan::initializeCan .....................");
if(h){
// init to a user defined bit rate
//nExtended = CAN_INIT_TYPE_ST;
//wBTR0BTR1 = CAN_BAUD_500K;
canMsgType = aCANMsgType;
wBTR0BTR1 = awBTR0BTR1;
errno = CAN_Init(h, wBTR0BTR1, canMsgType);
if (errno)
perror("BVCan::initializeCan CAN_Init failed");
else
BV_WARNING("BVCan::initializeCan baudrate=0x" << hex << wBTR0BTR1 << dec << " msgType=" << canMsgType );
}
else
BV_WARNING("BVCan::initializeCan can HANDLE is NULL");
#endif
}
//constructor
CmdVelToCAN() :
yaw_(0.0),
throttle_(2000.0),
reverse_on(false),
forward(true),
reverse(false)
{
nh_.param<std::string>("cmd_vel_topic", cmd_vel_topic_, "/cmd_vel");
nh_.param<std::string>("can_device", can_device_, "/dev/pcanusb0");
cmd_vel_sub_ = nh_.subscribe(cmd_vel_topic_, 1, &CmdVelToCAN::cmd_vel_callback, this);
errno=0;
char baudrate[7] = "0x0014"; //1 Mbit/s
//char baudrate[7] = "0x001C"; //500 kbit/s
//char baudrate[7] = "0x011C"; //250 kbit/s
std::cout << "here scheppert dat" << std::endl;
int wBTR0BTR1 = (int)strtoul(baudrate, NULL, 16);
int nExtended = 0;
std::cout << wBTR0BTR1 << std::endl;
std::cout << nExtended << std::endl;
h_ = LINUX_CAN_Open(can_device_.c_str(), O_RDWR);
if (!h_) {
ROS_ERROR("CMD_VEL_TO_CAN: can't open %s\n", can_device_.c_str());
return;
}
else {
ROS_INFO("CMD_VEL_TO_CAN: succesfully opened %s\n", can_device_.c_str());
}
/* clear status */
CAN_Status(h_);
errno = CAN_Init(h_, wBTR0BTR1, 0);
std::cout << "bla bla" << std::endl;
//prepare reverse / normal throttle msgs
one_IEEE754 = 1;
zero_IEEE754 = 0;
reverse_throttle_msg_.ID = 3;
reverse_throttle_msg_.MSGTYPE = MSGTYPE_STANDARD;
reverse_throttle_msg_.LEN = 1;
reverse_throttle_msg_.DATA[0] = one_IEEE754;
normal_throttle_msg_.ID = 3;
normal_throttle_msg_.MSGTYPE = MSGTYPE_STANDARD;
normal_throttle_msg_.LEN = 1;
normal_throttle_msg_.DATA[0] = zero_IEEE754;
ros::Rate r(20);
while(ros::ok()) {
_publish();
ros::spinOnce();
r.sleep();
}
}
void pcan_transmit::init(int argc, char **argv)
{
/*!
*\brief The init() function is based on the middle part of the main() function of the transmitest program.
*
* Compared to the transmitest program a lot of cases have been removed.
* Therefore, only the PCAN-USB adapter is, and standard messages are, supported.
*
* */
int nExtended = CAN_INIT_TYPE_ST;
int nType;
__u32 dwPort;
__u16 wIrq;
char *ptr;
__u16 wBTR0BTR1 = 0x011C;
// parameter wBTR0BTR1
// bitrate codes of BTR0/BTR1 registers
//#define CAN_BAUD_1M 0x0014 // 1 MBit/s
//#define CAN_BAUD_500K 0x001C // 500 kBit/s
//#define CAN_BAUD_250K 0x011C // 250 kBit/s
//#define CAN_BAUD_125K 0x031C // 125 kBit/s
//#define CAN_BAUD_100K 0x432F // 100 kBit/s
//#define CAN_BAUD_50K 0x472F // 50 kBit/s
//#define CAN_BAUD_20K 0x532F // 20 kBit/s
//#define CAN_BAUD_10K 0x672F // 10 kBit/s
//#define CAN_BAUD_5K 0x7F7F // 5 kBit/s
const char *szDevNode = DEFAULT_NODE;
bool bDevNodeGiven = false;
bool bTypeGiven = false;
char txt[VERSIONSTRING_LEN];
/* QApplication a(argc, argv);
QWidget *mainWindow=new QWidget;
mainWindow->setWindowTitle("Change the Data Value");
QSlider *slider= new QSlider(Qt::Horizontal);
QSpinBox *spinner= new QSpinBox;
slider->setRange(0,100);
spinner->setRange(0,100);
connect(ui->slider, SIGNAL(valueChanged(double)), SLOT(onSliderValueChanged(double)));
double slidValue= ui->Slider->value();
//string msg[]= "ID, LEN, ss";*/
// decode command line arguments
for (int i = 1; i < argc; i++)
{
char c;
ptr = argv[i];
while (*ptr == '-')
ptr++;
c = *ptr;
ptr++;
if (*ptr == '=')
ptr++;
switch(tolower(c))
{
case '?':
case 'h':
hlpMsg();
do_exit(errno, h);
break;
case 'f':
szDevNode = ptr;
bDevNodeGiven = true;
break;
case 'b':
wBTR0BTR1 = (__u16)strtoul(ptr, NULL, 16);
break;
default:
errno = EINVAL;
do_exit(errno, h);;
break;
}
}
/* open CAN port */
if ((bDevNodeGiven) || (!bDevNodeGiven && !bTypeGiven))
{
h = LINUX_CAN_Open(szDevNode, O_RDWR);
if (!h)
{
printf("pcan_transmit: can't open %s\n", szDevNode);
do_exit(errno, h);;
}
}
else {
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
h = CAN_Open(nType, dwPort, wIrq);
if (!h)
{
printf("pcan_transmit: can't open %s device.\n", getNameOfInterface(nType));
do_exit(errno, h);;
}
}
/* clear status */
CAN_Status(h);
// get version info
errno = CAN_VersionInfo(h, txt);
if (!errno)
printf("pcan_transmit: driver version = %s\n", txt);
else {
perror("pcan_transmit: CAN_VersionInfo()");
do_exit(errno, h);;
}
// init to a user defined bit rate
if (wBTR0BTR1)
{
errno = CAN_Init(h, wBTR0BTR1, nExtended);
if (errno)
{
perror("pcan_transmit: CAN_Init()");
do_exit(errno, h);;
}
}
}
int main(int argc, char *argv[])
{
char *ptr;
int i;
int nType = HW_PCI;
__u32 dwPort = 0;
__u16 wIrq = 0;
__u16 wBTR0BTR1 = 0;
__u32 dwMaxTimeInterval = 0, dwMaxLoop = 0;
char *filename = NULL;
const char *szDevNode = DEFAULT_NODE;
bool bDevNodeGiven = false;
bool bTypeGiven = false;
parser MyParser;
char txt[VERSIONSTRING_LEN];
errno = 0;
current_release = CURRENT_RELEASE;
disclaimer("transmitest");
init();
// decode command line arguments
for (i = 1; i < argc; i++)
{
char c;
ptr = argv[i];
if (*ptr == '-')
{
while (*ptr == '-')
ptr++;
c = *ptr;
ptr++;
if (*ptr == '=')
ptr++;
switch(tolower(c))
{
case 'f':
szDevNode = ptr;
bDevNodeGiven = true;
break;
case 't':
nType = getTypeOfInterface(ptr);
if (!nType)
{
errno = EINVAL;
printf("transmitest: unknown type of interface\n");
goto error;
}
bTypeGiven = true;
break;
case 'p':
dwPort = strtoul(ptr, NULL, 16);
break;
case 'i':
wIrq = (__u16)strtoul(ptr, NULL, 10);
break;
case 'e':
nExtended = CAN_INIT_TYPE_EX;
break;
case '?':
case 'h':
hlpMsg();
goto error;
break;
case 'b':
wBTR0BTR1 = (__u16)strtoul(ptr, NULL, 16);
break;
case 'r':
dwMaxTimeInterval = strtoul(ptr, NULL, 10);
break;
case 'n':
dwMaxLoop = strtoul(ptr, NULL, 10);
break;
default:
errno = EINVAL;
printf("transmitest: unknown command line argument\n");
goto error;
break;
}
}
else
filename = ptr;
}
// test for filename
if (filename == NULL)
{
errno = EINVAL;
perror("transmitest: no filename given");
goto error;
}
// test device node and type
if (bDevNodeGiven && bTypeGiven)
{
errno = EINVAL;
perror("transmitest: device node and type together is useless");
goto error;
}
// give the filename to my parser
MyParser.setFileName(filename);
// tell some information to the user
if (!bTypeGiven)
{
printf("transmitest: device node=\"%s\"\n", szDevNode);
}
else {
printf("transmitest: type=%s", getNameOfInterface(nType));
if (nType == HW_USB)
printf(", Serial Number=default, Device Number=%d\n", dwPort);
else {
if (dwPort)
{
if (nType == HW_PCI)
printf(", %d. PCI device", dwPort);
else
printf(", port=0x%08x", dwPort);
}
else
printf(", port=default");
if ((wIrq) && !(nType == HW_PCI))
printf(" irq=0x%04x\n", wIrq);
else
printf(", irq=default\n");
}
}
if (nExtended == CAN_INIT_TYPE_EX)
printf(" Extended frames are sent");
else
printf(" Only standard frames are sent");
if (wBTR0BTR1)
printf(", init with BTR0BTR1=0x%04x\n", wBTR0BTR1);
else
printf(", init with 500 kbit/sec.\n");
printf(" Data will be read from \"%s\".\n", filename);
if (dwMaxTimeInterval)
printf(" Messages are send in random time intervalls with a max. gap time of %d msec.\n", dwMaxTimeInterval);
/* get the list of data from parser */
List = MyParser.Messages();
if (!List)
{
errno = MyParser.nGetLastError();
perror("transmitest: error at file read");
goto error;
}
/* open CAN port */
if ((bDevNodeGiven) || (!bDevNodeGiven && !bTypeGiven))
{
h = LINUX_CAN_Open(szDevNode, O_RDWR);
if (!h)
{
printf("transmitest: can't open %s\n", szDevNode);
goto error;
}
}
else {
// please use what is appropriate
// HW_DONGLE_SJA
// HW_DONGLE_SJA_EPP
// HW_ISA_SJA
// HW_PCI
h = CAN_Open(nType, dwPort, wIrq);
if (!h)
{
printf("transmitest: can't open %s device.\n", getNameOfInterface(nType));
goto error;
}
}
/* clear status */
CAN_Status(h);
// get version info
errno = CAN_VersionInfo(h, txt);
if (!errno)
printf("transmitest: driver version = %s\n", txt);
else {
perror("transmitest: CAN_VersionInfo()");
goto error;
}
// init to a user defined bit rate
if (wBTR0BTR1)
{
errno = CAN_Init(h, wBTR0BTR1, nExtended);
if (errno)
{
perror("transmitest: CAN_Init()");
goto error;
}
}
// enter in the write loop
errno = write_loop(dwMaxTimeInterval, dwMaxLoop);
if (!errno)
return 0;
error:
do_exit(errno);
return errno;
}