6 * cangen.c - CAN frames generator for testing purposes
8 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of Volkswagen nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * Alternatively, provided that this notice is retained in full, this
24 * software may be distributed under the terms of the GNU General
25 * Public License ("GPL") version 2, in which case the provisions of the
26 * GPL apply INSTEAD OF those given above.
28 * The provided data structures and external interfaces from this code
29 * are not restricted to be used by modules with a GPL compatible license.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
36 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
37 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
38 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
39 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
41 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
44 * Send feedback to <socketcan-users@lists.berlios.de>
61 #include <sys/types.h>
62 #include <sys/socket.h>
63 #include <sys/ioctl.h>
67 #include <linux/can.h>
68 #include <linux/can/raw.h>
71 #define DEFAULT_GAP 200 /* ms */
74 #define MODE_INCREMENT 1
77 extern int optind, opterr, optopt;
79 static volatile int running = 1;
80 static unsigned long long enobufs_count;
82 void print_usage(char *prg)
84 fprintf(stderr, "\n%s: generate CAN frames\n\n", prg);
85 fprintf(stderr, "Usage: %s [options] <CAN interface>\n", prg);
86 fprintf(stderr, "Options: -g <ms> (gap in milli seconds "
87 "- default: %d ms)\n", DEFAULT_GAP);
88 fprintf(stderr, " -e (generate extended frame mode "
89 "(EFF) CAN frames)\n");
90 fprintf(stderr, " -I <mode> (CAN ID"
91 " generation mode - see below)\n");
92 fprintf(stderr, " -L <mode> (CAN data length code (dlc)"
93 " generation mode - see below)\n");
94 fprintf(stderr, " -D <mode> (CAN data (payload)"
95 " generation mode - see below)\n");
96 fprintf(stderr, " -p <timeout> (poll on -ENOBUFS to write frames"
97 " with <timeout> ms)\n");
98 fprintf(stderr, " -n <count> (terminate after <count> CAN frames "
99 "- default infinite)\n");
100 fprintf(stderr, " -i (ignore -ENOBUFS return values on"
101 " write() syscalls)\n");
102 fprintf(stderr, " -x (disable local loopback of "
103 "generated CAN frames)\n");
104 fprintf(stderr, " -v (increment verbose level for "
105 "printing sent CAN frames)\n\n");
106 fprintf(stderr, "Generation modes:\n");
107 fprintf(stderr, "'r' => random values (default)\n");
108 fprintf(stderr, "'i' => increment values\n");
109 fprintf(stderr, "<hexvalue> => fix value using <hexvalue>\n\n");
110 fprintf(stderr, "When incrementing the CAN data the data length code "
111 "minimum is set to 1.\n");
112 fprintf(stderr, "CAN IDs and data content are given and expected in hexadecimal values.\n\n");
113 fprintf(stderr, "Examples:\n");
114 fprintf(stderr, "%s vcan0 -g 4 -I 42A -L 1 -D i -v -v ", prg);
115 fprintf(stderr, "(fixed CAN ID and length, inc. data)\n");
116 fprintf(stderr, "%s vcan0 -e -L i -v -v -v ", prg);
117 fprintf(stderr, "(generate EFF frames, incr. length)\n");
118 fprintf(stderr, "%s vcan0 -D 11223344DEADBEEF -L 8 ", prg);
119 fprintf(stderr, "(fixed CAN data payload and length)\n");
120 fprintf(stderr, "%s vcan0 -g 0 -i -x ", prg);
121 fprintf(stderr, "(full load test ignoring -ENOBUFS)\n");
122 fprintf(stderr, "%s vcan0 -g 0 -p 10 -x ", prg);
123 fprintf(stderr, "(full load test with polling, 10ms timeout)\n");
124 fprintf(stderr, "%s vcan0 ", prg);
125 fprintf(stderr, "(my favourite default :)\n\n");
128 void sigterm(int signo)
133 int main(int argc, char **argv)
135 unsigned long gap = DEFAULT_GAP;
136 unsigned long polltimeout = 0;
137 unsigned char ignore_enobufs = 0;
138 unsigned char extended = 0;
139 unsigned char id_mode = MODE_RANDOM;
140 unsigned char data_mode = MODE_RANDOM;
141 unsigned char dlc_mode = MODE_RANDOM;
142 unsigned char loopback_disable = 0;
143 unsigned char verbose = 0;
145 uint64_t incdata = 0;
151 struct sockaddr_can addr;
152 static struct can_frame frame;
160 /* set seed value for pseudo random numbers */
161 gettimeofday(&now, NULL);
162 srandom(now.tv_usec);
164 signal(SIGTERM, sigterm);
165 signal(SIGHUP, sigterm);
166 signal(SIGINT, sigterm);
168 while ((opt = getopt(argc, argv, "ig:eI:L:D:xp:n:vh?")) != -1) {
176 gap = strtoul(optarg, NULL, 10);
184 if (optarg[0] == 'r') {
185 id_mode = MODE_RANDOM;
186 } else if (optarg[0] == 'i') {
187 id_mode = MODE_INCREMENT;
190 frame.can_id = strtoul(optarg, NULL, 16);
195 if (optarg[0] == 'r') {
196 dlc_mode = MODE_RANDOM;
197 } else if (optarg[0] == 'i') {
198 dlc_mode = MODE_INCREMENT;
201 frame.can_dlc = atoi(optarg)%9;
206 if (optarg[0] == 'r') {
207 data_mode = MODE_RANDOM;
208 } else if (optarg[0] == 'i') {
209 data_mode = MODE_INCREMENT;
211 data_mode = MODE_FIX;
212 if (hexstring2candata(optarg, &frame)) {
213 printf ("wrong fix data definition\n");
224 loopback_disable = 1;
228 polltimeout = strtoul(optarg, NULL, 10);
232 count = atoi(optarg);
234 print_usage(basename(argv[0]));
242 print_usage(basename(argv[0]));
248 if (optind == argc) {
249 print_usage(basename(argv[0]));
253 ts.tv_sec = gap / 1000;
254 ts.tv_nsec = (gap % 1000) * 1000000;
256 if (id_mode == MODE_FIX) {
258 /* recognize obviously missing commandline option */
259 if ((frame.can_id > 0x7FF) && !extended) {
260 printf("The given CAN-ID is greater than 0x7FF and "
261 "the '-e' option is not set.\n");
266 frame.can_id &= CAN_EFF_MASK;
268 frame.can_id &= CAN_SFF_MASK;
272 frame.can_id |= CAN_EFF_FLAG;
274 if ((data_mode == MODE_INCREMENT) && !frame.can_dlc)
275 frame.can_dlc = 1; /* min dlc value for incr. data */
277 if (strlen(argv[optind]) >= IFNAMSIZ) {
278 printf("Name of CAN device '%s' is too long!\n\n", argv[optind]);
282 if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
287 addr.can_family = AF_CAN;
289 strcpy(ifr.ifr_name, argv[optind]);
290 if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
291 perror("SIOCGIFINDEX");
294 addr.can_ifindex = ifr.ifr_ifindex;
296 /* disable default receive filter on this RAW socket */
297 /* This is obsolete as we do not read from the socket at all, but for */
298 /* this reason we can remove the receive list in the Kernel to save a */
299 /* little (really a very little!) CPU usage. */
300 setsockopt(s, SOL_CAN_RAW, CAN_RAW_FILTER, NULL, 0);
302 if (loopback_disable) {
305 setsockopt(s, SOL_CAN_RAW, CAN_RAW_LOOPBACK,
306 &loopback, sizeof(loopback));
309 if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
316 fds.events = POLLOUT;
321 if (count && (--count == 0))
324 if (id_mode == MODE_RANDOM) {
326 frame.can_id = random();
329 frame.can_id &= CAN_EFF_MASK;
330 frame.can_id |= CAN_EFF_FLAG;
332 frame.can_id &= CAN_SFF_MASK;
335 if (dlc_mode == MODE_RANDOM) {
337 frame.can_dlc = random() & 0xF;
339 if (frame.can_dlc & 8)
340 frame.can_dlc = 8; /* for about 50% of the frames */
342 if ((data_mode == MODE_INCREMENT) && !frame.can_dlc)
343 frame.can_dlc = 1; /* min dlc value for incr. data */
346 if (data_mode == MODE_RANDOM) {
348 /* that's what the 64 bit alignment of data[] is for ... :) */
349 *(unsigned long*)(&frame.data[0]) = random();
350 *(unsigned long*)(&frame.data[4]) = random();
355 printf(" %s ", argv[optind]);
358 fprint_long_canframe(stdout, &frame, "\n", (verbose > 2)?1:0);
360 fprint_canframe(stdout, &frame, "\n", 1);
364 nbytes = write(s, &frame, sizeof(struct can_frame));
366 if (errno != ENOBUFS) {
370 if (!ignore_enobufs && !polltimeout) {
375 /* wait for the write socket (with timeout) */
376 if (poll(&fds, 1, polltimeout) < 0) {
384 } else if (nbytes < sizeof(struct can_frame)) {
385 fprintf(stderr, "write: incomplete CAN frame\n");
389 if (gap) /* gap == 0 => performance test :-] */
390 if (nanosleep(&ts, NULL))
393 if (id_mode == MODE_INCREMENT) {
398 frame.can_id &= CAN_EFF_MASK;
399 frame.can_id |= CAN_EFF_FLAG;
401 frame.can_id &= CAN_SFF_MASK;
404 if (dlc_mode == MODE_INCREMENT) {
409 if ((data_mode == MODE_INCREMENT) && !frame.can_dlc)
410 frame.can_dlc = 1; /* min dlc value for incr. data */
413 if (data_mode == MODE_INCREMENT) {
418 frame.data[i] = (incdata >> i*8) & 0xFFULL;
423 printf("\nCounted %llu ENOBUFS return values on write().\n\n",