opencnvdriver.c

Go to the documentation of this file.

/*
NeuroServer
 
A collection of programs to translate between EEG data and TCP network
messages. This is a part of the OpenEEG project, see http://openeeg.sf.net
for details.
    
Copyright (C) 2003, 2004 Rudi Cilibrasi (cilibrar@ofb.net) 
     
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
         
This library 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
Lesser General Public License for more details.
             
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
*/
                


#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <nsnet.h>
#include <nsutil.h>
#include <nsser.h>
#include <openedf.h>
#include <config.h>
#define PROTOWINDOW 12

//#define DEBUGGING
char buf[PROTOWINDOW];
sock_t sock_fd;
int bufCount;
static int failCount = 0;
static struct OutputBuffer ob;
static struct InputBuffer ib;
int hasMatchedProtocol;
int isOpenCNV;
int isPseudoEDF;
int isValidPacket(unsigned short nchan, long *samples);
int doesMatchOpenCNV(unsigned char c, long *vals);
int mGetOK(sock_t fd, struct InputBuffer *ib);


int mGetOK(sock_t fd, struct InputBuffer *ib)
{
        return 0;
}

static struct EDFDecodedConfig openCNVCfg = {
                { 0,                            // size of header in bytes (to be set later)
                        -1,                     // data record count, -1 if unknown
                        3,                      // channels
                        "24bit",                // data format version number
                        "Mr. Default Patient",
                        "Ms. Default Recorder",
                        "date",
                        "time",
                        "24bit OpenCNV",        // manufactorer ID
                        2,                      // seconds per data record
                }, {
                                {
                                        1001,           
                                        -512, 512,      
                                        -8388608, 8388607,
                                        "electrode 0",  
                                        "Red Dot Ag/AgCl",  
                                        "uV",           
                                        "LP:100 Hz",    
                                        ""              
                                },
                                {
                                        1001,           
                                        -512, 512,      
                                        -8388608, 8388607,      
                                        "electrode 1",  
                                        "Red Dot Ag/AgCl",  
                                        "uV",           
                                        "LP:100 Hz",    
                                        ""              
                                },                                                              
                                        {
                                        1001,           
                                        0, 255,         
                                        0, 255,         
                                        "Stimulus State",       
                                        "----",  
                                        "State",                
                                        "none",         
                                        ""              
                                }                                                               
                                
                }
        };

static struct EDFDecodedConfig current;

int isValidPacket(unsigned short chan, long *samples)
{
//      int i;
//      if (chan != 2 && chan != 4 && chan !=5 && chan != 6) return 0;
//      for (i = 0; i < chan; i++) {
//              if (samples[i] > 16777216) return 0;
//      }
        return 1;
}



void eatCharacter(unsigned char c)
{
#define MINGOOD 6
        static int goodCount;
        long vals[MAXCHANNELS];  
        int didMatch = 0;
        //int ns=3;
        if (hasMatchedProtocol) {
           didMatch = doesMatchOpenCNV(c, vals);
         } 
         else {
           didMatch = doesMatchOpenCNV(c, vals); 
           if (didMatch) {
            if (goodCount > MINGOOD) {
             hasMatchedProtocol = 1;
//           isOpenCNV = 1;
            }
           }
         }
        if (didMatch) { 
                char *pstr = "xx";
//              if (isValidPacket(ns, vals)) {
//                      goodCount += 1;
//              }
//              else {
//                      rprintf("Warning: invalid serial packet ahead!\n");
//              }
                pstr = "OpenCNV";
//              failCount = 0;
//                printf("%c",c);       
#ifdef DEBUGGING1
                int i;  
                printf("Got %s packet with %d values: ", pstr, ns);
                for (i = 0; i < 3; ++i)
                 printf("%ld ", vals[i]);
                printf("\n");
#endif          
        }
        else {
                failCount += 1;
                if (failCount % PROTOWINDOW == 0) {
                        rprintf("Serial packet sync error -- missed window.\n");
                        goodCount = 0;
                }
        }
}


void handleSamples(int packetCounter, int chan, long *vals)
{
        char buf[MAXLEN];                                       
        int bufPos = 0;
  //long ChannelValue;
        int i;
#ifdef DEBUGGING        
        printf("Got good packet with counter %d, %d chan\n", packetCounter, chan);
#endif  
        chan=3;
        bufPos+=sprintf(buf, "! %d %d", packetCounter, chan);
        for (i = 0; i < 3; i++) {
          bufPos+=sprintf(buf+bufPos, " %ld",vals[i]); 
         }
        bufPos+=sprintf(buf+bufPos, "\r\n");
        writeString(sock_fd, buf, &ob);
        mGetOK(sock_fd, &ib);
}


int doesMatchOpenCNV(unsigned char c, long *vals)
{
        enum P2State { waitingA5, waiting5A, waitingCounter,
                waitingData };
        static int packetCounter = 0;
        static int chan = 0;
        static int i = 0;
        static enum P2State state = waitingA5;

        switch (state) {
                case waitingA5:
                        if (c == 0xa5) {
                                failCount = 0;
                                state = waiting5A;
                        }
                        else {
                                failCount += 1;
                                if (failCount % PROTOWINDOW == 0) {
                                        rprintf("Sync error, packet lost.\n");
                                        return 0;
                                }
                        }
                        break;

                case waiting5A:
                        if (c == 0x5a)
                                state = waitingCounter;
                        else
                                state = waitingA5;
                                return 0;
                        break;


                case waitingCounter:
                        packetCounter = c;
                        i = 0;          
                        state = waitingData;
        
                        break;

                case waitingData:
                        switch(i) {
                         case 0: vals[0] = 256*256*c;i++;break;                  
                         case 1: vals[0]+=256*c;i++;break;
                         case 2: vals[0]+=c;i++;vals[0]=vals[0]-8388608;break;
                         case 3: i++;break;                             
                         case 4: vals[1] = 256*256*c;i++;break;                  
                         case 5: vals[1]+=256*c;i++;break;
                         case 6: vals[1]+=c;vals[1]=vals[1]-8388608;i++;break;
                         case 7: i++;break;                             
                         case 8: vals[2]=c;                             
                                 i++;
                                 chan =  3; 
                                 handleSamples(packetCounter, chan , vals);
                                 state = waitingA5;break;
                          default:
                                rprintf("Error: problem during waiting Data state\n");
                                rexit(0);
                        }
                        break;
                default:
                                rprintf("Error: unknown state in OpenCNV protocol!\n");
                                rexit(0);
                }
        return 1;
}

void printHelp()
{
        rprintf("OpenCNV Driver interfaces the OpenCNV system to the NeuroServer TCP/IP protocol\n");
        rprintf("Usage: opencnvdriver [-d serialDeviceName] [-m} [hostname] [portno]\n");
        rprintf("The default options are opencnvdriver -d %s %s %d\n",
                        DEFAULTDEVICE, DEFAULTHOST, DEFAULTPORT);
        rprintf("The -m option splits 24bit ADC data into an offset part and regular part, \n");
        rprintf("this allows the standard 16bit EDF format to be used with higher dynamic range data.");
        
        
                        
}

void decodeCommand(char command[MAXLEN],ser_t serport) {
char writebuf[2];

 if ((command[0]=='g') && (command[1]=='o')) {
  writebuf[0]='T';
  writebuf[1]='1';
  writeSerial(serport,writebuf,2);
  }
 
 if ((command[0]=='n') && (command[1]=='o') && (command[2]=='g') && (command[3]=='o')) {
  writebuf[0]='T';
  writebuf[1]='3';
  writeSerial(serport,writebuf,2);
  }
  
  
 if ((command[0]=='2') && (command[1]=='0') && (command[2]=='0') ) {
//  rprintf("OK\n");
 }
 else {
  rprintf("not OK: %c %c %c \n",command[0],command[1],command[2]);
 }
}


int main(int argc, char **argv)
{
        char responseBuf[MAXLEN];
        int i;
        int retval;
        ser_t serport;
        char EDFPacket[MAXHEADERLEN];
        int EDFLen = MAXHEADERLEN;
        char smallbuf[PROTOWINDOW];
        char *hostname = NULL;
        char *deviceName = NULL;
        unsigned short portno = 0;
        struct timeval  when;
        
        char linebuf[MAXLEN+1]; // fifo command buffer
        int writepos = 0;        
        //int readpos = 0;
        int len;
        //unsigned int lpos = 0;
        
        rprintf("OpenCNV Driver v. %s-%s\n", VERSION, OSTYPESTR);

        rinitNetworking();
        
        isPseudoEDF=0;
        for (i = 1; argv[i]; ++i) {
                if (argv[i][0] == '-' && argv[i][1] == 'h') {
                        printHelp();
                        exit(0);
                }
                if (argv[i][0] == '-' && argv[i][1] == 'd') {
                        if (argv[i+1] == NULL) {
                                rprintf("Bad devicename option: %s\nExpected device name as next argument.\n", argv[i]);
                                exit(1);
                        }
                        deviceName = argv[i+1];
                        i += 1;
                        continue;
                }
                if (argv[i][0] == '-' && argv[i][1] == 'm') {
                        isPseudoEDF=1;
                        continue;

                }
                if (hostname == NULL) {
                        hostname = argv[i];
                        continue;
                }
                if (portno == 0) {
                        portno = atoi(argv[i]);
                        continue;
                }
        }
        if (deviceName == NULL)
                deviceName = DEFAULTDEVICE;
        if (portno == 0)
                portno = DEFAULTPORT;
        if (hostname == NULL)
                hostname = DEFAULTHOST;
        current=openCNVCfg;
        setEDFHeaderBytes(&current);
  strcpy(current.hdr.recordingStartDate, getDMY());
  strcpy(current.hdr.recordingStartTime, getHMS());
//        assert(isValidREDF(result));
//      makeREDFConfig(&current, &openCNVCfg);
//      write configuration into string 
        writeEDFString(&current, EDFPacket, &EDFLen);


        sock_fd = rsocket();
        if (sock_fd < 0) {
                perror("socket");
                rexit(1);
        }
        setblocking(sock_fd);

        rprintf("Attempting to connect to nsd at %s:%d\n", hostname, portno);
        retval = rconnectName(sock_fd, hostname, portno);
        if (retval != 0) {
                rprintf("connect error\n");
                rexit(1);
        }
        rprintf("Socket connected.\n");
        fflush(stdout);

        serport = openSerialPort(deviceName,115200);                    
        rprintf("Serial port %s opened.\n", deviceName);
        writeString(sock_fd, "eeg\n", &ob);     
        mGetOK(sock_fd, &ib);
        writeString(sock_fd, "setheader ", &ob);
        writeBytes(sock_fd, EDFPacket, EDFLen, &ob);
        writeString(sock_fd, "\n", &ob);
        mGetOK(sock_fd, &ib);
        updateMaxFd(sock_fd);
#ifndef __MINGW32__
        updateMaxFd(serport);
#endif
        when.tv_sec = 0;
        when.tv_usec = (int)(1000000 / openCNVCfg.chan[0].sampleCount * openCNVCfg.hdr.dataRecordSeconds);
        rprintf("Polling at %f Hertz or %i usec\n",(1e6/when.tv_usec), 
             when.tv_usec);
        for (;;) {
                int i, readSerBytes;
                int retval;
                fd_set toread;
                FD_ZERO(&toread);
                FD_SET(sock_fd, &toread);
#ifndef __MINGW32__
                FD_SET(serport, &toread);
#endif
                when.tv_usec = (int)(1000000 / openCNVCfg.chan[0].sampleCount * openCNVCfg.hdr.dataRecordSeconds);
                when.tv_sec = 0;
                retval = rselect_timed(max_fd, &toread, NULL, NULL, &when);
                readSerBytes = readSerial(serport, smallbuf, PROTOWINDOW);              // get one frame
// timeout + exit, if no serial data available
                if (readSerBytes < 0) {
                        rprintf("Serial error.\n");
                }
                if (readSerBytes > 0) {
                        for (i = 0; i < readSerBytes; ++i)
                                eatCharacter(smallbuf[i]);    
                }
                if ( (FD_ISSET(sock_fd, &toread)) && (ib.read_cnt<=0) ) {       // did we get any new network data ? yes !
                        my_read(sock_fd, responseBuf, MAXLEN, &ib); // get data into input buffer
                        len=0;
                        for (i=0;i<ib.read_cnt;i++) {
                         linebuf[writepos]=ib.read_buf[i];
                         if (linebuf[writepos]=='\n') {
                          decodeCommand(linebuf,serport);
                          writepos=0;
                          }
                         else {
                          writepos++;
                         }
                         if (writepos>=256) writepos=0;
                        }
                        ib.read_cnt=0;
                }
                

                if (isEOF(sock_fd, &ib)) {
                                        rprintf("Server died, exitting.\n");
                                        exit(0);
                }
                
        }

        return 0;
}

---