root/paper-tape-project/trunk/puncher/backend.linux.c

/**
 * The Paper Tape Project -- Punching subsystem
 * Linux backend implementation
 *
 * FACIT 4070 Tape punch-75 CPS
 * Linux parallel port userspace driver (ppdev)
 *
 * This driver assumes the Linux kernel module "ppdev"
 * being loaded and PARPORT_DEVICE (see symbol below)
 * being writable for the current UID.
 *
 * (c) 2008 Sven Köppel
 *
 **/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h> /* lowlevel io */
#include <errno.h>
#include <stdarg.h> /* var argument list */
#include <math.h>

#include "backend.h"
#define PARPORT_DEVICE "/dev/parport0"


/* Linux specific header files */
#include <sys/ioctl.h> 
#include <linux/ppdev.h>
#include <linux/parport.h>
#include <sys/time.h> /*  debugging */

int puncher_backend_mtime(long long since) {
        /* gibt millisekunden zurueck seit since. since sind dabei die
           Millisekunden seit der Unix-Epoche. Ein initiales since kann
           per mtime(0) gefunden werden. */
        struct timeval time;
        gettimeofday(&time, NULL);
              // Sec*10^6
        return (time.tv_sec * 1000000 + time.tv_usec) - since;
}

PuncherBackend* puncher_backend_new(int debug_flag) {
        int mode; /* IEEE1284_MODE_COMAT == compatibility mode */
        PuncherBackend* c = malloc(sizeof(PuncherBackend));
        c->debug_flag = debug_flag;

        printf("FACIT 4070 Tape punch-75 CPS userspace driver\n");
        printf("Starting up...\n");

        //PUNCHER_BACKEND_DPRINTF("opening device...\n");
        c->parport_fd = open(PARPORT_DEVICE, O_RDWR);
        if(c->parport_fd == -1) {
                perror("opening device failed");
                return NULL;
        }

        /* Claim the port */
        //PUNCHER_BACKEND_DPRINTF("claiming port...\n");
        if(ioctl(c->parport_fd, PPCLAIM)) {
                perror ("claiming port (PPCLAIM)");
                close (c->parport_fd);
                return NULL;
        }

        /* Go straight into compatibility mode: */
        //PUNCHER_BACKEND_DPRINTF("Setting compatibility mode...\n");
        mode = IEEE1284_MODE_COMPAT;
        if(ioctl(c->parport_fd, PPNEGOT, &mode)) {
                perror ("Setting compatibilty mode (PPNEGOT)");
                close (c->parport_fd);
                return NULL;
        }
        
        PUNCHER_BACKEND_DPRINTF("Waiting for Puncher beeing ready for signals...\n");
        {
                unsigned char status;
                if(ioctl(c->parport_fd, PPRSTATUS, &status)) return NULL;
                if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) {
                        PUNCHER_BACKEND_DPRINTF("Puncher is BUSY!\n");
                        usleep(8000);
                }
        }

        PUNCHER_BACKEND_DPRINTF("Puncher ready.\n");
        return c;
}

int puncher_backend_emergency_stop(PuncherBackend* c) {
        /**
         * This method implements the setoff-strobe mechanism.
         * It should be called whenever you want the puncher simply to
         * *stop*.
         **/
        static unsigned char mask = PARPORT_CONTROL_STROBE;
        PUNCHER_BACKEND_DPRINTF("Setting null mask to control pins (strobe,etc.)...\n");
        if(ioctl(c->parport_fd, PPWCONTROL, &mask)) {
                perror("backend emergency exit: null mask");
                close(c->parport_fd);
                return 1;
        }
        return 0;
}

int puncher_backend_destroy(PuncherBackend* c) {
        puncher_backend_emergency_stop(c); // stop it.
        if(ioctl(c->parport_fd, PPRELEASE)) {
                perror ("Releasing the parport");
                return 1;
        }
        close(c->parport_fd);
        PUNCHER_BACKEND_DPRINTF("Goodbye from the parport.\n");
        return 0;
}



int puncher_backend_write_byte(PuncherBackend* c, unsigned char buf) {
        /**
         * This will write one byte on the puncher. Return
         * values:
         * r  < 0  => Failure Error (see errno)
         * r == 0  => Perfect write, no error
         * r == 1  => After writing still "busy" signal (continue, anywhere)
         **/
        static unsigned char strobe_on = (PARPORT_CONTROL_STROBE);
        static unsigned char null_mask = 0x00;
        unsigned char status;
        long long time;

        /* (falls nötig) warten bis PR (Punch ready == busy) kommt */
        /*for(;;) *///{
        /*int x;
        for(x=0;x<5;x++) {
                if(ioctl(fd, PPRSTATUS, &status))
                        return -1;

                if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) {
                        PUNCHER_BACKEND_DPRINTF("Puncher ready to recieve (%x)\n", status);
                        x=-1;
                        break;
                }
                usleep(10);
        }*/

        /* Puncher hatte noch kein PR gesetzt. */
        //if(x<0)
          //      PUNCHER_BACKEND_DPRINTF("Waited for Puncher ready (status=%x)... ", status);
                
                //usleep(8000);
                /* 1/2 Sekunde ist fuer debugzwecke besser als die vorherigen 8000. */
        //}

        /* set data pins */
        if(ioctl(c->parport_fd, PPWDATA, &buf))
                return -2;

    time = puncher_backend_mtime(0);

        usleep(10); // take some time...
        
        /* "pulse" strobe ==> turn off strobe! (strange behaviour) */
        if(ioctl(c->parport_fd, PPWCONTROL, &null_mask))
                return -3;
        PUNCHER_BACKEND_DPRINTF("data set; strobe pulsed...\n");

        /* Puncher: PI (=strobe) minimum == 100us */
        usleep(220); // DTL TRY
        // was: 220 => wir gehen jetzt auf 2ms

        /* check if Punch Ready has fallen */
        if(ioctl(c->parport_fd, PPRSTATUS, &status))
            return -4;
        // bringts ja eh nicht -- also lassen.

        /*for(;;) {
                if(ioctl(fd, PPRSTATUS, &status))
                        return -4;
                if((status & PARPORT_STATUS_BUSY) != PARPORT_STATUS_BUSY) {
                        * it has not - quite bad, but we will continue *
                        PUNCHER_BACKEND_DPRINTF("ERROR: Punch Ready has NOT FALLEN (%x)\n",status);
                        usleep(5*1000); // noch mal 5ms warten.
                } else break;
        }*/

        /* end strobe + data pins */
        PUNCHER_BACKEND_DPRINTF("Control is %x. Ending data pins... ",status);
        if(ioctl(c->parport_fd, PPWDATA, &null_mask)) return -5;
        PUNCHER_BACKEND_DPRINTF("+ strobe... ");
        if(ioctl(c->parport_fd, PPWCONTROL, &strobe_on)) return -5;

        /* wait untill Puncher is ready to success */
        {
                int wait = 40*1000-puncher_backend_mtime(time); // war 13*1000
                PUNCHER_BACKEND_DPRINTF("\nWaiting for Puncher Ready (%i usec)...", wait);
                if(wait>0) usleep(wait);
        }
        
        if(ioctl(c->parport_fd, PPRSTATUS, &status)) return -6;
        if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) {
                PUNCHER_BACKEND_DPRINTF("Still busy (%x).\n", status);
                return 1;
        } else  {
                PUNCHER_BACKEND_DPRINTF("Finished successfully (%x)\n", status);
                return 0;
        }
        
        
        //for(;;) {
        /*
                int x;
                unsigned char status1,status2;
                for(x=0;x<(100);x++) {
                if(ioctl(fd, PPRSTATUS, &status1)) return -6;
                usleep(15);
                if(ioctl(fd, PPRSTATUS, &status2)) return -6;
                if(status1 == status2) {
                        //PUNCHER_BACKEND_DPRINTF("%x=%x ",status1,status2);
                        status = status2;

                        if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) {
                                PUNCHER_BACKEND_DPRINTF("- Puncher finished successfully (%x)\n",status);
                                return 0;
                        }
                }
                usleep(10);
                }//for

                PUNCHER_BACKEND_DPRINTF("Cycle passed. Still busy (%x/%x). Going on.\n",status1,status2);
                
                //usleep(10000); // 20ms was
                 * Der Komplettintervall betraegt 13.33 Microsekunden -
                 * 10ms ist vielleicht angemessen
                 * */
        //}
        //return 0;
} /* puncher_backend_write_byte */

/* EOF. */