diff options
| -rw-r--r-- | Makefile | 8 | ||||
| -rw-r--r-- | sercp.c | 786 |
2 files changed, 794 insertions, 0 deletions
diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..ffe0501 --- /dev/null +++ b/Makefile @@ -0,0 +1,8 @@ +PROJECT=sercp +all: + gcc $(PROJECT).c -o $(PROJECT) -Wall -pedantic -MP -MD -std=gnu11 -Werror=format-security -O2 +debug: + gcc $(PROJECT).c -o $(PROJECT) -Wall -pedantic -MP -MD -std=gnu11 -Werror=format-security -g -O0 + +clean: + rm -f $(PROJECT) $(PROJECT).d $(PROJECT).o @@ -0,0 +1,786 @@ +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <stdint.h> +#include <getopt.h> +#include <termios.h> +#include <error.h> +#include <sys/stat.h> +#include <sys/ioctl.h> +#include <sys/signal.h> +#include <fcntl.h> +#include <poll.h> + +#define false 0 +#define FALSE 0 +#define true 1 +#define TRUE 1 + + +// SERIAL +char MODEMDEVICE[64]; +FILE *tapout_fd = NULL; +int is_outfile = 0; +int baud_rate = 0; +int wait_us = 200; +int wait_ms = 800; +#define FILENAME_LENGTH 400 +char output_dump_file[FILENAME_LENGTH]; +char tap_file[FILENAME_LENGTH]; +unsigned char in_buff[65538]; +unsigned char *p_buff; +unsigned int is_continue = 1; +unsigned int is_binary = 0; +struct pollfd spolfd_serial[1]; // pole descriptoru pro poll + +static int inp_indx = 0; +int serial_fd; +size_t out_indx; +struct sigaction saterm; /* definition of signal action */ + +float width; // width of terminal +long pos = 0; +int scp = 0; +int is_scp_read = 0; + +typedef struct { + uint16_t block_len; + uint8_t block_xor; + uint8_t block_sum; +} __attribute__((packed)) fi_sum; + +typedef struct { + uint16_t length; // delka dat ve fileinfo + uint8_t h_xor; // xor bajtu fileinfa od fi_numblocks + uint8_t h_sum; // sum bajtu fileinfa od fi_numblocks + uint8_t fi_numblocks; // pocet bloku + uint8_t fi_name[64]; // jmeno souboru - prozatim musi byt ve fromatu 8.3 - kvuli esxdosu + uint8_t fi_date[8]; // nepouzito + uint8_t fi_time[8]; // nepouzito + fi_sum fi_blocks[256]; // delky a soucty bloku +} __attribute__((packed)) FILEINFO; + +FILEINFO fileinfo; + + +void usage(void) { + printf ("Tap file over serial port uploader/downloader. (c)2012-2015 Pavel Vymetálek <pavel@vym.cz>\n"); + printf ("Based on utility tapheader: http://zeroteam.sk/tapheader.html (c)2012 Michal Jurica <mike@zeroteam.sk>\n"); + printf ("Usage:\ntaptoser [-v] [-h] [-o filename.tap] [-b|--baud baud_rate] -d /dev/serial tap_file\n"); + printf ("\t-v, --version\tShow version info\n"); + printf ("\t-h, --help\tShow this text\n"); + printf ("\t-d, --device\tCommunication device\n"); + printf ("\t-w, --wait\tWaiting in microseconds between transmitted bytes. Default is -w 200us\n"); + printf ("\t-b, --baud\tSet the communication speed. 4800Bd, 9600Bd, 19200Bd and 57600Bd (default) are supported\n"); + printf ("\t-B, --binary\tBinary output - received tap from ZX Spectrum will save without all tap's specific mishmash\n"); + printf ("\t-o, --outfile\tOutput file. Usualy *.tap or *.bin with in --binary mode\n"); + printf ("SCP mode -----\n"); + printf ("\t-s, --scp\tSCP mode - sent files with fileinfo 1109bytes\n"); + printf ("\t-r, --read\tread file\n"); + printf ("\t-w, --wait\tWaiting in milliseconds between transmitted blocks. Default is -w 800 milliseconds\n"); +} + +void Set_DTR(unsigned short level) { + int status; + ioctl(serial_fd, TIOCMGET, &status); + if (level) { + status |= TIOCM_DTR; + } else { + status &= ~TIOCM_DTR; + } + ioctl(serial_fd, TIOCMSET, &status); +} + +void TestCts(void) { + int status; + do { + ioctl(serial_fd, TIOCMGET, &status); + if (status & 0x20) break; + usleep (100); + if (is_continue == 0) return; + // printf ("status: %X\n",status); + } while (1); +} + + +void TestArgs (int argc, char *argv[]) +{ + int c; + while (1) { + int option_index = 0; + static struct option long_options[] = { + {"outfile", required_argument, NULL, 'o'}, + {"device", required_argument, NULL, 'd'}, + {"baud", required_argument, NULL, 'b'}, + {"wait", required_argument, NULL, 'w'}, + {"scp", no_argument, NULL, 's'}, + {"read", no_argument, NULL, 'r'}, + {"binary", no_argument, NULL, 'B'}, + {"version", no_argument, NULL, 'v'}, + {"help", no_argument, NULL, 'h'}, + {0, 0, 0, 0} + }; + c = getopt_long (argc, argv, "o:d:b:w:srBvh", long_options, &option_index); + if (c == -1) { + // konec parametru + break; + } + switch (c) { + case 'h': + usage(); + exit(1); + break; + case 'b': + baud_rate = atoi(optarg); + break; + case 'w': + wait_us = atoi(optarg); + wait_ms = atoi(optarg); + break; + case 's': + printf ("Serial CP mode is activated\n"); + scp = 1; + break; + case 'r': + printf ("scp read...\n"); + is_scp_read = 1; + break; + case 'd': + strncpy(MODEMDEVICE, optarg, strlen(optarg)); +// printf ("Serial port: %s\n", MODEMDEVICE); + break; + case 'o': + strncpy (output_dump_file, optarg, strlen(optarg)); + is_outfile = 1; + break; + case 'B': + printf ("Running in binary output mode\n"); + is_binary = 1; + break; + case 'v': + printf ("Version 0.9.1 2015-07-22\n"); + exit(1); + break; + default: + break; + } + } + if (optind < argc) { + while (optind < argc){ + strncpy (&tap_file[0], argv[optind++], 63); // input tap file name - without option switch + } + } +} + + +// from tapheader utility +unsigned int h_len; + +unsigned int getword(unsigned char* data) { + return *data + 256 * (*(data + 1)); +} + +void tooshort(FILE *fd) { + printf("Input file too short.\n\n"); + fclose(fd); + exit(2); +} + +// decode header1 +void decode(unsigned char *header) { + char name[11]; + unsigned int n; + printf("\n"); + strncpy(name, (char*)(header+2), 10); + name[10] = '\0'; + printf("Filename: %12s \n", name); + printf("Flag: %4u ", (unsigned int)*header); + n = getword(header+14); + h_len = getword(header+12); + + switch(*(header+1)) { + case '\0': + printf("Type: 0 => program\nProgram length: %6u bytes ", h_len); + if (n < 32768) printf("Runs from line %5u\t", n); + printf("Length without variables: %5u bytes ", getword(header+16)); + break; + case '\1': + printf("Type: 1 => number array\tLength: %6u bytes", h_len); + break; + case '\2': + printf("Type: 2 => character array\tLength: %6u bytes", h_len); + break; + case '\3': + if (n == 16384 && h_len == 6912) + printf("Type: 3 => screen image\n"); + else + printf("Type: 3 => bytes " + "Start address: %5u\t" + "Length: %6u bytes\t3rd param: %4u", + n, h_len, getword(header+16)); + break; + } + printf("\n"); +} + +void signal_handler_sigterm (int status) { + // CTRL+C pressed + is_continue = 0; // do not continue +} + +int GetTerminalWidth(void) { + struct winsize termsize; + ioctl (STDOUT_FILENO, TIOCGWINSZ, &termsize); + return (termsize.ws_col); +} + +#define PROGRESS_PERCENT 0 +#define PROGRESS_COMPLETTE 1 +#define PROGRESS_ERROR_CSUM 2 + +void DoProgress(size_t pos, size_t max, unsigned char csum_ok) { + width = GetTerminalWidth(); + float percent, p, m; + int imax = width - 40; + int ipercent; + int px; + char progress_char; + p = pos; + m = max; + percent = 100 / m * p; + ipercent = percent / 100 * imax; + if (is_binary) progress_char = '#'; + else progress_char = '='; + printf ("Proceed bytes: %6d/%6d [", (int) pos, (int)max); + for (px = 0; px < imax; px++) { + if (px < ipercent) printf ("%c", progress_char); + else printf (" "); + } + if (csum_ok == 0) { + printf ("] %3d %%\r", (int)percent); + } else if (csum_ok == 1) { + printf ("] OK \r"); + } else { + printf ("] ERR \r"); + } + fflush (stdout); +} + +#define HEADER_RAW_LEN 21 + +void RecvTap() { + unsigned int err; + size_t len; + int result; + size_t block_pos = 0, last_block_pos = 0; + size_t block_len = 10000; + size_t tap_pos = 0; + unsigned char xor_csum, xor_csum_ok; + unsigned char *p_write; + unsigned char block_type; // typ bloku 255 data 0 - hlavicka + unsigned char recv_status = 0; // 0 - zacatek, 1 - hlavicka nactena, 2 - blok se nacita, 3- header less + tapout_fd = fopen (output_dump_file, "a"); + if (tapout_fd == NULL) { + err = errno; + error (1, err, "can't open output file"); + } + printf("Output file is: %s\n", output_dump_file); + p_buff = in_buff; + p_write = in_buff; + while (is_continue) { + result = poll (spolfd_serial, 1, 200); // 200ms timeout + if (result == 0) { + // nic neprislo + continue; + } + if (spolfd_serial[0].revents & POLLIN) { + len = read (serial_fd, p_buff, 256); + block_pos += len; + p_buff += len; + if (is_binary == 0) { + // ulozeni dat ze seriaku jako tap file + while (len) { + fputc(*p_write, tapout_fd); + p_write++; + len--; + } + } + if (block_pos != last_block_pos && recv_status >= 2) { + last_block_pos = block_pos; + DoProgress(block_pos, block_len+2, PROGRESS_PERCENT); + } + if (block_pos >= HEADER_RAW_LEN && recv_status == 0) { + recv_status = 1; // hlavicka nactena + block_len = getword(in_buff); + block_type = *(in_buff + 2); + if (block_type == 0) { + // Hlavicka komplet + decode (in_buff + 2); + block_len = 0; + block_pos = 0; + xor_csum = 0; + recv_status = 0; + p_buff = in_buff; + p_write = in_buff; + } else if (block_type == 255) { + // data block + printf ("Data block len: %6zu\n", block_len-2); + recv_status = 3; + } + continue; + } + if (block_pos > HEADER_RAW_LEN + 3 && recv_status == 1) { + // nactena delka dalsiho bloku + recv_status = 2; + block_len = getword(in_buff + HEADER_RAW_LEN); + block_type = *(in_buff + HEADER_RAW_LEN + 2); + printf ("Block len: %zu Block type: %d\n", block_len, block_type); + continue; + } + if (block_len + 2 == block_pos && recv_status > 2) { + // Blok komplet nacten cekej novy + block_len = getword(in_buff); + block_type = *(in_buff + 2); + for (tap_pos = 0; tap_pos < block_len -1; tap_pos++) { + xor_csum ^= *(in_buff + 2 + tap_pos); + } + xor_csum_ok = *(in_buff + 2 + block_len - 1); + if (xor_csum == xor_csum_ok) { + DoProgress(block_pos, block_len+2, PROGRESS_COMPLETTE); // vypis jeste OK + if (is_binary == 1) { + // binarni vystup do souboru + for (tap_pos = 0; tap_pos < block_len - 2; tap_pos++){ + fputc(*(in_buff + 3 + tap_pos), tapout_fd); // uloz do souboru + } + DoProgress(tap_pos, block_len - 2, PROGRESS_COMPLETTE); + } +// printf ("Checksum OK\n"); + } else { + DoProgress(block_pos, block_len+2, PROGRESS_ERROR_CSUM); // vypis error CSUM + } + block_len = 0; + block_pos = 0; + xor_csum = 0; + recv_status = 0; + p_buff = in_buff; + p_write = in_buff; + continue; + } + } + } + fclose (tapout_fd); + printf ("\n\nulozeno...\n"); +} + +void SendByte(unsigned char *p_dato) { + TestCts(); + write (serial_fd, p_dato, 1); +// tcdrain(serial_fd); // better solution, but usleep at the next line is + usleep (wait_us); // faster solution, TODO change sleep time according to serial communication speed 200us is for 57600Bd +} + +void SendTap() { + FILE *tap_fd; + unsigned int err, no, len; + struct stat st; + unsigned char header[19]; + + no = stat(tap_file, &st); + if (no != 0) { + err = errno; + error(1, err, "can't stat input file"); + } + + tap_fd = fopen(tap_file, "r"); + if (tap_fd == NULL) { + err = errno; + error(1, err, "can't open input file"); + } + while (pos < st.st_size) { + if (is_continue == 0) break; + pos += no = fread(header, 1, 2, tap_fd); + if (no != 2) + tooshort(tap_fd); + for (out_indx = 0; out_indx < 2; out_indx++) { + SendByte(&header[out_indx]); + } + no = getword(header); + if (no == 19) /* HEADER */ + { + pos += no = fread(header, 1, 19, tap_fd); + if (no != 19) + tooshort(tap_fd); +// printf ("Header len: %d\n", no); + decode(header); + for (out_indx = 0; out_indx < 19; out_indx++) { + SendByte(&header[out_indx]); + } + } else { + if (h_len != no - 2) { /* zobrazuj iba bloky bez hl. */ + len = no; + printf ("NO datablock without header: %d\n", no); + printf("Type: datablock\nLength: %u\n", len - 2); + pos += no = fread(header, 1, 1, tap_fd); + SendByte(header); + DoProgress(1, no, PROGRESS_PERCENT); + if (no != 1) tooshort(tap_fd); + printf("Flag: %u\n\n", (int)*header); + len--; + } else { + len = no; + } + pos += len; + for (out_indx = 0; out_indx < len; out_indx++) { + fread(header, 1, 1, tap_fd); + SendByte(header); + DoProgress(out_indx+1, len, PROGRESS_PERCENT); + if (is_continue == 0) break; + } + printf ("\n"); + usleep (800000); + } + } + fclose(tap_fd); +} + + +int CheckFileInfo(FILEINFO* p_fi) { + unsigned char *p_fiinfo = (unsigned char*)p_fi; + uint16_t fi_len; + uint8_t fi_xor = 0; + uint8_t fi_sum = 0; + fi_len = p_fi->length; + p_fiinfo += 4; // suma se bude pocitat od offsetu 4 + for (uint16_t indx = 0; indx < (fi_len-4); indx++) { + fi_xor ^= *p_fiinfo; + fi_sum += *p_fiinfo; + p_fiinfo++; + } + if (fi_xor == p_fi->h_xor && fi_sum == p_fi->h_sum) { + return 0; + } + return -1; +} + +void CountFileInfoChecksum(FILEINFO* p_fi) { + unsigned char *p_fiinfo = (unsigned char*)p_fi; + uint16_t fi_len; + uint8_t fi_xor = 0; + uint8_t fi_sum = 0; + fi_len = p_fi->length; + p_fiinfo += 4; // suma se bude pocitat od offsetu 4 + for (uint16_t indx = 0; indx < (fi_len-4); indx++) { + fi_xor ^= *p_fiinfo; + fi_sum += *p_fiinfo; + p_fiinfo++; + } + p_fi->h_xor = fi_xor; + p_fi->h_sum = fi_sum; +} + +int CheckSumBlock(FILEINFO* p_fi, uint8_t block_indx, uint8_t *p_buffer) { + uint16_t block_len; + uint8_t b_xor = 0; + uint8_t b_sum = 0; + uint8_t block_xor; + uint8_t block_sum; + block_len = p_fi->fi_blocks[block_indx].block_len; + block_sum = p_fi->fi_blocks[block_indx].block_sum; + block_xor = p_fi->fi_blocks[block_indx].block_xor; + for (uint16_t indx = 0; indx < block_len; indx++) { + b_xor ^= *p_buffer; + b_sum += *p_buffer; + p_buffer++; + } + if (b_xor == block_xor && b_sum == block_sum) { + return 0; // vrat se, je to v poradku + } + return -1; // vrat se s chybou bloku +} + +void CountSumBlock(FILEINFO* p_fi, uint8_t block_indx, uint8_t *p_buffer, uint16_t block_len) { + uint8_t block_xor = 0; + uint8_t block_sum = 0; + for (uint16_t indx = 0; indx < block_len; indx++) { + block_xor ^= *p_buffer; + block_sum += *p_buffer; + p_buffer++; + } + p_fi->fi_blocks[block_indx].block_len = block_len; + p_fi->fi_blocks[block_indx].block_sum = block_sum; + p_fi->fi_blocks[block_indx].block_xor = block_xor; +} + + +unsigned char buff[32768]; + +uint32_t GetOverallLen(FILEINFO *p_fi) { + uint32_t overall_len = 0; + uint8_t block_num = p_fi->fi_numblocks; + for (uint8_t indx = 0; indx < block_num; indx++) { + overall_len += p_fi->fi_blocks[indx].block_len; + } + return overall_len; +} + +void RecvSCP(void) { + int recv_phase = 0; // 0 - fileinfo, 1 - blok 16kiB, 2 - posledni blok + uint8_t block_index = 0; + int result; + uint16_t len; + uint16_t length = 0; + uint16_t expected_len = 0; +// uint8_t expected_xor; +// uint8_t expected_sum; + uint32_t overall_length = 0; // celkova delka souboru + uint32_t recv_length = 0; // zatim prijatych dat ze souboru + int err; + + FILEINFO *p_fileinfo = &fileinfo; + unsigned char *p_buff = buff; + tapout_fd = NULL; + + memset (p_fileinfo, 0, sizeof(fileinfo)); + while (is_continue) { + result = poll (spolfd_serial, 1, 200); // 200ms timeout + if (result == 0) { + // nic neprislo + continue; + } + switch (recv_phase) { + case 0: + // prijem fileinfo + if (spolfd_serial[0].revents & POLLIN) { + len = read (serial_fd, p_buff, sizeof(fileinfo)); + p_buff += len; + length += len; + if (length == sizeof(fileinfo)) { + memcpy((unsigned char*) p_fileinfo, buff, sizeof(fileinfo)); + if (CheckFileInfo(p_fileinfo) == 0) { + printf("Prijato fileinfo\n"); + overall_length = GetOverallLen(p_fileinfo); + printf("Nazev souboru: \"%s\" pocet bloku:%d, delka souboru: %u\n", p_fileinfo->fi_name, p_fileinfo->fi_numblocks, overall_length); + recv_phase++; // priste se uz prijimaji bloky + block_index = 0; // zacina se prvnim blokem + p_buff = buff; // buffer na zacatek + length = 0; + expected_len = p_fileinfo->fi_blocks[block_index].block_len; + + + tapout_fd = fopen ((char*)p_fileinfo->fi_name, "w"); + if (tapout_fd == NULL) { + err = errno; + error (1, err, "can't open output file"); + } +// expected_xor = p_fileinfo->fi_blocks[block_index].block_xor; +// expected_sum = p_fileinfo->fi_blocks[block_index].block_sum; + } else { + printf("Fileinfo neni v cajku. Koncim...\n"); + break; + } + break; + } else if (length > sizeof(fileinfo)){ + len = read (serial_fd, p_buff, sizeof(fileinfo)); + printf("Nejaky bordel. Koncim...\n"); + break; + } + } + break; + case 1: + // prijem datoveho bloku - max. delka 16kiB + if (spolfd_serial[0].revents & POLLIN) { + len = read (serial_fd, p_buff, expected_len); + p_buff += len; + expected_len -= len; + length += len; + recv_length += len; + DoProgress(recv_length, overall_length, PROGRESS_PERCENT); + if (length == p_fileinfo->fi_blocks[block_index].block_len) { + // prijaty prvni block +// printf("Prijaty blok c.%d delky: %d\n", block_index, length); + if (CheckSumBlock(p_fileinfo, block_index, buff) == 0) { + // blok je v cajku - zapsat do souboru + if (tapout_fd) fwrite(buff, length, 1, tapout_fd); + } + length = 0; + p_buff = buff; + block_index++; + expected_len = p_fileinfo->fi_blocks[block_index].block_len; + } + if (expected_len == 0 || block_index == 255) { + printf ("\nKonec prenosu\n"); + recv_phase++; + is_continue = 0; + break; + } + } else if (length > 16384) { + len = read (serial_fd, p_buff, 16384); + printf("Nejaky bordel. Koncim...\n"); + break; + } + } + } + if (tapout_fd) fclose (tapout_fd); + printf ("\n\nulozeno...\n"); +} + +void SendSCP(void) { + FILE *tap_fd; + unsigned int err, no, len; + struct stat st; + FILEINFO *p_fileinfo = &fileinfo; + unsigned char *p_buff = buff; + uint32_t file_len; + uint8_t num_blocks = 0; + ssize_t odeslano; + uint32_t len_sent; + uint16_t sent_size; + uint32_t overall_sent; + + + no = stat(tap_file, &st); + if (no != 0) { + err = errno; + error(1, err, "can't stat input file"); + } + + tap_fd = fopen(tap_file, "r"); + if (tap_fd == NULL) { + err = errno; + error(1, err, "can't open input file"); + } + printf ("Soubor %s delky: %ld\n", tap_file, st.st_size); + memset (p_fileinfo, 0, sizeof(fileinfo)); // smazat fileinfo + + memcpy(p_fileinfo->fi_name, tap_file, strlen(tap_file)); + file_len = (uint32_t) st.st_size; + while (file_len) { + len = fread(buff, 1, 16384, tap_fd); // precti 16kiB dat + CountSumBlock(p_fileinfo, num_blocks, buff, len); +// printf ("Blok c. %d, delka: %d\n", num_blocks, len); + file_len -= len; + num_blocks++; + } + p_fileinfo->fi_numblocks = num_blocks; + p_fileinfo->length = num_blocks*4 + 85; + CountFileInfoChecksum(p_fileinfo); + odeslano = write (serial_fd, (void*)p_fileinfo, sizeof(fileinfo)); + tcdrain(serial_fd); + printf("Fileinfo sent...\n"); + // TODO Cekat pauzu mezi bloky + usleep (wait_ms * 1000); + + rewind(tap_fd); // prenaseny soubor na zacatek + file_len = (uint32_t) st.st_size; + overall_sent = 0; + while (file_len && is_continue) { + len = fread(buff, 1, 16384, tap_fd); // precti 16kiB dat + p_buff = buff; + sent_size = 256; + len_sent = len; + while (len_sent && is_continue) { + odeslano = write (serial_fd, (void*)p_buff, sent_size); + tcdrain(serial_fd); + p_buff += odeslano; + overall_sent += odeslano; + len_sent -= odeslano; + if (len_sent < 256) { + sent_size = len_sent; + } + DoProgress(overall_sent, st.st_size, PROGRESS_PERCENT); + } + usleep (wait_ms * 1000); + file_len -= len; + } + printf("\nFile sent...\n"); + fclose(tap_fd); +} + +int main(int argc, char** argv, char** env) +{ + // osetreni breaku ^C + saterm.sa_handler = signal_handler_sigterm; + saterm.sa_flags = 0; + sigaction (SIGINT, &saterm, NULL); + width = GetTerminalWidth(); + + // nastaveni serioveho portu + struct termios oldtio, newtio; + inp_indx = 0; + if (argc < 3) { + printf("You must specify the Serial device and file\n"); + usage(); + exit(1); + } + TestArgs (argc, argv); + /* open the device to be non-blocking (read will return immediatly) */ + serial_fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK); + if (serial_fd < 0) { + perror(MODEMDEVICE); + return(-1); + } + tcgetattr(serial_fd, &oldtio); /* save current port settings */ + switch (baud_rate){ + default: + baud_rate = 57600; // default speed + newtio.c_cflag = B57600 | CS8 | CLOCAL | CREAD | CSTOPB;// | CRTSCTS; + break; + case 115200: + newtio.c_cflag = B115200 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS; + break; + case 57600: + newtio.c_cflag = B57600 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS; + break; + case 38400: + newtio.c_cflag = B38400 | CS8 | CLOCAL | CREAD | CRTSCTS; // dva stopbity jsou nastaveny vsude, ale tady ne + break; + case 19200: + newtio.c_cflag = B19200 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS; + break; + case 9600: + newtio.c_cflag = B9600 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS; + break; + case 4800: + newtio.c_cflag = B4800 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS; + break; + case 2400: + newtio.c_cflag = B2400 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS; + break; + case 1200: + newtio.c_cflag = B1200 | CS8 | CLOCAL | CREAD | CSTOPB | CRTSCTS; + break; + } + newtio.c_cflag |= CRTSCTS; + printf ("Serial device: %s, communication speed is: %d Bd\n", MODEMDEVICE, baud_rate); +// newtio.c_iflag &= ~(IXON | IXOFF | IXANY); // vypne XON/XOFF + newtio.c_iflag = 0; //IGNPAR | IXOFF; + newtio.c_oflag = 0; +// newtio.c_oflag &= ~OPOST; + newtio.c_lflag = 0; //NOFLSH; + newtio.c_cc[VMIN] = 0; + newtio.c_cc[VTIME] = 10; + tcsetattr(serial_fd, TCSANOW, &newtio); + tcflush(serial_fd, TCIOFLUSH); + spolfd_serial[0].fd = serial_fd; // nastaveni hlidaneho descriptoru + spolfd_serial[0].events = POLLIN; // hlidaji se data na vstupu + + if (scp) { + // serial copy activated + if (is_scp_read) { + RecvSCP(); + } else { + SendSCP(); + } + } else { + Set_DTR(true); // PC can read data from speccy everytime + if (is_outfile) { + RecvTap(); // cteni tap souboru ze seriaku a zapis na disk pocitace + } else { + SendTap(); // poslat na seriak tap soubor do spectra + } + } + close (serial_fd); + return 0; +} |