c_can_testtool.c

HMS30C7202下的CAN驱动

        if ( new_listmem->object == NULL ) {
                printf("   Error: couldn't allocate memory\n");
                return ENOMEM;
        }
        ((struct can_device_t *)new_listmem->object)->devname = dev_filename;
        ((struct can_device_t *)new_listmem->object)->filedesc = fd;
        ((struct can_device_t *)new_listmem->object)->flags = CANDEV_UNCONF;
        ((struct can_device_t *)new_listmem->object)->sub_dev_tsk = NULL;

        /* enter new member into linked list */
        ((struct object_list_t *)open_dev_head->object)->next = new_listmem;
        open_dev_head->object = (void *)new_listmem;
        new_listmem->next = open_dev_head;

        return 0;
}

/*
 * Closes one of the opened can devices.
 */
int close_candevice (struct can_device_t * can_device) {
        struct read_device_t *read_device;
        struct read_task_t *read_task;
        struct write_task_t *write_task;

        /* stop running read devices and tasks on this device */
        rem_readdevice( can_device );
        stop_tasks( can_device );

        /* now can device isn't configured anymore */
        can_device->flags |= CANDEV_UNCONF;

        /* close can device */
        printf("   Try to close %s : ", can_device->devname );
        if ( close( can_device->filedesc ) ) {
                printf("error (%s)\n", strerror(errno) );
                return -1;
        }
        printf("ok\n");

        /* free memory allocated for device name */
        free( (void *)can_device->devname );
        rm_lstmempnt( can_device, open_dev_head );

        return 0;
}

/*
 * Configures an opened can device for message reception
 */
int add_readdevice ( struct can_device_t *can_device,
                      unsigned long id,
                      char usemask,
                      unsigned long mask ) {

        struct object_list_t *new_listmem;

        /* stop running read devices and tasks on this device */
        rem_readdevice( can_device );
        stop_tasks( can_device );

        /* configure for reception */
        printf("   Try to set arbitration mask of %s to id=0x%X : ",
               can_device->devname, id);
        if ( ioctl( can_device->filedesc, IOCTL_CAN_SET_READ_MODE, id ) ) {
                printf("error (%s)\n", strerror(errno) );
                return -1;
        }
        printf("ok\n");

        if ( usemask ) {
                printf("   Try to set filter mask of %s to mask=0x%X : ",
                can_device->devname, mask);
                if ( ioctl( can_device->filedesc, IOCTL_CAN_SET_FILTER, mask ) ) {
                        printf("error (%s)\n", strerror(errno) );
                        return -1;
                }
        } else {
                printf("   Try to disable filter mask of %s : ",
                can_device->devname, mask);
                if ( ioctl( can_device->filedesc, IOCTL_CAN_DISABLE_FILTER ) ) {
                        printf("error\n");
                        return -1;
                }
        }
        printf("ok\n");

        /* add read_device to list */
        new_listmem = (struct object_list_t *) malloc(sizeof (struct object_list_t));
        if ( new_listmem == NULL ) {
                printf("   Error: couldn't allocate memory\n");
                return ENOMEM;
        }
        new_listmem->object = (void *) malloc( sizeof (struct read_device_t));
        if ( new_listmem->object == NULL ) {
                printf("   Error: couldn't allocate memory\n");
                return ENOMEM;
        }
        ((struct read_device_t *)new_listmem->object)->can_device = can_device;
        ((struct read_device_t *)new_listmem->object)->id = id;
        ((struct read_device_t *)new_listmem->object)->usemask = usemask;
        ((struct read_device_t *)new_listmem->object)->mask = mask;
        ((struct read_device_t *)new_listmem->object)->read_task = NULL;

        /* enter new member into linked list */
        ((struct object_list_t *)read_dev_head->object)->next = new_listmem;
        read_dev_head->object = (void *)new_listmem;
        new_listmem->next = read_dev_head;

        can_device->flags = CANDEV_READDEV;

        return 0;
}

/*
 * Stops tasks running on given device
 */
int rem_readdevice ( struct can_device_t *can_device ) {
        struct read_device_t *read_device;

        /* stop read device */
        if ( can_device->flags & CANDEV_READDEV ) {
               /* get read device */
               read_device = (struct read_device_t *)can_device->sub_dev_tsk;

               stop_tasks ( can_device );

               if ( read_device == NULL ) {
                       /* no read device registered -> search */
               } else {
                       /* remove read device from list */
                       rm_lstmempnt( read_device, read_dev_head );
                       can_device->sub_dev_tsk = NULL;
                       can_device->flags &= ~CANDEV_READDEV;
               }
        }

        if ( ! (can_device->flags & (CANDEV_READDEV | CANDEV_READTSK | CANDEV_WRITTSK)) ) {
                can_device->flags = CANDEV_UNCONF;
        }

        return 0;
}

/*
 * Logs the contents of given can message buffer to given output stream and begins
 * each ouput line with the given string.
 */
int log_messages ( struct canmsg_t *canmsgs,
                   int msgcnt,
                   FILE *stream,
                   char *begofline ) {

        int count = 0;
        struct tm *msgtime;

        if (canmsgs == NULL ) {
                printf("   ERROR: POINTER TO MESSAGE BUFFER IS NULL\n");
                return -1;
        }
        if ( stream == NULL ) {
                printf("   UNKNOWN OUTPUT STREAM, PRINTING TO STDOUT\n");
                stream = stdout;
        }
        if ( msgcnt == 0 ) {
                fprintf(stream,"%sMessage buffer is empty\n", begofline);
                return 0;
        }
        fprintf(stream,"%s|id   |l|data (hex)              |timestamp                      |\n", begofline);
        while (++count < msgcnt) {
                msgtime = localtime ( &((time_t)canmsgs->timestamp_sec));
                fprintf(stream,
                        "%s|0x%-3X|%1d|%02X %02X %02X %02X %02X %02X %02X %02X |%02d.%02d.%04d %02d:%02d:%02d %03ldms %03ldus|\n",
                        begofline,
                        canmsgs->id, canmsgs->length, canmsgs->data[0], canmsgs->data[1], canmsgs->data[2],
                        canmsgs->data[3], canmsgs->data[4], canmsgs->data[5], canmsgs->data[6], canmsgs->data[7],
                        msgtime->tm_mday, msgtime->tm_mon + 1, msgtime->tm_year + 1900, msgtime->tm_hour,
                        msgtime->tm_min, msgtime->tm_sec,
                        canmsgs->timestamp_usec / 1000, canmsgs->timestamp_usec % 1000
                       );
                fflush( stdout );
                canmsgs ++;
        }
        return count;
}

/*
 * Sends one or more messages through given device.
 */
int send_messages ( struct can_device_t * can_device ){
        struct canmsg_t canmsg = {0, 0, 0, 0, 0, {0, 0, 0, 0 ,0 ,0 ,0 ,0}};
        int i, length=0, msgnr=0, delay=0, data=0;
        struct timespec delaytime, remaintime;

        printf("   ID (hex) : "); fflush( NULL);
        scanf("%lx", &canmsg.id);
        while (getchar() != '\n') ; /* flush input buffer */
        printf("   Length : "); fflush( NULL);
        scanf("%d", &length);
        if (length < 0) length = 0;
        if (length > 8) length = 8;
        canmsg.length = length;
        for (i = 0; i < canmsg.length; i++) {
                printf("   Data %d (hex) : ", i); fflush( NULL);
                scanf("%2X", &data );
                canmsg.data[i] = data;
                while (getchar() != '\n') ; /* flush input buffer */
        }
        printf("   How often should the message be sent : "); fflush( NULL);
        scanf("%d", &msgnr);
        while (getchar() != '\n') ; /* flush input buffer */
        if (msgnr < 0) msgnr = 0;
        printf("   How big (in ms) will be the delay between two messages : "); fflush( NULL);
        scanf("%d", &delay);
        if ( delay > 4 && delay < 15 ) {
                delay = 3;
        } else if ( delay < 5) {
                delay = 0;
        } else {
                delay -= 10;
        }
        delaytime.tv_sec = delay / 1000;
        delaytime.tv_nsec = ((long int)(delay % 1000)) * 1000000;
        while (getchar() != '\n') ; /* flush input buffer */

        printf("   Sending message(s) : %-6d", msgnr); fflush(stdout);
        while ( msgnr--) {
                if ( write( can_device->filedesc, &canmsg,
                        sizeof( struct canmsg_t ) ) < 0 ) {
                        printf("\n    error (%s)\n", strerror(errno) );
                        return -1;
                }
                printf("\b\b\b\b\b\b%-6d", msgnr); fflush(stdout);
                if (delay > 0) {
                        nanosleep( &delaytime, &remaintime );
                }
        }
        printf("\n   ok\n");
        return 0;
}

/*
 * Stops tasks running on given device
 */
int stop_tasks ( struct can_device_t *can_device ) {
        struct read_device_t *read_device;
        struct read_task_t *read_task;
        struct write_task_t *write_task;

        /* stop read task */
        if ( can_device->flags & CANDEV_READDEV ) {
               /* get read device */
               read_device = (struct read_device_t *)can_device->sub_dev_tsk;

               if ( read_device == NULL ) {
                       /* no read device registered -> search */
               } else {
                       /* stop running read task */
                       if ( can_device->flags & CANDEV_READTSK ) {
                               /* get read task */
                               read_task = read_device->read_task;
                               if ( read_task == NULL ) {
                                       /* no read task registered */
                               } else {
                                       /* stop task */

                                       /* free memory allocated for canmsg buffer */
                                       free( (void *)read_task->canmsg_buff );
                                       /* remove read task from list */
                                       rm_lstmempnt( read_task, read_tsk_head );
                                       read_device->read_task = NULL;
                                       can_device->flags &= ~CANDEV_READTSK;
                               }
                       }
               }
        }

        /* stop running write task */
        if ( can_device->flags & CANDEV_WRITTSK ) {
               /* get write task */
               write_task = (struct write_task_t *)can_device->sub_dev_tsk;
               if ( write_task == NULL ) {
                       /* no write task registered */
               } else {
                       /* stop task */

                       /* free memory allocated for canmsg structure */
                       free( (void *)write_task->canmsg );
                       /* remove read task from list */
                       rm_lstmempnt( write_task, writ_tsk_head );
                       can_device->sub_dev_tsk = NULL;
                       can_device->flags &= ~CANDEV_WRITTSK;
               }
        }

        if ( ! (can_device->flags & (CANDEV_READDEV | CANDEV_READTSK | CANDEV_WRITTSK)) ) {
                can_device->flags = CANDEV_UNCONF;
        }

        return 0;
}

/*
 * Lets user select one of the opened can devices
 */
struct can_device_t * select_candev ( void ) {
        int nr, cnt;
        struct object_list_t *tmp_listmem;