root/paper-tape-project/trunk/reader/reader.c

/**
 * GHIELMETTI FER 201 paper tape reader
 * Linux parallel port userspace driver (ppdev)
 *
 * Reads bytes from the reader and prints them to
 * STDOUT. Verbose output will be on stderr.
 *
 * CHANGELOG:
 *    12.04.08  initially written
 *
 * The sourcecode of this program was branched from
 * the FACIT userspace driver.
 *
 * Copyright (C) 2008 Sven Köppel
 *
 * This program is free software; you can redistribute
 * it and/or modify it under the terms of the GNU General
 * Public License as published by the Free Software
 * Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will
 * be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General
 * Public License along with this program; if not, see
 * <http://www.gnu.org/licenses/>.
 *
 **/

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

#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);


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^3
        return (time.tv_sec * 1000 + (long long)(time.tv_usec / 1000)) - since;
}

int u_time(long long since) {
        /* gibt Mikrosekunden zurueck seit since. since sind dabei die
           Mikrosekunden 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 * 1000 * 1000 + 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 x; // debug
        
        fprintf(stderr, "FER 201 Paper tape reader user space driver\n");
        fprintf(stderr, "time ms |123.45678|  hex=dec\n");
        
        // Aufrufparameter analsyieren
        debug_flag = 0;
        opterr = 0;
        int c;
        while( (c = getopt(argc, argv, "dh")) != -1)
            switch(c) {
                case 'd':
                    debug_flag = 1;
                    break;
                case 'h':
                    fprintf(stderr, "Usage: program [-d] [-h]\n");
                    return 0;
                //default:
            }

        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;
        }
        
        /*DPRINTF("Setting IEEE protocol..\n");
        mode = IEEE1284_MODE_COMPAT;
        if(ioctl(parport_fd, PPSETMODE, &mode)) {
                perror("Setting PPSETMODE");
                close(parport_fd);
                return 1;
        }*/

        /* Go straight into compatibility mode: */
        DPRINTF("Setting IEEE netogation...\n");
        mode = IEEE1284_MODE_COMPAT; //BYTE; //COMPAT;
        if(ioctl(parport_fd, PPNEGOT, &mode)) {
                perror ("Setting compatibilty mode (PPNEGOT)");
                close (parport_fd);
                return 1;
        }
        
        DPRINTF("Setting off data line drivers..\n");
        mode = 1;
        if(ioctl(parport_fd, PPDATADIR, &mode)) {
                perror("Setting PPDATADIR");
                close(parport_fd);
                return 1;
        }
        
        DPRINTF("Resetting reader...\n");
        {
                unsigned char mask = (PARPORT_CONTROL_STROBE|PARPORT_CONTROL_AUTOFD);
                if(ioctl(parport_fd, PPWCONTROL, &mask))
                        return -3;
                usleep(20);
        }
        
        /*
        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);
                }
        }
        */

        time_since_beginning = mtime(0);
        for(x=0;;x++) {
                unsigned char buf; /* the read-in-byte buffer */
                int ret; /* multipurpose return value */

                ret = read_byte(parport_fd, &buf);
                if(ret < 0) {
                        printf("read byte: %i!", ret);
                        //perror("read byte");
                        close(parport_fd);
                        return 1;
                }
                
                /* Visualisierung der Zeile */
                fprintf(stderr, "%5ims ", (int)(mtime(time_since_beginning)));
                visualize_byte(buf);
                fprintf(stderr, " 0x%02x=%03i\n", buf, buf);
                
                // ausgeben auf STDOUT.
                putchar((int)buf);
                fflush(stdout); // kein buffern.
                
                usleep(10*1000);
        }

    DPRINTF("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;
        
        fprintf(stderr, "|");
        for(pos=0; pos < 8; pos++) {
                if(pos == 3) /* Streifenfuehrung */
                        fprintf(stderr, ".");
                check = buf;
                check >>= pos;
                
                if((check & against) == 0)
                        fprintf(stderr, " "); /* bit nicht gesetzt */
                else
                        fprintf(stderr, "*"); /* bit gesetzt */
        } /*for */
        fprintf(stderr, "|");
}

int read_byte(int fd, unsigned char *byte) {
        /**
         * Der eigentliche, geraetespezifische Treiber befindet
         * sich auch erst hier.
         *
         */
        static unsigned char mask_strobe = (PARPORT_CONTROL_STROBE|PARPORT_CONTROL_INIT);
        static unsigned char mask_null = (0x00);
        unsigned char status;
        long long time;
        int x; // temporaer
        
        // erst mal warten, bis Schalter geschlossen ist.
        if(ioctl(fd, PPRSTATUS, &status))
                return -5;
        if(!(status & PARPORT_STATUS_SELECT)) {
                DPRINTF("Warte, bis Schalter geschlossen ist");
                while(!(status & PARPORT_STATUS_SELECT)) {
                        if(ioctl(fd, PPRSTATUS, &status))
                                return -5;
                        DPRINTF(".");
                        sleep(1);
                }
        }

        //DPRINTF("Strobe pulsed.\n");
        if(ioctl(fd, PPWCONTROL, &mask_strobe))
                return -3;
        time = u_time(0);

        // in den ersten 2ms passiert selten etwas
        for(x=0;;) {
                //DPRINTF("%5i. Signale: ", (int)(u_time(time)));
                if(ioctl(fd, PPRSTATUS, &status))
                        return -4;
                if(!(status & PARPORT_STATUS_ACK)) {
                        //DPRINTF("Lesesignal ");
                        if(!x) {
                                if(u_time(time) > 4*1000) {
                                        DPRINTF("Lesesignal erst nach 4ms!\n");
                                }
                                ioctl(fd, PPRDATA, byte);
                                ioctl(fd, PPWCONTROL, &mask_null);
                                x++;
                        }
                } else if(u_time(time) > 9*1000) {
                        DPRINTF("Lesesignal kommt nicht!\n");
                        usleep(2);
                }
                
                if(!(status & PARPORT_STATUS_BUSY)) {
                        //DPRINTF("Busy "); 
                        if(u_time(time) > 10*1000) {
                                break; // alles klar.
                        }
                } else if(u_time(time) > 90*1000) {
                        DPRINTF("Busy missing nach 9ms!\n");
                        DPRINTF("BEende.\n");
                        exit(0);
                }
                
                if(!(status & PARPORT_STATUS_SELECT))
                        DPRINTF("Schalter offen! ");
                //DPRINTF("\n");

                if(0==1) {
                        struct timespec a;
                        a.tv_sec = 0;
                        a.tv_nsec = 1000;
                        nanosleep(&a, NULL);
                }
        }

        // auf ACK = RS Lesesignal warten um Daten
        // abzuholen.

        /*
        for(;;) {
                ioctl(fd, PPRSTATUS, &status);
                if((status & PARPORT_STATUS_ACK) == PARPORT_STATUS_ACK) {
                        if(mtime(time) > 4) {
                                DPRINTF("Waiting over 4ms for ACK!\n");
                                sleep(2);
                        } else {
                                usleep(10);
                        }
                } else break;
        }*/

        // warten bis Busy verschwindet.
        /*
        for(;;) {
                ioctl(fd, PPRSTATUS, &status);
                if(status & PARPORT_STATUS_BUSY) {
                        if(mtime(time) > 5) {
                                DPRINTF("Still busy =(\n");
                                break;
                        } else
                                usleep(10);
                } else break;
        }*/

        return 0;
}