hexagram/examples/cluster.c

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>

#include <sys/time.h>

#include <hexagram/can.h>
#include <hexagram/window.h>
#include <hexagram/cluster.h>

static hexagram_cluster_state state = {
    0, 0, 0, 0
};

static void cluster_update(struct can_frame *frame) {
    switch (frame->can_id) {
        case 0x280: {
            state.rpm = 0.25 *
                (double)(frame->data[2] | (frame->data[3] << 8));

            break;
        }

        case 0x288: {
            state.temp = (double)(frame->data[1] - 48 * 0.75);

            break;
        }

        case 0x320: {
            state.fuel = (double)(frame->data[2] & 0xf) / 16.0;

            break;
        }

        case 0x5a0: {
            state.rps = 0.001 * (double)(frame->data[1]
                                      | (frame->data[2] << 8));

            break;
        }
    }
}

static int usage(int argc, char **argv, const char *message, ...) {
    if (message) {
        va_list args;

        va_start(args, message);
        vfprintf(stderr, message, args);
         fprintf(stderr, "\n");
        va_end(args);
    }

    fprintf(stderr, "usage: %s canif\n", argv[0]);

    return 1;
}

int main(int argc, char **argv) {
    Display *display;
    fd_set rfds, rready;

    hexagram_can_if *can_if;
    hexagram_window *window;
    hexagram_cluster *cluster;

    int fd, fd2,
        width  = 1024,
        height =  480;

    struct timeval last = {
        .tv_sec  = 0,
        .tv_usec = 0
    };

    cairo_t *fg, *bg;

    if (argc != 2) {
        return usage(argc, argv, "No CAN interface specified");
    }

    if ((can_if = hexagram_can_if_open(argv[1])) == NULL) {
        return 1;
    }

    if ((window = hexagram_window_new_x11(NULL, width, height)) == NULL) {
        return 1;
    }

    if ((cluster = hexagram_cluster_new(width, height)) == NULL) {
        return 1;
    }

    display = hexagram_window_display(window);

    fd  = hexagram_can_if_fd(can_if);
    fd2 = hexagram_window_display_fd(window);

    /*
     * Set up the rendering surfaces
     */
    fg = hexagram_window_create_fg_context(window);
    bg = hexagram_window_create_bg_context(window);

    /*
     * Draw the background layer
     */
    hexagram_cluster_draw_bg(cluster, bg);

    /*
     * Present the background layer
     */
    hexagram_window_show(window);

    /*
     * Set up file descriptors to monitor
     */
    FD_ZERO(&rfds);

    FD_SET(fd,  &rfds);
    FD_SET(fd2, &rfds);

    while (1) {
        int pending,
            nfds = fd2 + 1;

        while ((pending = XPending(display)) != 0) {
            XEvent e;

            XNextEvent(display, &e);

            switch (e.type) {
                case MapNotify:
                case Expose:
                    hexagram_window_refresh_bg(window);
                    hexagram_cluster_draw_fg(cluster, fg, &state);
                    hexagram_window_swap_buffer(window);

                    break;

                case ButtonPress:
                case KeyPress:
                    break;

                default:
                    break;
            }
        }

        memcpy(&rready, &rfds, sizeof(rfds));

        if (select(nfds, &rready, NULL, NULL, NULL) < 0) {
            break;
        }

        if (FD_ISSET(fd, &rready)) {
            struct can_frame frame;

            hexagram_can_if_read(can_if, &frame);

            switch (frame.can_id) {
                case 0x280:
                case 0x288:
                case 0x320:
                case 0x5a0: {
                    struct timeval now;

                    cluster_update(&frame);

                    (void)gettimeofday(&now, NULL);

                    if (now.tv_sec  - last.tv_sec
                     || now.tv_usec - last.tv_usec > 16666) {
                        hexagram_window_refresh_bg(window);
                        hexagram_cluster_draw_fg(cluster, fg, &state);
                        hexagram_window_swap_buffer(window);

                        (void)memcpy(&last, &now, sizeof(now));
                    }
                }
            }
        }
    }

    hexagram_window_destroy(window);

    return 0;
}