root/paper-tape-project/trunk/userspace-driver/puncher.c

/**
 * FACIT 4070 Tape punch-75 CPS
 * Linux parallel port userspace driver (ppdev)
 *
 * Reads bytes from stdin and transfers them to
 * the puncher.
 * Verbose output will be on stderr, standard on
 * stdout.
 *
 * CHANGELOG:
 *    Feb 2007  initially written
 *    16.11.07  kleinigkeiten geaendert.
 *    31.03.08  Endlich mal funktionsfaehig gemacht, ohne
 *              unnoetigen Debugausgaben
 * bis 06.04.08 Komplett umgeschrieben, sodass jetzt
 *              der Zyklus nachempfunden wird, weil die
 *              busy-Leitung sowieso tut, was sie will.
 *              Ordentliche Ausgaben auf stdout, Debug
 *              Flag (-d)
 *
 * Dieses Programm soll sich nur aufs Punchen beschraenken,
 * eine luxerioesere Variante (mit Beschriftung, Nullbytes
 * vorne dran) gibt es mit einem Perl-Tool.
 *
 *
 **/

#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 <sys/ioctl.h> 
#include <linux/ppdev.h>
#include <linux/parport.h>

#include <sys/time.h> //  debugging

#define PARPORT_DEVICE "/dev/parport0"

/*#ifdef DEBUG
#define DPRINTF(bla...)  fprintf(stderr,bla)
#else
#define DPRINTF(bla...)
#endif*/

#define DPRINTF(bla...) { if(debug_flag) fprintf(stderr,bla); }


unsigned char debug_flag; /* switch: Debug an/aus? */
size_t write_puncher(int fd, unsigned char buf);
void visualize_byte(unsigned char buf);
void calculate_time(int already_punched_bytes, int estimated_punch_length, int mtime_since_beginning);


int 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;
}

int main(int argc, char **argv) {
        int parport_fd;
        int mode; /* IEEE1284_MODE_COMAT == compatibility mode */
        long long time_since_beginning; // etwas lustige Zeitmessung
        int already_punched = 0; // Anzahl bereits gepunchte bytes
        int estimated_data_length = 0; // per Schalter -l angegebbare Datenlaenge
        
        printf("FACIT 4070 Tape punch-75 CPS userspace driver\n");
        printf("time ms |123.45678|  hex=dec status: =) punch successful / :-( still busy\n");
        
        // Aufrufparameter analsyieren
        debug_flag = 0;
        opterr = 0;
        int c;
        while( (c = getopt(argc, argv, "dhl:s:")) != -1)
            switch(c) {
                case 'd':
                    debug_flag = 1;
                    break;
                case 'h':
                    fprintf(stderr, "Usage: %s [-d] [-h] [-lNUM]\n"
                      "  optional parameters:\n"
                      "   -d   debug mode, print out verbose informations about signals\n"
                      "        if not set, only normal verbosity will be printed out on\n"
                      "        stdout, painting an ASCII paper tape which visualizes the\n"
                      "        bytes (see above for the caption)\n\n"
                      "   -h   display this help message\n\n"
                      "   -s   same as -l\n"
                      "   -l   sets the NUMBER OF BYTES which are expected on stdin.\n"
                      "        with this information we can complete the status information\n"
                      "        with useful informations about the estimated remaining time\n"
                      "        to punch (useful for longer data)\n"
                      "        example: cat 2k-data-file | %s -l2000\n",
                      argv[0], argv[0]);
                    return 0;
                case 'l':
                case 's':
                    c = atoi(optarg);
                    if( c > 0 ) {
                        estimated_data_length = c;
                        break;
                    }
                    printf("%s: data length must be a positive integer, like '123', not %s\n", argv[0], optarg);
                case '?': break;
            }

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

        /* Claim the port */
        //DPRINTF("claiming port...\n");
        if(ioctl(parport_fd, PPCLAIM)) {
                perror ("claiming port (PPCLAIM)");
                close (parport_fd);
                return 1;
        }        

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

        /* The main loop (reading stdin and printing out) */
        /* We will just read 1 byte at one time to handle
         * it nicely... */
        DPRINTF("Start reading from stdin...\n");
        time_since_beginning = mtime(0);
        for(;;) {
                unsigned char buf; /* stdin 1 byte buffer */
                size_t ret; /* multipurpose return value */

                ret = read(0, &buf, 1); /* 1 byte from stdin */
                if(ret < 0) {
                        perror("read stdin");
                        close(parport_fd);
                        return 1;
                }

                if(ret == 0) {/* EOF, end of input, etc. */
                        DPRINTF("stdin EOF\n");
                        break;
                }

                /* Visualisierung der Zeile */
                printf("%5ims ", (int)(mtime(time_since_beginning)/1000));
                visualize_byte(buf);
                printf(" 0x%02x=%03i ", buf, buf);
                calculate_time(++already_punched, estimated_data_length, (int)(mtime(time_since_beginning)/1000));

                /* und Ausdrucken */
                ret = write_puncher(parport_fd, buf);
                if(ret < 0) {
                        perror("write puncher");
                        close(parport_fd);
                        return 1;
                } else if(ret == 0) {
                        printf("=)\n"); // Smiley freut sich
                } else if(ret == 1) {
                        printf(":-(\n"); // Smile traurig
                }
        } /* for stdin */
    
    DPRINTF("Transmission finished\n");
    ioctl(parport_fd, PPRELEASE);
    close(parport_fd);
    return 0;
}

void visualize_byte(unsigned char buf) {
        /* Zeichnet Lochstreifen-Byte (wie das Perl-Proggi) */
        unsigned char against = 0x01;
        unsigned char check;
        int pos;
        
        printf("|");
        for(pos=0; pos < 8; pos++) {
                if(pos == 3) /* Streifenfuehrung */
                        printf(".");
                check = buf;
                check >>= pos;
                
                if((check & against) == 0)
                        printf(" "); /* bit nicht gesetzt */
                else
                        printf("*"); /* bit gesetzt */
        } /*for */
        printf("|");
}

void calculate_time(int already_punched_bytes, int estimated_punch_length, int mtime_since_beginning) {
        /* In jeder Zeile berechnen, wie lange noch gepuncht wird,
         * und ausgeben. Nur wenn Laenge per "-l" oder "-s" angegeben
         * wird. In Bytes.
         * 
         * Irgendwie ist der Berechnungsalgorithmus etwas schrottig und
         * produziert in den ersten Sekunden nur Müll, aber ansonsten
         * ist er ganz okay.
         */
        int percentage, remaining_sec = 0;
         
        if(!estimated_punch_length) return; // wenn es gar nicht abgegeben wurde
        
        //printf("%i %i ", already_punched_bytes, estimated_punch_length, mtime_since_beginning);
        
        percentage = (int)rint(((float)already_punched_bytes / (float)estimated_punch_length) * 100);
        if(mtime_since_beginning != 0) // erst nach dem ersten Zyklus berechenbar
            remaining_sec = (int)rint(((float)mtime_since_beginning / ((float)already_punched_bytes / (float)estimated_punch_length) - mtime_since_beginning)/1000);
        
        if(already_punched_bytes <= estimated_punch_length) {
               printf("| %i%% (%i sec remaining)  ", percentage, remaining_sec);
        }
}

size_t write_puncher(int fd, unsigned char buf) {
        /* Der eigentliche, Geraetespezifische Treiber
         * befindet sich erst in dieser Schreib-Funktion
         * 
         * return: <0 => Fehler; ==0 => Alles perfekt; 1 => Am Ende noch busy
         * 
         */
        //DPRINTF("\n");
        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) {
                        DPRINTF("Puncher ready to recieve (%x)\n", status);
                        x=-1;
                        break;
                }
                usleep(10);
        }*/

        /* Puncher hatte noch kein PR gesetzt. */
        //if(x<0)
          //      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(fd, PPWDATA, &buf))
                return -2;
        time = mtime(0);

        usleep(10); // take some time...
        
        /* "pulse" strobe ==> turn off strobe! (strange behaviour) */
        if(ioctl(fd, PPWCONTROL, &null_mask))
                return -3;
        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(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 *
                        DPRINTF("ERROR: Punch Ready has NOT FALLEN (%x)\n",status);
                        usleep(5*1000); // noch mal 5ms warten.
                } else break;
        }*/

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

        /* wait untill Puncher is ready to success */
        {
                int wait = 40*1000-mtime(time); // war 13*1000
                DPRINTF("\nWaiting for Puncher Ready (%i usec)...", wait);
                if(wait>0) usleep(wait);
        }
        
        if(ioctl(fd, PPRSTATUS, &status)) return -6;
        if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) {
                DPRINTF("Still busy (%x).\n", status);
                return 1;
        } else  {
                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) {
                        //DPRINTF("%x=%x ",status1,status2);
                        status = status2;

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

                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;
} /* write_puncher */