PCANBasic-Wrapper/Examples/C++/can_recv.cpp at 09948b9920be75af23a29f25eb6969484d14c396 · uv-software/PCANBasic-Wrapper · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
//
//  can_recv.cpp
//  PCANBasic-Wrapper
//  Receive some CAN messages using the C++ API (PeakCAN.h)
//  Library: PeakCAN.dll, libPeakCAN.dylib, libpeakcan.so
//
#ifdef _MSC_VER
//no Microsoft extensions please!
#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS 1
#endif
#endif
#include <iostream>
#include <signal.h>
#include <errno.h>

#include "PeakCAN.h"

#ifndef CHANNEL
#define CHANNEL  0x51
#endif
#ifndef BAUDRATE
#define BAUDRATE  CANBTR_INDEX_250K
#endif

static void sigterm(int signo);
static volatile int running = 1;

static CPeakCAN myDriver = CPeakCAN();

int main(/*int argc, const char * argv[]*/) {
    CANAPI_OpMode_t opMode = {};
    opMode.byte = CANMODE_DEFAULT;
    CANAPI_Bitrate_t bitrate = {};
    bitrate.index = BAUDRATE;
    CANAPI_Message_t message = {};
    CANAPI_Return_t retVal = 0;
    int frames = 0;

    std::cout << CPeakCAN::GetVersion() << std::endl;
    if((signal(SIGINT, sigterm) == SIG_ERR) ||
#if !defined(_WIN32) && !defined(_WIN64)
       (signal(SIGHUP, sigterm) == SIG_ERR) ||
#endif
       (signal(SIGTERM, sigterm) == SIG_ERR)) {
        perror("+++ error");
        return errno;
    }
    if ((retVal = myDriver.InitializeChannel(CHANNEL, opMode)) != CCanApi::NoError) {
        std::cerr << "+++ error: interface could not be initialized" << std::endl;
        return retVal;
    }
    if ((retVal = myDriver.StartController(bitrate)) != CCanApi::NoError) {
        std::cerr << "+++ error: interface could not be started" << std::endl;
        goto teardown;
    }
    std::cout << "Press ^C to abort." << std::endl;
    while (running) {
        if ((retVal = myDriver.ReadMessage(message, CANREAD_INFINITE)) == CCanApi::NoError) {
            fprintf(stdout, "%i\t", frames++);
            fprintf(stdout, "%7li.%04li\t", (long)message.timestamp.tv_sec, message.timestamp.tv_nsec / 100000);
            fprintf(stdout, "%03X\t", message.id);
            if (!message.sts) {
                fputc(message.xtd ? 'X' : 'S', stdout);
                fputc(message.fdf ? 'F' : '-', stdout);
                fputc(message.brs ? 'B' : '-', stdout);
                fputc(message.esi ? 'E' : '-', stdout);
                fputc(message.rtr ? 'R' : '-', stdout);
            } else {
                fprintf(stdout, "Error");
            }
            printf(" [%u]", CCanApi::Dlc2Len(message.dlc));
            for (uint8_t i = 0; i < CCanApi::Dlc2Len(message.dlc); i++)
                fprintf(stdout, " %02X", message.data[i]);
            if (message.sts)
                fprintf(stdout, " <<< status frame");
            fprintf(stdout, "\n");
        }
        else if (retVal != CCanApi::ReceiverEmpty) {
            fprintf(stderr, "+++ error: read message returned %i", retVal);
            running = 0;
        }
    }
    std::cout << std::endl;
teardown:
    if ((retVal = myDriver.TeardownChannel()) != CCanApi::NoError)
        std::cerr << "+++ error: interface could not be shutdown" << std::endl;
    std::cout << "Cheers!" << std::endl;
    return retVal;
}

static void sigterm(int signo) {
    //fprintf(stderr, "%s: got signal %d\n", __FILE__, signo);
    myDriver.SignalChannel();
    running = 0;
    (void)signo;
}