int CDeviceCAN::OpenCAN()
{
int stat;
canInitializeLibrary();
canhandle = canOpenChannel(0, canOPEN_EXCLUSIVE);
if (canhandle < 0) {
AfxMessageBox("打开端口错误");
return STATUS_ERR;
}
Baudrates PCANBaudrate;
if(m_canBaudrate == 500)
{
PCANBaudrate = BAUD_500K;
}
else
{
PCANBaudrate = BAUD_250K;
}
stat = canSetBusParams(canhandle, PCANBaudrate, 0, 0, 1, 1, 0);
if (stat < 0)
{
AfxMessageBox("设置参数错误");
return STATUS_ERR;
}
stat = canBusOn(canhandle);
if (stat < 0) {
AfxMessageBox("挂入总线错误");
return STATUS_ERR;
}
return STATUS_OK;
}
//
//called when the OnBus button is pressed
//
void CCanTestMFCDlg::OnOnBus()
{
int stat;
int handle;
char tmpStr[200];
//init canlib
canInitializeLibrary();
//open channel 0
handle = canOpenChannel(0, canOPEN_EXCLUSIVE);
if (handle < 0) {
sprintf(tmpStr, "ERROR: canOpenChannel() handle returned: %d", handle);
AfxMessageBox(tmpStr);
}
//set up the bus
stat = canSetBusParams(handle, canBITRATE_125K, 0, 0, 0, 0, 0);
if (stat < 0) {
AfxMessageBox("ERROR: canSetBusParams().");
}
//go on bus
stat = canBusOn(handle);
if (stat < 0) {
AfxMessageBox("ERROR: canBusOn().");
}
//set notification
stat = canSetNotify(handle, this->GetSafeHwnd() , canNOTIFY_RX | canNOTIFY_ERROR | canNOTIFY_STATUS | canEVENT_TX | canNOTIFY_ENVVAR);
//save the can channel handle in the global variable m_handle
m_handle = handle;
}
/**
* @brief MainWindow::MainWindow
* @param parent
*/
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
connected = false;
canHandle = -1;
busOn = false;
uitimer.setInterval(100);
uitimer.start();
connect(&uitimer, SIGNAL(timeout()), this, SLOT(uiUpdate()));
connect(ui->lineEdit_CanByte0, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
connect(ui->lineEdit_CanByte1, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
connect(ui->lineEdit_CanByte2, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
connect(ui->lineEdit_CanByte3, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
connect(ui->lineEdit_CanByte4, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
connect(ui->lineEdit_CanByte5, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
connect(ui->lineEdit_CanByte6, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
connect(ui->lineEdit_CanByte7, SIGNAL(textChanged(QString)), this, SLOT(on_bytes_changed()));
canInitializeLibrary();
on_pushButtonRefresh_clicked();
ui->progressBarBusLoad->setMinimum(0);
ui->progressBarBusLoad->setMaximum(10000);
ui->comboBoxBaud->setCurrentIndex(2);
}
static bool dbg_kavaser_can_init(uint32 ch)
{
CanHandle handle;
canInitializeLibrary();
handle = canOpenChannel(dbg_kvaser.channel, canOPEN_EXCLUSIVE);
if (handle < 0) {
printf("dbg_kavaser_can_init:canOpenChannel err=%d\n", handle);
return FALSE;
}
printf("dbg_kavaser_can_init:canOpenChannel OK:handle=%d\n", handle);
dbg_kvaser.handle = handle;
dbg_kvaser.status = canSetBusParams(handle, dbg_kvaser.baud, 0, 0, 0, 0, 0);
if (dbg_kvaser.status != canOK) {
printf("dbg_kavaser_can_init:canSetBusParams err=%d\n", dbg_kvaser.status);
return FALSE;
}
printf("dbg_kavaser_can_init:canSetBusParams OK:baud=%d\n", dbg_kvaser.baud);
dbg_kvaser.status = canBusOn(handle);
if (dbg_kvaser.status != canOK) {
printf("dbg_kavaser_can_init:canBusOn err=%d\n", dbg_kvaser.status);
return FALSE;
}
printf("dbg_kavaser_can_init:canBusOn OK\n");
return TRUE;
}
int main(void)
{
canInitializeLibrary();
can_init();
i15765_init();
UIN15765_DEBUG_TRACE("%s OK!\n\r", __FUNCTION__ );
return 0;
}
void MainWindow::on_actionInstall_Drivers_triggered()
{
QMessageBox::StandardButton reply;
reply = QMessageBox::question(this, "Install", "Install kvaser drivers?",
QMessageBox::Yes|QMessageBox::No);
if (reply == QMessageBox::Yes) {
// install drivers
system("kvaser_drivers_setup.exe");
canInitializeLibrary();
on_pushButtonRefresh_clicked();
}else{
qDebug() << "Yes was *not* clicked";
}
}
int InitCtrlWithFlags(int ctrl, int bitrate, int flags)
{
int stat;
int hnd;
canInitializeLibrary();
hnd = canOpenChannel(ctrl, flags);
if (hnd < 0) Check("canOpenChannel", hnd);
if (bitrate < 0) {
stat = canSetBusParams(hnd, bitrate, 0, 0, 0, 0, 0);
Check("canSetBusParams", stat);
} else if (bitrate == 5000) {
// Special case for 5k
stat = canSetBusParams(hnd, 5000, 16, 8, 1, 1, 0);
Check("canSetBusParams", stat);
} else if (bitrate == 10000) {
// Special case for 10k
stat = canSetBusParams(hnd, 10000, 12, 7, 1, 1, 0);
Check("canSetBusParams", stat);
} else if (bitrate == 20000) {
// Special case for 20k
stat = canSetBusParamsC200(hnd, 0x58, 0x67);
Check("canSetBusParamsC200", stat);
} else if (bitrate == 40000) {
// Special case for 40k
stat = canSetBusParamsC200(hnd, 0x58, 0x14);
Check("canSetBusParamsC200", stat);
} else {
Error("Bad bitrate sent to canInitCtrlWithFlags: %u",bitrate);
}
stat = canBusOn(hnd);
Check("canBusOn", stat);
stat = canSetBusOutputControl(hnd, canDRIVER_NORMAL);
Check("canSetBusOutputControl", stat);
return hnd;
}
int main(int argc, char **argv)
{
int i, h;
int stat;
unsigned char buf[8];
if (argc != 2) {
printf("Usage: read_customer_data channel\n");
exit(1);
}
canInitializeLibrary();
h = canOpenChannel(atoi(argv[1]), 0);
if (h < 0) {
printf("Cannot open channel %s, error code %d\n", argv[1], h);
exit(1);
}
stat = kvReadDeviceCustomerData(h,
100 /*userNumber*/,
0, /* reserved, MBZ */
buf, sizeof(buf));
if (stat != canOK) {
printf("kvReadDeviceCustomerData returned error code %d\n", stat);
exit(1);
}
printf("User data: ");
for (i=0; i<(signed)sizeof(buf); i++) {
printf("%02x ", buf[i]);
}
printf("\n");
canClose(h);
return 0;
}
void main(int argc, char* argv[])
{
canStatus stat;
int i, chanCount;
printf("Starting...\n");
canInitializeLibrary();
stat = canGetNumberOfChannels(&chanCount);
Check("canGetNumberOfChannels", stat);
if (chanCount<0 || chanCount > 1000) {
printf("ChannelCount = %d but I don't believe it.\n", chanCount);
exit(1);
} else {
printf("%d channels.\n", chanCount);
}
for (i=0; i<chanCount; i++) {
DWORD tmp;
DWORD quad[2];
char name[64];
unsigned long ean[2];
printf("== Channel %d ===============================\n", i);
stat = canGetChannelData(i, canCHANNELDATA_CHANNEL_CAP, &tmp, sizeof(tmp));
Check("canGetChannelData", stat);
printf("Channel Capabilities = 0x%08lx ", tmp);
if (tmp & canCHANNEL_CAP_EXTENDED_CAN) printf("Ext ");
if (tmp & canCHANNEL_CAP_BUS_STATISTICS) printf("Stat ");
if (tmp & canCHANNEL_CAP_ERROR_COUNTERS) printf("ErrCnt ");
if (tmp & canCHANNEL_CAP_CAN_DIAGNOSTICS) printf("Diag ");
if (tmp & canCHANNEL_CAP_GENERATE_ERROR) printf("ErrGen ");
if (tmp & canCHANNEL_CAP_GENERATE_OVERLOAD) printf("OvlGen ");
if (tmp & canCHANNEL_CAP_TXREQUEST) printf("TxRq ");
if (tmp & canCHANNEL_CAP_TXACKNOWLEDGE) printf("TxAck ");
if (tmp & canCHANNEL_CAP_VIRTUAL) printf("Virt ");
if (tmp & canCHANNEL_CAP_SIMULATED) printf("Simulated ");
if (tmp & canCHANNEL_CAP_REMOTE) printf("Remote ");
printf("\n");
stat = canGetChannelData(i, canCHANNELDATA_TRANS_CAP, &tmp, sizeof(tmp));
Check("canGetChannelData", stat);
printf("DRVcan Capabilities = 0x%08lx ", tmp);
if (tmp & canDRIVER_CAP_HIGHSPEED) printf("HiSpd ");
printf("\n");
stat = canGetChannelData(i, canCHANNELDATA_CHANNEL_FLAGS, &tmp, sizeof(tmp));
Check("canGetChannelData", stat);
printf("Channel Flags = 0x%08lx\n", tmp);
stat = canGetChannelData(i, canCHANNELDATA_CARD_TYPE, &tmp, sizeof(tmp));
Check("canGetChannelData", stat);
printf("Board type = 0x%08lx", tmp);
switch (tmp) {
case canHWTYPE_NONE:
printf(" (Unknown)\n");
break;
case canHWTYPE_VIRTUAL:
printf(" (Virtual)\n");
break;
case canHWTYPE_LAPCAN:
printf(" (LAPcan family)\n");
break;
case canHWTYPE_PCCAN:
printf(" (PCcan Family)\n");
break;
case canHWTYPE_PCICAN:
printf(" (PCIcan Family)\n");
break;
case canHWTYPE_USBCAN:
printf(" (USBcan Family)\n");
break;
case canHWTYPE_PCICAN_II:
printf(" (PCIcan II Family)\n");
break;
case canHWTYPE_USBCAN_II:
printf(" (USBcan II Family (including Kvaser Memorator))\n");
break;
case canHWTYPE_LEAF:
printf(" (Kvaser Leaf Family)\n");
break;
case canHWTYPE_PC104_PLUS:
printf(" (PC104+ Family)\n");
break;
case canHWTYPE_PCICANX_II:
printf(" (PCIcanx II Family)\n");
break;
case canHWTYPE_MEMORATOR_PRO:
case canHWTYPE_UVP:
printf(" (Kvaser Memorator Professional Family)\n");
break;
case canHWTYPE_USBCAN_PRO:
printf(" (Kvaser USBcan Professional Family)\n");
break;
case canHWTYPE_IRIS:
printf(" (Kvaser BlackBird)\n");
break;
case canHWTYPE_EAGLE:
printf(" (Kvaser Eagle)\n");
break;
case canHWTYPE_MINIPCIE:
printf(" (Kvaser Mini PCI Express)\n");
break;
case canHWTYPE_USBCAN_LIGHT:
printf(" (Kvaser USBcan Light)\n");
break;
default:
printf(" (Unsupported)\n");
break;
}
stat = canGetChannelData(i, canCHANNELDATA_CARD_NUMBER, &tmp, sizeof(tmp));
Check("canCHANNELDATA_CARD_NUMBER", stat);
printf("Board Number = 0x%08lx\n", tmp);
stat = canGetChannelData(i, canCHANNELDATA_CHAN_NO_ON_CARD, &tmp, sizeof(tmp));
Check("canCHANNELDATA_CHAN_NO_ON_CARD", stat);
printf("Channel no on board = 0x%08lx\n", tmp);
stat = canGetChannelData(i, canCHANNELDATA_CARD_SERIAL_NO, quad, sizeof(quad));
Check("canCHANNELDATA_CARD_SERIAL_NO", stat);
printf("Board S/N = 0x%08lx 0x%08lx\n", quad[0], quad[1]);
stat = canGetChannelData(i, canCHANNELDATA_TRANS_SERIAL_NO, quad, sizeof(quad));
Check("canCHANNELDATA_TRANS_SERIAL_NO", stat);
printf("DRVcan S/N = 0x%08lx 0x%08lx\n", quad[0], quad[1]);
stat = canGetChannelData(i, canCHANNELDATA_CARD_FIRMWARE_REV, quad, sizeof(quad));
Check("canCHANNELDATA_CARD_FIRMWARE_REV", stat);
printf("Board F/W version = 0x%08lx 0x%08lx\n", quad[0], quad[1]);
stat = canGetChannelData(i, canCHANNELDATA_CARD_HARDWARE_REV, quad, sizeof(quad));
Check("canCHANNELDATA_CARD_HARDWARE_REV", stat);
printf("Board H/W version = 0x%08lx 0x%08lx\n", quad[0], quad[1]);
stat = canGetChannelData(i, canCHANNELDATA_CARD_UPC_NO, ean, sizeof(ean));
Check("canCHANNELDATA_CARD_UPC_NO", stat);
printf("Board UPC/EAN = 0x%08x 0x%08x\n", ean[1], ean[0]);
stat = canGetChannelData(i, canCHANNELDATA_TRANS_UPC_NO, ean, sizeof(ean));
Check("canCHANNELDATA_TRANS_UPC_NO", stat);
printf("DRVcan UPC/EAN = 0x%08x 0x%08x\n", ean[1], ean[0]);
stat = canGetChannelData(i, canCHANNELDATA_CHANNEL_NAME, name, sizeof(name));
Check("canCHANNELDATA_CHANNEL_NAME", stat);
printf("Channel name = '%s'\n", name);
stat = canGetChannelData(i, canCHANNELDATA_REMOTE_OPERATIONAL_MODE, &tmp, sizeof(tmp));
if (stat != canERR_NOT_IMPLEMENTED) {
Check("canCHANNELDATA_REMOTE_OPERATIONAL_MODE", stat);
printf("Operational mode = %d (%s)\n", tmp, CANCHANNEL_OPMODE_TEXT[tmp]);
stat = canGetChannelData(i, canCHANNELDATA_REMOTE_PROFILE_NAME, name, sizeof(name));
Check("canCHANNELDATA_REMOTE_PROFILE_NAME", stat);
printf("Profile name = '%s'\n", name);
stat = canGetChannelData(i, canCHANNELDATA_REMOTE_HOST_NAME, name, sizeof(name));
Check("canCHANNELDATA_REMOTE_HOST_NAME", stat);
printf("Remote host name = '%s'\n", name);
stat = canGetChannelData(i, canCHANNELDATA_REMOTE_MAC, name, sizeof(name));
Check("canCHANNELDATA_REMOTE_MAC", stat);
printf("MAC = '%s'\n", name);
} else {
printf("Device is not capable of acting in remote operational mode\n");
}
printf("\n");
}
}
int main(int argc, char *argv[])
{
canStatus stat;
canHandle hnd;
int channelRx;
int channelTx;
if (argc != 3) {
printUsageAndExit(argv[0]);
}
{
char *endPtr = NULL;
errno = 0;
channelRx = strtol(argv[1], &endPtr, 10);
if ( (errno != 0) || ((channelRx == 0) && (endPtr == argv[1])) ) {
printUsageAndExit(argv[0]);
}
channelTx = strtol(argv[2], &endPtr, 10);
if ( (errno != 0) || ((channelTx == 0) && (endPtr == argv[2])) ) {
printUsageAndExit(argv[0]);
}
}
canInitializeLibrary();
hnd = canOpenChannel(channelRx, canOPEN_REQUIRE_EXTENDED);
if (hnd < 0) {
printf("canOpenChannel %d", channelRx);
check("", hnd);
return -1;
}
stat = canBusOff(hnd);
check("canBusOff", stat);
if (stat != canOK) {
goto ErrorExit;
}
stat = canSetNotify(hnd, callback, canNOTIFY_ERROR | canNOTIFY_STATUS, NULL);
check("canSetNotify", stat);
if (stat != canOK) {
goto ErrorExit;
}
stat = canSetBusParams(hnd, bitrate, 0, 0, 0, 0, 0);
check("canSetBusParams", stat);
if (stat != canOK) {
goto ErrorExit;
}
stat = canBusOn(hnd);
check("canBusOn", stat);
if (stat != canOK) {
goto ErrorExit;
}
incBusLoad(channelTx, canOPEN_REQUIRE_EXTENDED, 0);
testBusLoad(hnd);
incBusLoad(channelTx, canOPEN_REQUIRE_EXTENDED, 100);
testBusLoad(hnd);
testBusLoad(hnd);
incBusLoad(channelTx, canOPEN_REQUIRE_EXTENDED, 300);
testBusLoad(hnd);
testBusLoad(hnd);
ErrorExit:
stat = canBusOff(hnd);
check("canBusOff", stat);
stat = canClose(hnd);
check("canClose", stat);
stat = canUnloadLibrary();
check("canUnloadLibrary", stat);
return 0;
}
void initCAN() { canInitializeLibrary(); }
