oscillo.c

/****************************************************************
 *  program name / version
 *   oscillo.c      wave data transfer from oscilloscope to WS
 *---------------------------------------------------------------
 *  2003.03.12 by SCH. remove compile warnnings.
 *  1999.03.05 by GRA. for Lynix and AS network corrected.
 *  1998.02.21 by TEL.
 *                 copyright reserved by designers & YMBC project    
 ****************************************************************
 * NOTE:
 * 
 * device name : LT etc.: /dev/ttya Max baourate is 9600.
 *               PC/AT etc.: /dev/ttyS0 (Upper one is ttyS1 at robolin1)
 *                           Max baurate is 19200.   
 *
-- succeeded set up of the terminal --

% stty -a > /dev/ttya
input speed 9600 baudoutput speed 19200 baud, 0 rows, 0 columns
eucw 1:2:1:2, scrw 1:2:1:2
-parenb -parodd cs8 -cstopb -hupcl cread clocal -crtscts 
-ignbrk brkint -ignpar -parmrk inpck istrip -inlcr igncr icrnl -iuclc 
-ixon -ixany -ixoff -imaxbel 
-isig iexten -icanon -xcase -echo -echoe -echok -echonl -noflsh -tostop 
-echoctl -echoprt -echoke 
-opost -olcuc onlcr -ocrnl -onocr -onlret -ofill -ofdel -tabs 
min 255, time 5
erase  kill   werase rprnt  flush  lnext  susp   intr   quit   stop   eof
^?     ^U     ^W     ^R     ^O     ^V     ^Z/^Y  ^C     ^\     ^S/^Q  
%
 ****************************************************************/

#include <unistd.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <sys/termios.h> 
#include <sys/file.h>
#include <signal.h>
#include <string.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/ioctl.h>

#define STX 0x2
#define ETX 0x3
#define ENQ 0x5
#define ACK 0x6
#define NAK 0x15
#define ACK_STRING "\006"
#define BELL 0x7
#define LF 0xa
#define NL LF
#define CR 0xd
#define SI  0x0f
#define SO  0x0e

#define HIGH( val ) ((val>>4) & 0xf) /* high nibble */
#define LOW( val ) (val & 0xf)  /* low nibble */
#define FALSEP( cond ) (cond==FALSE)
#define TRUEP( cond ) (cond==TRUE)

typedef unsigned char Uchar;
typedef unsigned short Ushort;
typedef unsigned int Uint;
typedef Uchar * UniversalPointer;
typedef enum {
    FALSE,
    TRUE
} Bool;

#define BAUD      9600
#define DATA       256
#define LENGTH    1024
#define LENGTH2   2048
#define LENGTH16 16384
#define LENGTH32 32768
/* #define STDERR 2 */

struct termios ytm,old_ytm;   
int sw_old_ytm = 0;

typedef struct point {
    double x, y;
} Point;

void finishDev(void);
void exit_mode(int);
void setup(int, char *[]);
void get_length(void);
void read_wave(void);
void exit_mode(int);
void Command_output(char *);
int Read_command(char *, char);
void ErrorCheck(int retv);
void get_info(void);
void save_data(Point *);
void Nak_err(void);
void Other_err(void);
void uWrite(int fd, char *buff, int nwrite);
void options(int argc, char *argv[]);
void crlf(void);
int calcBaudChar(Uint baud);
int hog(int ttyfd, int w, int print);


extern int errno;
int ttyfd;
char BlockTransferChar;
char progName[80];
int channel = 0;         /* channel number */
int data_len;            /* data length */
char sfile[20];          /* output filename */
char TermDev[32];        /* terminal device */
int no_ad_gnd = 0;       /* adjust GND level ON/OFF */
int save_format = 0;     /* saving the data DOUBLE/BINARY */
double volt,timediv,gnd; /* volt/div, time/div, GND level   !!! 'time'->'timediv' */
int baudrate = BAUD;     /* baudrate */


int main(int argc, char *argv[])
{
    setup(argc, argv);
    get_length();
    read_wave();
    exit_mode(0);
    
    return 0;
}


void usage(void)
{
    fprintf(stderr, "\n%s : %s [-p port] [-c channel] [-h] [-v] [-b] [-g] [filename]\n", progName, progName);
}


void version(void)
{
    printf("\n%s version 2.3.1  1994/08/07\n\n",progName);
}


void help(void)
{
    printf("\n-p port    : RS232C device port [/dev/ttya,/dev/ttyb]");
    printf("\n-b baudrate: baudrate [300,600,1200,2400,4800,9600,19200]");
    printf("\n-c channel : wave channel [1,2,3,4,calc,calc2,REF1,REF3]");
    printf("\n             REF1 : take data from channel 1  ");
    printf("\n                    In case of taking 2k data, put upper 1k in REF1 ");
    printf("\n                    and lower 1k in REF2.     ");
    printf("\n             REF3 : take data from channel 2  ");
    printf("\n                    In case of taking 2k data, put upper 1k in REF3 ");
    printf("\n                    and lower 1k in REF4.     ");
    printf("\n-f         : save the data in binary (faster) ");
    printf("\n-g         : no-adjust GND level");
    printf("\n-h         : display this help");
    printf("\n-v         : display version");
    printf("\nfilename   : wave data file name\n");
    printf("\n    %s tansfers wave data from DS-8613 & DS-8617 to WS.",progName);    
    printf("\n    data length is choosen automatically [1k,2k,16k,32k].");
    printf("\n    GND level is adjusted (expect -g option)."); 
    printf("\n    channel CALC[1|2] is supprted only for DS-8617.\n\n");
}


void get_length(void)
{
    int retv;
    char *len,*len1,*len2,*len16,*len32;
    
    len1="1K\n"; len2="2K\n"; len16="16K\n"; len32="32K\n";
    if ((len = malloc(sizeof(char)*DATA)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    Command_output("LGTH?");   
    retv = Read_command(len,LF);
    ErrorCheck(retv);
    if (strcmp(len+1,len1)==0) data_len = LENGTH;
    else if (strcmp(len+1,len2)==0) data_len = LENGTH2;
    else if (strcmp(len+1,len16)==0) data_len = LENGTH16;
    else if (strcmp(len+1,len32)==0) data_len = LENGTH32;
    else{
        fprintf(stderr,"data length error\n");
        exit_mode(1);
    }
    free(len);
}


void set_channel(void)
{
    char *rch,u[10];
    int retv;

    if (channel == 0){
        printf("Input channel\n");
        printf(" CH1->1 CH2->2 CH3->3 CH4->4 CALC1->5 CALC2->6 \n");
        printf(" REF1>7 REF3>8                                 \n");
        scanf("%d%*c",&channel);
    }
    if ((rch = malloc(sizeof(char)*DATA)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    if (channel < 5) sprintf(u, "DIRV CH%1d", channel);
    else if (channel == 5) sprintf(u, "DIRV CH1");
    else if (channel == 6) sprintf(u, "DIRV CH3");
    else if (channel == 7) sprintf(u, "DIRV CH1");
    else if (channel == 8) sprintf(u, "DIRV CH2");
    else{
        fprintf(stderr,"wrong channel.\n");
        exit_mode(1);
    }
    Command_output(u);
    retv = Read_command(rch,ACK);
    ErrorCheck(retv);
    if (channel < 5) printf("channel No.%1d\n",channel);
    else if (channel < 7) printf("channel CALC%1d\n",channel-4);
    else printf("channel REF%1d\r\n",channel-6);
    free(rch);
}


void read_wave(void)
{
    int i,retv;       /* i:counter, c:input character */
    char u[50],*rch;
    Point *p;

    set_channel();
    get_info();
    if ((rch = malloc(sizeof(char)*data_len*7+3)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    if (channel < 5) sprintf(u, "MEMR CH%1d, 0, 0, %d",channel,data_len);
    else if (channel == 5) sprintf(u, "MEMR CALC, 0, 0, %d", data_len);
    else if (channel == 6) sprintf(u, "MEMR CALC2, 0, 0, %d", data_len);
    else if (channel == 7) sprintf(u, "MEMR REF1, 0, 0, %d", data_len);
    else sprintf(u, "MEMR REF3, 0, 0, %d", data_len);
    Command_output(u);
    retv = Read_command(rch,LF);
    ErrorCheck(retv);
    printf("\nDone.\n");

    if ((p = (Point *)malloc(sizeof(Point)*data_len)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    for (i=0; i<data_len; i++){
        p[i].x = (double)i/1024.0 * timediv * 10.0;
        if (no_ad_gnd == 1){
            p[i].y = (double)(atoi(rch+1+i*7) / 256) / 256.0 * 8.0 * volt; 
        }
        else 
            p[i].y = ((double)(atoi(rch+1+i*7)/256)/256.0*8.0 - gnd) * volt;
        /* 16bit -> 8bit -> div */    
    }
    free(rch);
    save_data(p);
    free(p);
}


void get_info(void)
{
    char *t,*v,*g,u[10];
    int retv;

    if ((v = malloc(sizeof(char)*DATA)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    sprintf(u,"VDIV?");
    Command_output(u);
    retv = Read_command(v,LF);
    ErrorCheck(retv);
    volt = atof(v+1);
    printf("volt/dev = %g, ",volt);
    free(v);

    if ((t = malloc(sizeof(char)*DATA)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    sprintf(u,"TMDV?");
    Command_output(u);
    retv = Read_command(t,LF);
    ErrorCheck(retv);
    timediv = atof(t+1);
    printf("time/dev = %g, ",timediv);
    free(t);

    if ((g = malloc(sizeof(char)*DATA)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    sprintf(u,"VPOS?");
    Command_output(u);
    retv = Read_command(g,LF);
    ErrorCheck(retv);
    gnd = atof(g+1);
    printf("GND level = %g div\n",gnd);
    free(g);
}


void save_data(Point *p)
{
    FILE *fp;
    char check[5];
    int i;

    if ('\0' == sfile[0]){
        printf("Input file name for saving: ");
        scanf("%s%*c",sfile);
    }
    if (NULL != (fp = fopen(sfile,"r"))){
        fprintf(stderr,"%s is already exist. Overwrite (y/n) ?  ",sfile);
        scanf("%s",check);
        if (check[0] == 'n'){
            fprintf(stderr,"Input file name for saving :  ");
            scanf("%s",sfile);
        }
    }
    if (NULL == (fp = fopen(sfile,"wb"))){
        printf("Cannot open FILE : %s\n",sfile);
    }
    fprintf(stderr, "Now writing...");

    
    if(save_format == 1) /* data is written in BINARY. */
        fwrite(p,sizeof(Point),data_len,fp);

    else { /* data is written in DOUBLE.*/
        fprintf(fp, "# Volt/dev  %g\n", volt);
        fprintf(fp, "# Time/dev  %g\n", timediv);
        fprintf(fp, "# GND level %g\n", gnd);
        for (i=0; i<data_len; i++){
            fprintf(fp, "%g ", p[i].x);
            fprintf(fp, "%g\n", p[i].y);
        }
    }
        
    fclose(fp);
    printf("Done.\n");
}


void ErrorCheck(int retv)
{
    if (retv == NAK) Nak_err();
    else if (retv != ACK) Other_err();
}


void Nak_err(void)
{
    char *sch,u[10];
    int retv;

    if ((sch = malloc(sizeof(char)*DATA)) == NULL){
        fprintf(stderr,"malloc error:\n");
        exit_mode(1);
    }
    fprintf(stderr, "NAK received.\n");
    sprintf(u, "ERRN?");
    Command_output(u);
    retv = Read_command(sch,LF);
    ErrorCheck(retv);
    fprintf(stderr,"ERROR number : %s\n",sch);
    exit_mode(1);
}
  

void Other_err(void)
{
    fprintf(stderr, "Transfer error!!!\n");
    exit_mode(1);
}


void Command_output(char *sch)
{
    int writew;
    char *p;

    p = malloc(strlen(sch) + 2 + 1);
    strcpy(p,sch);
    writew = strlen(p) + 2; 
    if (writew == 2) exit_mode(1);
    p[writew-2] = '\r';
    p[writew-1] = '\n';
    p[writew] = '\0';
    uWrite(ttyfd, p, writew);
    free(p);
}


int Read_command(char *ch, char delim)
{
    int readw;
    char *start;
    int count = 0;
    start = ch;
    for(;;){
        readw = read(ttyfd, ch, DATA-1);
        if (start[0]!=ACK){
            return((int)ch[0]); /* something wrong for communication */
        }
        if ( readw > 0){
            if (ch[readw-1] == delim) {
                ch[readw] = '\0';
                break;          
            }
            else {
                count += readw;
                if(count >= 1024) {
                    fprintf(stderr,"\r%5d", data_len*7+3-((int)ch-(int)start));
                    count %= 1024;
                }
                ch=ch+readw;
                continue;
            }
        }
    }
    if(count > 0) fprintf(stderr,"\r%5d",0);
    return((int)start[0]);
}


void exit_mode(int st)
{
    finishDev();
    if(!st) ; //fprintf(stderr, "%s is normally ended\n", progName);
    else fprintf(stderr, "\n%s is ABNORMALLY exited\n", progName);
    exit(st);
}


void uWrite(int fd, char *buff, int nwrite)
{
    int writew;
    writew = write(fd, buff, nwrite);
    if ( writew < 0  && errno ) {
        perror("write:");
        exit_mode(1);
    }
}


void setup(int argc, char *argv[])
{
    Bool initDev();

    strcpy(progName, argv[0]);   /* copy program name. */
    BlockTransferChar = 't';

    options(argc,argv);
    if ( TermDev[0] == '\0' ) {
        fprintf(stderr, "device for communication : ");
        fflush(stderr);          /* flush. */
        scanf("%s", TermDev);
    }

    if FALSEP(initDev(TermDev, baudrate) ) {    /* initialize the device */
        fprintf(stderr, "something is wrong in initialization of devices.\n");
        crlf();
        exit_mode(1);
    }

    signal(SIGINT,exit_mode);
}


void options(int argc, char *argv[])
{
    int i;
    char *ch1,*ch2;

    ch1="calc"; ch2="calc2";
    for ( i = 1; i < argc; i++ ){
        if (argv[i][0] == '-'){
            switch (argv[i][1]){
            case 'p':
                i++;
                if (argv[i][0] == '-'){
                    usage();
                    exit_mode(1);
                }
                strcpy(TermDev, argv[i]);
                break;
            case 'c':
                i++;
                if (argv[i][0] == '-'){
                    usage();
                    exit_mode(1);
                }
                if (isdigit(argv[i][0])) channel = atoi(argv[i]);
                else if (strcmp(argv[i],ch1)==0) channel = 5;
                else if (strcmp(argv[i],ch2)==0) channel = 6;
                break;
            case 'f':
                save_format = 1;
                break;
            case 'g':
                no_ad_gnd = 1;
                break;
            case 'h':
                usage();
                help();
                exit_mode(0);
            case 'v':
                version();
                exit_mode(0);
            case 'b':
                i++;
                if (argv[i][0] == '-'){
                    usage();
                    exit_mode(1);
                }
                baudrate = atoi(argv[i]);
                break;
            default:
                fprintf(stderr, "illegal option %s.\n", argv[i]);
                exit_mode(0);
            }
        }
        else strcpy(sfile,argv[i]);
    }
}


void crlf(void)
{
    fprintf(stderr,"\r\n");
    return;
}


void finishDev()
{
    if(sw_old_ytm) ioctl(ttyfd, TCSETS, &old_ytm);
    close(ttyfd);
}


Bool initDev(char *term, Uint baud)
{
    if ( (ttyfd=open(term, O_RDWR)) < 0 ) {
        perror("open");
        return FALSE;
    }

    if ( ioctl(ttyfd, TCGETS, &old_ytm) ) {
        perror("ioctl(TCGETS:communication)");
        return FALSE;
    };

    sw_old_ytm = 1;
    ytm = old_ytm;

    /* for desplaying initial sets, REMAIN  this part.
       fprintf(stderr, "ytm.c_iflag=0x%6x\n", ytm.c_iflag);
       fprintf(stderr, "ytm.c_oflag=0x%6x\n", ytm.c_oflag);
       fprintf(stderr, "ytm.c_cflag=0x%6x\n", ytm.c_cflag);
       fprintf(stderr, "ytm.c_lflag=0x%6x\n", ytm.c_lflag); */

    ytm.c_iflag &= ~( IXON );
    ytm.c_iflag |= ( IGNCR | INPCK ); 
    /* ytm.c_iflag |= ( /IXOFF | IGNBRK | IGNPAR | /IGNCR | INPCK ); */
    ytm.c_oflag &= ~( OPOST );
    ytm.c_cflag &= ~( CBAUD | CSIZE | PARENB | CSTOPB );
    ytm.c_cflag |= ( calcBaudChar(baud) | CLOCAL | CS8 );
    ytm.c_lflag &= ~( ICANON |  ISIG |  ECHO );
    /*ytm.c_lflag &= ~( ICANON |  ISIG |  ECHO  /| IEXTEN /);*/
    ytm.c_cc[4]=255;      /* MIN  */
    ytm.c_cc[5]=5;      /* TIME */


    if ( ioctl(ttyfd, TCSETS, &ytm) ) {
        perror("ioctl(TCSETS:communication)");
        return FALSE;
    };

    if ( ioctl(ttyfd, TCGETS, &ytm) ) {
        perror("ioctl(TCGETS:communication)");
        return FALSE;
    };

    /*
      fprintf(stderr, "ytm.c_iflag=0x%6x\n", ytm.c_iflag);
      fprintf(stderr, "ytm.c_oflag=0x%6x\n", ytm.c_oflag);
      fprintf(stderr, "ytm.c_cflag=0x%6x\n", ytm.c_cflag);
      fprintf(stderr, "ytm.c_lflag=0x%6x\n", ytm.c_lflag); */

    /* !!! Inserted here. Please use one of them as you like. */
    write(ttyfd,"\r\n",2);
    printf("Discarding data from '%s' ...",term);
    hog(ttyfd,1,0);
    printf(" Done.\n");

    return TRUE;
}


int hog(int ttyfd, int w, int print) /* GRA's function */
{
    fd_set r;
    struct timeval tv;
    char n[257];
    int len;
    while(1) {
        FD_ZERO(&r);  FD_SET(ttyfd,&r);  tv.tv_sec = w;  tv.tv_usec = 0;
        select(ttyfd+1,&r,NULL,NULL,&tv);
        if(!FD_ISSET(ttyfd,&r)) break;
        if((len = read(ttyfd,n,256))<=0) break;
        n[len] = '\0';
        if(print) fputs(n,stdout);
    }
    return 0;
}


int calcBaudChar(Uint baud)
{
    int retv;
  
    switch ( (int)baud ) {
    case 300:
        retv = B300;
        break;
    case 600:
        retv = B600;
        break;
    case 1200:
        retv = B1200;
        break;
    case 2400:
        retv = B2400;
        break;
    case 4800:
        retv = B4800;
        break;
    case 9600:
    default:
        retv = B9600;
        break;
    case 19200:
        retv = B19200;
        break;
    }
    return retv;
}