[1] | 1 | /** |
---|
| 2 | * FACIT 4070 Tape punch-75 CPS |
---|
| 3 | * Linux parallel port userspace driver (ppdev) |
---|
| 4 | * |
---|
| 5 | * Reads bytes from stdin and transfers them to |
---|
| 6 | * the puncher. |
---|
| 7 | * Verbose output will be on stderr, standard on |
---|
| 8 | * stdout. |
---|
| 9 | * |
---|
| 10 | * CHANGELOG: |
---|
| 11 | * Feb 2007 initially written |
---|
| 12 | * 16.11.07 kleinigkeiten geaendert. |
---|
| 13 | * 31.03.08 Endlich mal funktionsfaehig gemacht, ohne |
---|
| 14 | * unnoetigen Debugausgaben |
---|
| 15 | * bis 06.04.08 Komplett umgeschrieben, sodass jetzt |
---|
| 16 | * der Zyklus nachempfunden wird, weil die |
---|
| 17 | * busy-Leitung sowieso tut, was sie will. |
---|
| 18 | * Ordentliche Ausgaben auf stdout, Debug |
---|
| 19 | * Flag (-d) |
---|
| 20 | * |
---|
| 21 | * Dieses Programm soll sich nur aufs Punchen beschraenken, |
---|
| 22 | * eine luxerioesere Variante (mit Beschriftung, Nullbytes |
---|
| 23 | * vorne dran) gibt es mit einem Perl-Tool. |
---|
| 24 | * |
---|
| 25 | * |
---|
| 26 | **/ |
---|
| 27 | |
---|
| 28 | #include <stdio.h> |
---|
| 29 | #include <stdlib.h> |
---|
| 30 | #include <unistd.h> |
---|
| 31 | #include <fcntl.h> /* lowlevel io */ |
---|
| 32 | #include <errno.h> |
---|
| 33 | #include <stdarg.h> /* var argument list */ |
---|
| 34 | #include <math.h> |
---|
| 35 | |
---|
| 36 | #include <sys/ioctl.h> |
---|
| 37 | #include <linux/ppdev.h> |
---|
| 38 | #include <linux/parport.h> |
---|
| 39 | |
---|
| 40 | #include <sys/time.h> // debugging |
---|
| 41 | |
---|
| 42 | #define PARPORT_DEVICE "/dev/parport0" |
---|
| 43 | |
---|
| 44 | /*#ifdef DEBUG |
---|
| 45 | #define DPRINTF(bla...) fprintf(stderr,bla) |
---|
| 46 | #else |
---|
| 47 | #define DPRINTF(bla...) |
---|
| 48 | #endif*/ |
---|
| 49 | |
---|
| 50 | #define DPRINTF(bla...) { if(debug_flag) fprintf(stderr,bla); } |
---|
| 51 | |
---|
| 52 | |
---|
| 53 | unsigned char debug_flag; /* switch: Debug an/aus? */ |
---|
| 54 | size_t write_puncher(int fd, unsigned char buf); |
---|
| 55 | void visualize_byte(unsigned char buf); |
---|
| 56 | void calculate_time(int already_punched_bytes, int estimated_punch_length, int mtime_since_beginning); |
---|
| 57 | |
---|
| 58 | |
---|
| 59 | int mtime(long long since) { |
---|
| 60 | /* gibt millisekunden zurueck seit since. since sind dabei die |
---|
| 61 | Millisekunden seit der Unix-Epoche. Ein initiales since kann |
---|
| 62 | per mtime(0) gefunden werden. */ |
---|
| 63 | struct timeval time; |
---|
| 64 | gettimeofday(&time, NULL); |
---|
| 65 | // Sec*10^6 |
---|
| 66 | return (time.tv_sec * 1000000 + time.tv_usec) - since; |
---|
| 67 | } |
---|
| 68 | |
---|
| 69 | int main(int argc, char **argv) { |
---|
| 70 | int parport_fd; |
---|
| 71 | int mode; /* IEEE1284_MODE_COMAT == compatibility mode */ |
---|
| 72 | long long time_since_beginning; // etwas lustige Zeitmessung |
---|
| 73 | int already_punched = 0; // Anzahl bereits gepunchte bytes |
---|
| 74 | int estimated_data_length = 0; // per Schalter -l angegebbare Datenlaenge |
---|
| 75 | |
---|
| 76 | printf("FACIT 4070 Tape punch-75 CPS userspace driver\n"); |
---|
| 77 | printf("time ms |123.45678| hex=dec status: =) punch successful / :-( still busy\n"); |
---|
| 78 | |
---|
| 79 | // Aufrufparameter analsyieren |
---|
| 80 | debug_flag = 0; |
---|
| 81 | opterr = 0; |
---|
| 82 | int c; |
---|
| 83 | while( (c = getopt(argc, argv, "dhl:s:")) != -1) |
---|
| 84 | switch(c) { |
---|
| 85 | case 'd': |
---|
| 86 | debug_flag = 1; |
---|
| 87 | break; |
---|
| 88 | case 'h': |
---|
| 89 | fprintf(stderr, "Usage: %s [-d] [-h] [-lNUM]\n" |
---|
| 90 | " optional parameters:\n" |
---|
| 91 | " -d debug mode, print out verbose informations about signals\n" |
---|
| 92 | " if not set, only normal verbosity will be printed out on\n" |
---|
| 93 | " stdout, painting an ASCII paper tape which visualizes the\n" |
---|
| 94 | " bytes (see above for the caption)\n\n" |
---|
| 95 | " -h display this help message\n\n" |
---|
| 96 | " -s same as -l\n" |
---|
| 97 | " -l sets the NUMBER OF BYTES which are expected on stdin.\n" |
---|
| 98 | " with this information we can complete the status information\n" |
---|
| 99 | " with useful informations about the estimated remaining time\n" |
---|
| 100 | " to punch (useful for longer data)\n" |
---|
| 101 | " example: cat 2k-data-file | %s -l2000\n", |
---|
| 102 | argv[0], argv[0]); |
---|
| 103 | return 0; |
---|
| 104 | case 'l': |
---|
| 105 | case 's': |
---|
| 106 | c = atoi(optarg); |
---|
| 107 | if( c > 0 ) { |
---|
| 108 | estimated_data_length = c; |
---|
| 109 | break; |
---|
| 110 | } |
---|
| 111 | printf("%s: data length must be a positive integer, like '123', not %s\n", argv[0], optarg); |
---|
| 112 | case '?': break; |
---|
| 113 | } |
---|
| 114 | |
---|
| 115 | //DPRINTF("opening device...\n"); |
---|
| 116 | parport_fd = open(PARPORT_DEVICE, O_RDWR); |
---|
| 117 | if(parport_fd == -1) { |
---|
| 118 | perror("opening device failed"); |
---|
| 119 | return 1; |
---|
| 120 | } |
---|
| 121 | |
---|
| 122 | /* Claim the port */ |
---|
| 123 | //DPRINTF("claiming port...\n"); |
---|
| 124 | if(ioctl(parport_fd, PPCLAIM)) { |
---|
| 125 | perror ("claiming port (PPCLAIM)"); |
---|
| 126 | close (parport_fd); |
---|
| 127 | return 1; |
---|
| 128 | } |
---|
| 129 | |
---|
| 130 | /* Go straight into compatibility mode: */ |
---|
| 131 | //DPRINTF("Setting compatibility mode...\n"); |
---|
| 132 | mode = IEEE1284_MODE_COMPAT; |
---|
| 133 | if(ioctl(parport_fd, PPNEGOT, &mode)) { |
---|
| 134 | perror ("Setting compatibilty mode (PPNEGOT)"); |
---|
| 135 | close (parport_fd); |
---|
| 136 | return 1; |
---|
| 137 | } |
---|
| 138 | |
---|
| 139 | DPRINTF("Waiting for Puncher beeing ready for signals...\n"); |
---|
| 140 | { |
---|
| 141 | unsigned char status; |
---|
| 142 | if(ioctl(parport_fd, PPRSTATUS, &status)) return -1; |
---|
| 143 | if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) { |
---|
| 144 | DPRINTF("Puncher is BUSY!\n"); |
---|
| 145 | usleep(8000); |
---|
| 146 | } |
---|
| 147 | } |
---|
| 148 | |
---|
| 149 | /* The main loop (reading stdin and printing out) */ |
---|
| 150 | /* We will just read 1 byte at one time to handle |
---|
| 151 | * it nicely... */ |
---|
| 152 | DPRINTF("Start reading from stdin...\n"); |
---|
| 153 | time_since_beginning = mtime(0); |
---|
| 154 | for(;;) { |
---|
| 155 | unsigned char buf; /* stdin 1 byte buffer */ |
---|
| 156 | size_t ret; /* multipurpose return value */ |
---|
| 157 | |
---|
| 158 | ret = read(0, &buf, 1); /* 1 byte from stdin */ |
---|
| 159 | if(ret < 0) { |
---|
| 160 | perror("read stdin"); |
---|
| 161 | close(parport_fd); |
---|
| 162 | return 1; |
---|
| 163 | } |
---|
| 164 | |
---|
| 165 | if(ret == 0) {/* EOF, end of input, etc. */ |
---|
| 166 | DPRINTF("stdin EOF\n"); |
---|
| 167 | break; |
---|
| 168 | } |
---|
| 169 | |
---|
| 170 | /* Visualisierung der Zeile */ |
---|
| 171 | printf("%5ims ", (int)(mtime(time_since_beginning)/1000)); |
---|
| 172 | visualize_byte(buf); |
---|
| 173 | printf(" 0x%02x=%03i ", buf, buf); |
---|
| 174 | calculate_time(++already_punched, estimated_data_length, (int)(mtime(time_since_beginning)/1000)); |
---|
| 175 | |
---|
| 176 | /* und Ausdrucken */ |
---|
| 177 | ret = write_puncher(parport_fd, buf); |
---|
| 178 | if(ret < 0) { |
---|
| 179 | perror("write puncher"); |
---|
| 180 | close(parport_fd); |
---|
| 181 | return 1; |
---|
| 182 | } else if(ret == 0) { |
---|
| 183 | printf("=)\n"); // Smiley freut sich |
---|
| 184 | } else if(ret == 1) { |
---|
| 185 | printf(":-(\n"); // Smile traurig |
---|
| 186 | } |
---|
| 187 | } /* for stdin */ |
---|
| 188 | |
---|
| 189 | DPRINTF("Transmission finished\n"); |
---|
| 190 | ioctl(parport_fd, PPRELEASE); |
---|
| 191 | close(parport_fd); |
---|
| 192 | return 0; |
---|
| 193 | } |
---|
| 194 | |
---|
| 195 | void visualize_byte(unsigned char buf) { |
---|
| 196 | /* Zeichnet Lochstreifen-Byte (wie das Perl-Proggi) */ |
---|
| 197 | unsigned char against = 0x01; |
---|
| 198 | unsigned char check; |
---|
| 199 | int pos; |
---|
| 200 | |
---|
| 201 | printf("|"); |
---|
| 202 | for(pos=0; pos < 8; pos++) { |
---|
| 203 | if(pos == 3) /* Streifenfuehrung */ |
---|
| 204 | printf("."); |
---|
| 205 | check = buf; |
---|
| 206 | check >>= pos; |
---|
| 207 | |
---|
| 208 | if((check & against) == 0) |
---|
| 209 | printf(" "); /* bit nicht gesetzt */ |
---|
| 210 | else |
---|
| 211 | printf("*"); /* bit gesetzt */ |
---|
| 212 | } /*for */ |
---|
| 213 | printf("|"); |
---|
| 214 | } |
---|
| 215 | |
---|
| 216 | void calculate_time(int already_punched_bytes, int estimated_punch_length, int mtime_since_beginning) { |
---|
| 217 | /* In jeder Zeile berechnen, wie lange noch gepuncht wird, |
---|
| 218 | * und ausgeben. Nur wenn Laenge per "-l" oder "-s" angegeben |
---|
| 219 | * wird. In Bytes. |
---|
| 220 | * |
---|
| 221 | * Irgendwie ist der Berechnungsalgorithmus etwas schrottig und |
---|
| 222 | * produziert in den ersten Sekunden nur Müll, aber ansonsten |
---|
| 223 | * ist er ganz okay. |
---|
| 224 | */ |
---|
| 225 | int percentage, remaining_sec = 0; |
---|
| 226 | |
---|
| 227 | if(!estimated_punch_length) return; // wenn es gar nicht abgegeben wurde |
---|
| 228 | |
---|
| 229 | //printf("%i %i ", already_punched_bytes, estimated_punch_length, mtime_since_beginning); |
---|
| 230 | |
---|
| 231 | percentage = (int)rint(((float)already_punched_bytes / (float)estimated_punch_length) * 100); |
---|
| 232 | if(mtime_since_beginning != 0) // erst nach dem ersten Zyklus berechenbar |
---|
| 233 | remaining_sec = (int)rint(((float)mtime_since_beginning / ((float)already_punched_bytes / (float)estimated_punch_length) - mtime_since_beginning)/1000); |
---|
| 234 | |
---|
| 235 | if(already_punched_bytes <= estimated_punch_length) { |
---|
| 236 | printf("| %i%% (%i sec remaining) ", percentage, remaining_sec); |
---|
| 237 | } |
---|
| 238 | } |
---|
| 239 | |
---|
| 240 | size_t write_puncher(int fd, unsigned char buf) { |
---|
| 241 | /* Der eigentliche, Geraetespezifische Treiber |
---|
| 242 | * befindet sich erst in dieser Schreib-Funktion |
---|
| 243 | * |
---|
| 244 | * return: <0 => Fehler; ==0 => Alles perfekt; 1 => Am Ende noch busy |
---|
| 245 | * |
---|
| 246 | */ |
---|
| 247 | //DPRINTF("\n"); |
---|
| 248 | static unsigned char strobe_on = (PARPORT_CONTROL_STROBE); |
---|
| 249 | static unsigned char null_mask = 0x00; |
---|
| 250 | unsigned char status; |
---|
| 251 | long long time; |
---|
| 252 | |
---|
| 253 | /* (falls nötig) warten bis PR (Punch ready == busy) kommt */ |
---|
| 254 | /*for(;;) *///{ |
---|
| 255 | /*int x; |
---|
| 256 | for(x=0;x<5;x++) { |
---|
| 257 | if(ioctl(fd, PPRSTATUS, &status)) |
---|
| 258 | return -1; |
---|
| 259 | |
---|
| 260 | if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) { |
---|
| 261 | DPRINTF("Puncher ready to recieve (%x)\n", status); |
---|
| 262 | x=-1; |
---|
| 263 | break; |
---|
| 264 | } |
---|
| 265 | usleep(10); |
---|
| 266 | }*/ |
---|
| 267 | |
---|
| 268 | /* Puncher hatte noch kein PR gesetzt. */ |
---|
| 269 | //if(x<0) |
---|
| 270 | // DPRINTF("Waited for Puncher ready (status=%x)... ", status); |
---|
| 271 | |
---|
| 272 | //usleep(8000); |
---|
| 273 | /* 1/2 Sekunde ist fuer debugzwecke besser als die vorherigen 8000. */ |
---|
| 274 | //} |
---|
| 275 | |
---|
| 276 | /* set data pins */ |
---|
| 277 | if(ioctl(fd, PPWDATA, &buf)) |
---|
| 278 | return -2; |
---|
| 279 | time = mtime(0); |
---|
| 280 | |
---|
| 281 | usleep(10); // take some time... |
---|
| 282 | |
---|
| 283 | /* "pulse" strobe ==> turn off strobe! (strange behaviour) */ |
---|
| 284 | if(ioctl(fd, PPWCONTROL, &null_mask)) |
---|
| 285 | return -3; |
---|
| 286 | DPRINTF("data set; strobe pulsed...\n"); |
---|
| 287 | |
---|
| 288 | /* Puncher: PI (=strobe) minimum == 100us */ |
---|
| 289 | usleep(220); // DTL TRY |
---|
| 290 | // was: 220 => wir gehen jetzt auf 2ms |
---|
| 291 | |
---|
| 292 | /* check if Punch Ready has fallen */ |
---|
| 293 | if(ioctl(fd, PPRSTATUS, &status)) |
---|
| 294 | return -4; |
---|
| 295 | // bringts ja eh nicht -- also lassen. |
---|
| 296 | |
---|
| 297 | /*for(;;) { |
---|
| 298 | if(ioctl(fd, PPRSTATUS, &status)) |
---|
| 299 | return -4; |
---|
| 300 | if((status & PARPORT_STATUS_BUSY) != PARPORT_STATUS_BUSY) { |
---|
| 301 | * it has not - quite bad, but we will continue * |
---|
| 302 | DPRINTF("ERROR: Punch Ready has NOT FALLEN (%x)\n",status); |
---|
| 303 | usleep(5*1000); // noch mal 5ms warten. |
---|
| 304 | } else break; |
---|
| 305 | }*/ |
---|
| 306 | |
---|
| 307 | /* end strobe + data pins */ |
---|
| 308 | DPRINTF("Control is %x. Ending data pins... ",status); |
---|
| 309 | if(ioctl(fd, PPWDATA, &null_mask)) return -5; |
---|
| 310 | DPRINTF("+ strobe... "); |
---|
| 311 | if(ioctl(fd, PPWCONTROL, &strobe_on)) return -5; |
---|
| 312 | |
---|
| 313 | /* wait untill Puncher is ready to success */ |
---|
| 314 | { |
---|
| 315 | int wait = 40*1000-mtime(time); // war 13*1000 |
---|
| 316 | DPRINTF("\nWaiting for Puncher Ready (%i usec)...", wait); |
---|
| 317 | if(wait>0) usleep(wait); |
---|
| 318 | } |
---|
| 319 | |
---|
| 320 | if(ioctl(fd, PPRSTATUS, &status)) return -6; |
---|
| 321 | if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) { |
---|
| 322 | DPRINTF("Still busy (%x).\n", status); |
---|
| 323 | return 1; |
---|
| 324 | } else { |
---|
| 325 | DPRINTF("Finished successfully (%x)\n", status); |
---|
| 326 | return 0; |
---|
| 327 | } |
---|
| 328 | |
---|
| 329 | |
---|
| 330 | //for(;;) { |
---|
| 331 | /* |
---|
| 332 | int x; |
---|
| 333 | unsigned char status1,status2; |
---|
| 334 | for(x=0;x<(100);x++) { |
---|
| 335 | if(ioctl(fd, PPRSTATUS, &status1)) return -6; |
---|
| 336 | usleep(15); |
---|
| 337 | if(ioctl(fd, PPRSTATUS, &status2)) return -6; |
---|
| 338 | if(status1 == status2) { |
---|
| 339 | //DPRINTF("%x=%x ",status1,status2); |
---|
| 340 | status = status2; |
---|
| 341 | |
---|
| 342 | if((status & PARPORT_STATUS_BUSY) == PARPORT_STATUS_BUSY) { |
---|
| 343 | DPRINTF("- Puncher finished successfully (%x)\n",status); |
---|
| 344 | return 0; |
---|
| 345 | } |
---|
| 346 | } |
---|
| 347 | usleep(10); |
---|
| 348 | }//for |
---|
| 349 | |
---|
| 350 | DPRINTF("Cycle passed. Still busy (%x/%x). Going on.\n",status1,status2); |
---|
| 351 | |
---|
| 352 | //usleep(10000); // 20ms was |
---|
| 353 | /* Der Komplettintervall betraegt 13.33 Microsekunden - |
---|
| 354 | * 10ms ist vielleicht angemessen |
---|
| 355 | * */ |
---|
| 356 | //} |
---|
| 357 | //return 0; |
---|
| 358 | } /* write_puncher */ |
---|