BOOL DisconnectNIA(void) {
UINT ui;
UINT ret;
UINT i;
write_logfile("Disconnecting NIA");
ret=GetRegisteredRawInputDevices(NULL,&ui,sizeof(RAWINPUTDEVICE)); // get size
if (ret<=sizeof(Rid)) // if okay, get structures
GetRegisteredRawInputDevices(Rid, &ui, sizeof(RAWINPUTDEVICE));
if(ret!=(UINT)-1){
for (i=0; i<ui; i++) {
Rid[i].dwFlags = RIDEV_REMOVE; // this should disable the HID device
Rid[i].hwndTarget = NULL ;
// RawInputDeviceList[i].hDevice = NULL;
if (RegisterRawInputDevices(Rid, 1, sizeof(RAWINPUTDEVICE)) == FALSE)
report_error("Could not close NIA");
}
}
ret=GetRegisteredRawInputDevices(Rid, &ui, sizeof(RAWINPUTDEVICE));
if (ret !=0)
write_logfile("Could not disconnect NIA");
return TRUE;
}
void write_spacelog(dbref executor, dbref object, const char *fmt)
{
switch (LOG_TYPE) {
case 1: write_logfile(executor, object, fmt); break;
case 2: write_logchannel(executor, object, fmt); break;
case 3: write_logfile(executor, object, fmt);
write_logchannel(executor, object, fmt);
break;
default: write_logfile(executor, object, fmt); break;
}
}
/**
* do_main - The main loop.
*
* @fd: Receiver socket's file descriptor.
*
* Returns nothing.
*/
static void do_main(const int fd)
{
static char buf[65536];
struct sockaddr_in addr;
while (1) {
struct pollfd pfd = { fd, POLLIN, 0 };
socklen_t size = sizeof(addr);
int i;
time_t now;
/* Don't wait forever if checking for timeout. */
for (i = 0; i < num_clients; i++)
if (clients[i].avail)
break;
/* Flush log file and wait for data. */
// fflush(log_fp);
poll(&pfd, 1, i < num_clients ? 1000 : -1);
now = time(NULL);
/* Check for timeout. */
for (i = 0; i < num_clients; i++)
if (clients[i].avail &&
now - clients[i].stamp >= wait_timeout)
write_logfile(&clients[i], 1);
/* Don't receive forever in order to check for timeout. */
while (now == time(NULL)) {
struct client *ptr;
char *tmp;
int len = recvfrom(fd, buf, sizeof(buf), MSG_DONTWAIT,
(struct sockaddr *) &addr, &size);
if (len <= 0 || size != sizeof(addr))
break;
ptr = find_client(&addr);
if (!ptr)
continue;
/* Save current time if receiving the first byte. */
if (!ptr->avail)
ptr->stamp = now;
/* Append data to the line. */
tmp = realloc(ptr->buffer, round_up(ptr->avail + len));
if (!tmp)
flush_all_and_abort();
memmove(tmp + ptr->avail, buf, len);
ptr->avail += len;
ptr->buffer = tmp;
/* Write if at least one line completed. */
if (memchr(buf, '\n', len))
write_logfile(ptr, 0);
/* Write if the line is too long. */
if (ptr->avail >= wbuf_size)
write_logfile(ptr, 1);
}
drop_memory_usage();
}
}
BOOL load_settings(void)
{
HANDLE hFile;
int t,x,c,f;
char settingsfilename[256],midipname[256],tempname[256];
strcpy(settingsfilename,GLOBAL.resourcepath);
strcat(settingsfilename,"brainbay.cfg");
write_logfile("load setting from: %s",settingsfilename);
hFile = CreateFile(settingsfilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if(hFile == INVALID_HANDLE_VALUE) return FALSE;
load_next_config_buffer(hFile);
load_property("samplingrate",P_INT,&PACKETSPERSECOND);
//load_property("com-port",P_INT,&TTY.PORT);
//load_property("baudrate",P_INT,&TTY.BAUDRATE);
//load_property("devicetype",P_INT,&TTY.devicetype);
load_property("dialoginterval",P_INT,&GLOBAL.dialog_interval);
load_property("drawinterval",P_INT,&GLOBAL.draw_interval);
load_property("startup",P_INT,&GLOBAL.startup);
load_property("autorun",P_INT,&GLOBAL.autorun);
load_property("configfile",P_STRING,GLOBAL.configfile);
load_property("use_cvcapture",P_INT,&GLOBAL.use_cv_capture);
load_property("midiports",P_INT,&x);
for (c=0;c<GLOBAL.midiports;c++) midiOutClose(MIDIPORTS[c].midiout);
for (t=1;t<=x;t++)
{
sprintf(midipname,"midiport%d",t);
load_property(midipname,P_STRING,tempname);
f=0;
for (c=0;c<GLOBAL.midiports;c++)
{
if (!strcmp(tempname,MIDIPORTS[c].portname))
{
write_logfile("open midi port: %s", tempname);
midi_open_port(&(MIDIPORTS[c].midiout),c);
f=1;
}
}
if (!f) {strcat (tempname," not found"); report_error (tempname); }
}
CloseHandle(hFile);
return(TRUE);
}
DWORD WINAPI ReaderProc(LPVOID lpv)
{
DWORD dwRead; // bytes actually read
DWORD dwBytesTransferred; // result from WaitForSingleObject
struct _COMSTAT status;
unsigned long etat;
//
while (!fThreadDone)
{
// Wait for an event to occur for the port.
// WaitCommEvent (TTY.COMDEV, &dwCommModemStatus, 0);
// Re-specify the set of events to be monitored for the port.
// SetCommMask (TTY.COMDEV, EV_RXCHAR | EV_CTS | EV_DSR | EV_RING);
if ((TTY.CONNECTED) && (!GLOBAL.loading))
{
dwBytesTransferred = 0;
if (ClearCommError(TTY.COMDEV, &etat, &status))
dwBytesTransferred = status.cbInQue;
if (dwBytesTransferred)
{
dwRead=0;
// Read the data from the serial port.
ReadFile (TTY.COMDEV, TTY.readBuf, dwBytesTransferred, &dwRead, 0);
// Display the data read.
if ((dwRead)&&(!TTY.read_pause)) ParseLocalInput((int)dwRead);
} else Sleep (1);
}
}
write_logfile("COMPORT closed");
return 1;
}
HANDLE create_captfile(LPCTSTR lpFName)
{
HANDLE hTemp;
DWORD dwWritten;
int t;
CAPTFILEHEADERStruct header;
if (TTY.devicetype>1)
{ report_error("Can only create ModuarEEG P2 or P3 Archive Files."); return(INVALID_HANDLE_VALUE); }
for(t=0;t<sizeof(header);t++) * (((char *)&header)+t) = ' ';
append_newline(header.description,sizeof(header.description));
write_logfile("create capture file: %s",(char *)lpFName);
hTemp=CreateFile(lpFName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0,NULL);
if (hTemp==INVALID_HANDLE_VALUE)
{ report_error("CreateFile"); return (INVALID_HANDLE_VALUE); }
strcpy(header.description, "BrainBay Archive File\r\n");
strcpy(header.filetype, captfiletypes[CAPTFILE.filetype]);
append_newline(header.filetype,sizeof(header.filetype));
strcpy(header.devicetype, devicetypes[TTY.devicetype]);
append_newline(header.devicetype,sizeof(header.devicetype));
if (!WriteFile(hTemp,&header,sizeof(header), &dwWritten, NULL)) report_error("Could not write to Archive");
CAPTFILE.start=TIMING.packetcounter;
CAPTFILE.file_action=FILE_WRITING;
GLOBAL.actcolumn=0;
return hTemp;
}
EMOTIVOBJ::EMOTIVOBJ(int num) : BASE_CL() //constructor
{
inports = 0;
outports = MAX_CHANNELS; //Emotiv Epoc Channels
/*outports are entiteled according to the international 10-20 location system*/
strcpy(out_ports[0].out_name, "AF3");
strcpy(out_ports[1].out_name, "F7");
strcpy(out_ports[2].out_name, "F3");
strcpy(out_ports[3].out_name, "FC5");
strcpy(out_ports[4].out_name, "T7");
strcpy(out_ports[5].out_name, "P7");
strcpy(out_ports[6].out_name, "O1");
strcpy(out_ports[7].out_name, "O2");
strcpy(out_ports[8].out_name, "P8");
strcpy(out_ports[9].out_name, "T8");
strcpy(out_ports[10].out_name, "FC6");
strcpy(out_ports[11].out_name, "F4");
strcpy(out_ports[12].out_name, "F8");
strcpy(out_ports[13].out_name, "AF4");
/* Init protocol driver library */
if ((drv_lib=InitEmotivEDKLib(GLOBAL.emotivpath))==NULL)
{
std::cout << "trying to load Emotiv EDK dlls from " << GLOBAL.emotivpath << "\n";
write_logfile("trying to load Emotiv EDK dlls from %s", GLOBAL.emotivpath);
report_error("could not load Emotiv EDK dlls\n Emotiv EPOC cannot be used. Please check Path to Emotiv SDK in Application Settings...");
}
filehandle = INVALID_HANDLE_VALUE;
filemode = 0;
gEMOTIV=this;
}
void NEUROBITOBJ::load_devctx(void)
{
char szFileName[256];
char *extension;
strcpy(szFileName,GLOBAL.configfile);
if (extension = strstr(szFileName, ".con"))
strcpy(extension,".nb");
else strcat(szFileName,".nb");
write_logfile("loading Neurobit device context from %s",szFileName);
GLOBAL.neurobit_available=0;
if (DevCtx>=0) NdCloseDevContext(DevCtx);
DevCtx=ReadCfgFile(szFileName);
if (DevCtx<0) {
report_error ("Could not load Neurobit Config File - using default configuration");
DevCtx=NdOpenDevContext(device);
}
strcpy(device,NdGetDevName());
GLOBAL.neurobit_available=1;
InvalidateRect(hDlg,NULL,FALSE);
update_channelinfo();
SetDlgItemText(hDlg,IDC_NB_DEVICECOMBO,device);
}
void GlobalCleanup()
{
int t;
stop_timer();
for (t=0;t<GLOBAL.objects;t++) objects[t]->session_stop();
while (GLOBAL.objects>0) free_object(0);
BreakDownCommPort();
// for (t=0;t<GLOBAL.objects;t++) free_object(0);
CloseHandle(TTY.ThreadExitEvent);
for (t=0;t<GLOBAL.midiports;t++)
if (MIDIPORTS[t].midiout) midiOutClose(MIDIPORTS[t].midiout);
if (CAPTFILE.filehandle!=0) CloseHandle(CAPTFILE.filehandle);
SDLNet_Quit();
SDL_Quit();
DeleteObject(DRAW.brush_blue);
DeleteObject(DRAW.pen_blue);
DeleteObject(DRAW.pen_white);
write_logfile("BrainBay normal shutdown.");
return;
}
HANDLE create_edf_file(EDFHEADERStruct * from, CHANNELStruct * fromchn, char * filename)
{
HANDLE temp;
char fname[256];
DWORD dwWritten;
EDFHEADER_PHYSICALStruct file_header;
char chnbuf[18000];
*filename=0;
strcpy(fname,GLOBAL.resourcepath);
strcat(fname,"ARCHIVES\\*.edf");
if (!open_file_dlg(ghWndMain,fname, FT_EDF, OPEN_SAVE)) return (INVALID_HANDLE_VALUE);
write_logfile("create edf file: %s",fname);
temp= CreateFile(fname, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
if (temp==INVALID_HANDLE_VALUE) return (temp);
edfheader_to_physical(from, &file_header);
edfchannels_to_physical(fromchn, chnbuf, from->channels);
WriteFile(temp,&file_header,256, &dwWritten,NULL);
if (dwWritten!=256) { CloseHandle(temp); return(INVALID_HANDLE_VALUE); }
WriteFile(temp,chnbuf,256*from->channels, &dwWritten,NULL);
if (dwWritten!=(DWORD)256*from->channels) { CloseHandle(temp); return(INVALID_HANDLE_VALUE); }
strcpy(filename,fname);
return(temp);
}
void NEUROBITOBJ::save_devctx(void)
{
char szFileName[256];
char *extension;
strcpy(szFileName,GLOBAL.configfile);
if (extension = strstr(szFileName, ".con"))
strcpy(extension,".nb");
else strcat(szFileName,".nb");
if (DevCtx>=0)
{
write_logfile("saving Neurobit device context to %s",szFileName);
if (!WriteCfgFile(DevCtx,szFileName))
report_error("Could not save Neurobit Config File");
} else write_logfile("ERROR: No Neurobit Device Context to save ");
}
/* Display message for an user */
void NdUserMsg(word dc, const char *msg)
{
char s[128];
int n;
n = sprintf(s, "(%i) ", dc);
strncpy(s+n, msg+(*msg=='!'), sizeof(s)-n);
s[sizeof(s)-1] = '\0';
if (*msg == '!') {
SetDlgItemText(ghWndStatusbox,IDC_STATUS, s);
write_logfile("Neurobit message: %s",s);
} else {
SetDlgItemText(ghWndStatusbox,IDC_STATUS, s);
write_logfile("Neurobit message: %s",s);
}
}
void NEUROBITOBJ::update_channelinfo(void)
{
NDGETVAL gv;
int chans,i;
float max_sr;
if (DevCtx<0) {
write_logfile ("could not open Neurobit device context");
return;
}
if (NdGetParam(ND_PAR_CHAN_NUM, 0, &gv) || (gv.type&~ND_T_LIST)!=ND_T_INT)
return;
max_sr=0;
chans = gv.val.i;
outports = chans;
strcpy(out_ports[0].out_dim,"uV");
chncol[0]=CI_GREEN;
for (i=1; i<5; i++) chncol[i]=CI_GRAY;
for (i=0; i<chans; i++) {
/* Update channel indicator field info */
if (!NdGetParam(ND_PAR_CH_LABEL, i, &gv)) {
strcpy( out_ports[i].out_name,gv.val.t);
}
if (!NdGetParam(ND_PAR_CH_RANGE_MAX, i, &gv)) {
out_ports[i].out_max = gv.val.f;
}
if (!NdGetParam(ND_PAR_CH_RANGE_MIN, i, &gv)) {
out_ports[i].out_min = gv.val.f;
}
if (!NdGetParam(ND_PAR_CH_SR, i, &gv)) {
if (gv.val.f>max_sr) max_sr=gv.val.f;
}
strcpy(out_ports[i].out_dim,NdParamInfo(ND_PAR_CH_RANGE_MAX, i)->unit);
/*
if (!NdGetParam(ND_PAR_CH_FUNC, i, &gv)) {
if (!strcmp(gv.val.t,"Voltage")) strcpy(out_ports[i].out_dim,"uV");
if (!strcmp(gv.val.t,"Temperature")) strcpy(out_ports[i].out_dim,"Deg");
if (!strcmp(gv.val.t,"Conductance")) strcpy(out_ports[i].out_dim,"uS");
if (!strcmp(gv.val.t,"Resistance")) strcpy(out_ports[i].out_dim,"kOhm");
}*/
if (!NdGetParam(ND_PAR_CH_EN, i, &gv)) {
if (gv.val.b) chncol[i+1]= CI_GREEN; else chncol[i+1]=CI_GRAY;
}
}
if (max_sr>0) update_samplingrate((int)max_sr);
dev_chans=0;
update_dimensions();
reset_oscilloscopes();
InvalidateRect(ghWndMain,NULL,TRUE);
InvalidateRect(ghWndDesign,NULL,TRUE);
if (ghWndToolbox == hDlg) InvalidateRect(ghWndToolbox,NULL,FALSE);
}
int midi_open_port(HMIDIOUT * midiout, int portnum)
{
if (midiout) midiOutClose(* midiout);
if (midiOutOpen(midiout,portnum-1,0,0,CALLBACK_NULL)==MMSYSERR_NOERROR)
return TRUE;
write_logfile("could not open midi port");
return FALSE;
}
/**
* flush_all_and_abort - Clean up upon out of memory.
*
* This function does not return.
*/
static void flush_all_and_abort(void)
{
int i;
for (i = 0; i < num_clients; i++)
if (clients[i].avail) {
write_logfile(&clients[i], 1);
free(clients[i].buffer);
fprintf(clients[i].log_fp, "[aborted due to memory allocation failure]\n");
fflush(clients[i].log_fp);
}
exit(1);
}
DWORD WINAPI WriterProc(LPVOID lpv)
{
DWORD dwWritten;
while (!fThreadDone)
{
if ((TTY.CONNECTED)&&(TTY.amount_to_write>0)&&(!TTY.writing))
{
WriteFile(TTY.COMDEV, TTY.writeBuf, TTY.amount_to_write, &dwWritten, 0);
TTY.amount_to_write=0;
} else Sleep (10);
}
write_logfile("COMPORT closed");
return 1;
}
/*-----------------------------------------------------------------------------
FUNCTION: WaitForThreads(DWORD)
PURPOSE: Waits a specified time for the worker threads to exit
PARAMETERS:
dwTimeout - milliseconds to wait until timeout
RETURN:
WAIT_OBJECT_0 - successful wait, threads are not running
WAIT_TIMEOUT - at least one thread is still running
WAIT_FAILED - failure in WaitForMultipleObjects
----------------------------------------------------------------------------*/
DWORD WaitForThreads(DWORD dwTimeout)
{
HANDLE hThreads[2];
DWORD dwRes;
hThreads[0] = TTY.READERTHREAD;
// hThreads[1] = TTY.WRITERTHREAD;
//
// set thread exit event here
//
SetEvent(TTY.ThreadExitEvent);
write_logfile("COMPORT waitforthreads");
dwRes = WaitForMultipleObjects(1, hThreads, TRUE, dwTimeout);
switch(dwRes)
{
case WAIT_OBJECT_0:
case WAIT_OBJECT_0 + 1:
dwRes = WAIT_OBJECT_0;
break;
case WAIT_TIMEOUT:
if (WaitForSingleObject(TTY.READERTHREAD, 0) == WAIT_TIMEOUT)
report_error("Reader Thread didn't exit");
// if (WaitForSingleObject(TTY.WRITERTHREAD, 0) == WAIT_TIMEOUT)
// report_error("Writer Thread didn't exit");
default:
report_error("WaitForTheads: unknown exit error");
break;
}
//
// reset thread exit event here
//
ResetEvent(TTY.ThreadExitEvent);
return dwRes;
}
void open_captfile(LPCTSTR lpFName)
{
DWORD dwRead;
CAPTFILEHEADERStruct header;
CAPTFILE.offset=0;
write_logfile("create capture file: %s: ", (char *)lpFName);
CAPTFILE.filehandle = CreateFile(lpFName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (CAPTFILE.filehandle!=INVALID_HANDLE_VALUE)
{
if(!ReadFile(CAPTFILE.filehandle, &header , sizeof(header), &dwRead, NULL))
{
report_error("Could not read from Archive File");
CAPTFILE.filehandle=INVALID_HANDLE_VALUE;
return;
}
if (strstr(header.description,"BrainBay Archive File")!=NULL)
{
if (!strcmp(header.filetype, captfiletypes[FILE_TEXTMODE])) CAPTFILE.filetype=FILE_TEXTMODE;
if (!strcmp(header.filetype, captfiletypes[FILE_INTMODE])) CAPTFILE.filetype=FILE_INTMODE;
if (!strcmp(header.devicetype, devicetypes[DEV_MODEEG_P2])) TTY.devicetype=DEV_MODEEG_P2;
if (!strcmp(header.devicetype, devicetypes[DEV_MODEEG_P3])) TTY.devicetype=DEV_MODEEG_P3;
}
else
{
// TTY.devicetype=DEV_RAW;
CAPTFILE.filetype=FILE_INTMODE;
}
update_devicetype();
CAPTFILE.file_action=FILE_READING;
}
else
{
strcat(CAPTFILE.filename,": Archive not found.");
report(CAPTFILE.filename);
strcpy(CAPTFILE.filename,"none");
}
get_session_length();
}
DWORD WINAPI WriterProc(LPVOID lpv)
{
DWORD dwWritten;
while (!fThreadDone)
{
if ((TTY.CONNECTED)&&(TTY.amount_to_write>0))
{
if ( WaitForSingleObject( TTY.writeMutex, INFINITE ) == WAIT_OBJECT_0 )
{
WriteFile(TTY.COMDEV, TTY.writeBuf, TTY.amount_to_write, &dwWritten, 0);
TTY.amount_to_write=0;
ReleaseMutex( TTY.writeMutex );
}
} else Sleep (10);
}
write_logfile("COMPORT closed");
return 1;
}
void write_logchannel(dbref executor, dbref object, const char *fmt)
{
CHAN *c;
struct tm *ttm;
char timebuf[18];
char unp1[BUFFER_LEN], unp2[BUFFER_LEN];
c = NULL;
ttm = localtime(&mudtime);
strftime(timebuf, sizeof timebuf, "[%m/%d %H:%M:%S]", ttm);
strcpy(unp1, quick_space_unparse(executor));
strcpy(unp2, quick_space_unparse(object));
if (find_channel(LOG_CHANNEL, &c, GOD) == CMATCH_NONE) {
write_logfile(executor, object, fmt);
} else {
do_cemit(GOD, LOG_CHANNEL, tprintf("%s SPACE: %s %s %s", timebuf, unp1, unp2, fmt), 0);
}
}
BOOL save_settings(void)
{
HANDLE hFile;
int t,x;
char settingsfilename[256],midipname[256];
strcpy(settingsfilename,GLOBAL.resourcepath);
strcat(settingsfilename,"brainbay.cfg");
write_logfile("saving program settings.");
hFile = CreateFile(settingsfilename, GENERIC_WRITE, 0, NULL,CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile == INVALID_HANDLE_VALUE) return FALSE;
save_property(hFile,"samplingrate",P_INT,&PACKETSPERSECOND);
//save_property(hFile,"com-port",P_INT,&TTY.PORT);
//save_property(hFile,"baudrate",P_INT,&TTY.BAUDRATE);
//save_property(hFile,"devicetype",P_INT,&TTY.devicetype);
save_property(hFile,"dialoginterval",P_INT,&GLOBAL.dialog_interval);
save_property(hFile,"drawinterval",P_INT,&GLOBAL.draw_interval);
save_property(hFile,"startup",P_INT,&GLOBAL.startup);
save_property(hFile,"autorun",P_INT,&GLOBAL.autorun);
save_property(hFile,"configfile",P_STRING,GLOBAL.configfile);
save_property(hFile,"use_cvcapture",P_INT,&GLOBAL.use_cv_capture);
x=0;
for (t=0;t<GLOBAL.midiports;t++)
if (MIDIPORTS[t].midiout)
{
x++;
sprintf(midipname,"midiport%d",x);
save_property(hFile,midipname,P_STRING,MIDIPORTS[t].portname);
}
save_property(hFile,"midiports",P_INT,&x);
CloseHandle(hFile);
return(TRUE);
}
HANDLE open_edf_file(EDFHEADERStruct * to, CHANNELStruct * tochn, char * filename)
{
char readbuf[8192];
int t,channels;
HANDLE temp;
char fname[256],szdata[300];
DWORD dwRead;
if (!(filename[0]))
{
strcpy(fname,GLOBAL.resourcepath);
strcat(fname,"ARCHIVES\\*.edf");
if (!open_file_dlg(ghWndMain,fname, FT_EDF, OPEN_LOAD)) return (INVALID_HANDLE_VALUE);
}
else strcpy(fname,filename);
write_logfile("open edf file: %s",fname);
temp= CreateFile(fname, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (temp==INVALID_HANDLE_VALUE) return (temp);
ReadFile(temp,readbuf,256, &dwRead,NULL);
if (dwRead!=256) { CloseHandle(temp); return(INVALID_HANDLE_VALUE); }
copy_string(readbuf,252,256,szdata);
sscanf(szdata,"%d",&channels);
for (t=0;t<channels;t++)
{
ReadFile(temp,readbuf+256+256*t,256, &dwRead,NULL);
if (dwRead!=256) { CloseHandle(temp); return(INVALID_HANDLE_VALUE); }
}
parse_edf_header(to, tochn, readbuf);
//if (filename)
strcpy(filename,fname);
return(temp);
}
static void _log_write(const char *pfx, const char *msg)
{
char buf[1024];
char tbuf[64];
int len;
int old_errno = errno;
render_time(tbuf, sizeof(tbuf));
len = snprintf(buf, sizeof(buf), "%s %u %s %s\n",
tbuf, (unsigned)getpid(), pfx, msg);
if (cf_logfile[0])
write_logfile(buf, len);
if (cf_syslog)
write_syslog(pfx, msg);
if (!cf_quiet)
fprintf(stderr, "%s", buf);
if (old_errno != errno)
errno = old_errno;
}
/*-----------------------------------------------------------------------------
FUNCTION: SetupCommPort( int Port )
PURPOSE: Setup Communication Port with our settings
-----------------------------------------------------------------------------*/
BOOL SetupCommPort(int port)
{
DWORD dwReadStatId;
DWORD dwWriteStatId;
int sav_port,sav_pause;
DCB dcb = {0};
char PORTNAME[10];
if (!port) return(false);
sav_port=TTY.PORT;
sav_pause=TTY.read_pause;
TTY.read_pause=1;
BreakDownCommPort();
TTY.PORT = port ;
// set tty structure for the specified port
sprintf(PORTNAME,"\\\\.\\COM%d",port);
PACKET.readstate=0;
PACKET.number=0;
PACKET.old_number=0;
PACKET.info=0;
// open communication port handle
// TTY.COMDEV = CreateFile( PORTNAME,GENERIC_READ | GENERIC_WRITE,
// 0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,0);
TTY.COMDEV = CreateFile( PORTNAME,GENERIC_READ | GENERIC_WRITE,
0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
if (TTY.COMDEV == INVALID_HANDLE_VALUE) goto failed;
if (!GetCommState(TTY.COMDEV, &dcb)) // get current DCB settings
{ report_error("GetCommState");goto failed; }
// update DCB rate, byte size, parity, and stop bits size
dcb.DCBlength = sizeof(dcb);
dcb.BaudRate = TTY.BAUDRATE;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
dcb.EvtChar = '\0';
// update flow control settings
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
if (TTY.FLOW_CONTROL)
{
dcb.fOutxCtsFlow = TRUE;
dcb.fOutxDsrFlow = TRUE;
}
else
{
dcb.fOutxCtsFlow = FALSE;
dcb.fOutxDsrFlow = FALSE;
}
dcb.fDsrSensitivity = FALSE;;
dcb.fOutX = FALSE;
dcb.fInX = FALSE;
dcb.fTXContinueOnXoff = FALSE;
dcb.XonChar = 0;
dcb.XoffChar = 0;
dcb.XonLim = 0;
dcb.XoffLim = 0;
dcb.fParity = FALSE; //TRUE;
if (!SetCommState(TTY.COMDEV, &dcb)) // set new state
{ report_error("SetCommState failed"); goto failed;}
// set comm buffer sizes
if (!SetupComm(TTY.COMDEV, 1024, 1024))
{ report_error("SetupComm failed");goto failed;}
if (!EscapeCommFunction(TTY.COMDEV, SETDTR)) // raise DTR
{ report_error("EscapeCommFunction failed");goto failed;}
SetCommMask (TTY.COMDEV, EV_RXCHAR | EV_CTS | EV_DSR | EV_RLSD | EV_RING);
// start the reader and writer threads
fThreadDone = FALSE;
TTY.READERTHREAD =
CreateThread( NULL, 1000, (LPTHREAD_START_ROUTINE) ReaderProc, 0, 0, &dwReadStatId);
if (TTY.READERTHREAD == NULL)
{ report_error("CreateThread failed"); goto failed;}
TTY.WRITERTHREAD =
CreateThread( NULL, 1000, (LPTHREAD_START_ROUTINE) WriterProc, 0, 0, &dwWriteStatId);
if (TTY.WRITERTHREAD == NULL)
{ report_error("CreateWriterThread failed"); goto failed;}
write_logfile("COMPORT opened: %s", PORTNAME);
TTY.amount_to_write=0;
TTY.read_pause=sav_pause;
return TRUE;
failed:
{
char sztemp[100];
write_logfile("COMPORT open failed");
sprintf(sztemp, "The Port COM%d is not available. Please select another Com-Port.",TTY.PORT);
report_error(sztemp);
TTY.read_pause=sav_pause;
TTY.PORT=sav_port;
TTY.COMDEV=INVALID_HANDLE_VALUE;
TTY.CONNECTED=FALSE;
TTY.amount_to_write=0;
return FALSE;
}
}
int check_OS(void)
{
OSVERSIONINFOEX InfoStruct;
int bOSVERSIONINFOEX;
string temp="";
int osid=0;
write_logfile ("checking OS version");
ZeroMemory(&InfoStruct,sizeof(OSVERSIONINFOEX));
InfoStruct.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if(!(bOSVERSIONINFOEX = GetVersionEx((OSVERSIONINFO*)&InfoStruct)))
{
InfoStruct.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if(!GetVersionEx((OSVERSIONINFO*)&InfoStruct))
return -1;
}
if(InfoStruct.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
{
if(InfoStruct.dwMajorVersion == 4 && InfoStruct.dwMinorVersion == 0)
{
temp += "Windows 95 ";
if(InfoStruct.szCSDVersion[1] == 'C' || InfoStruct.szCSDVersion[1] == 'A')
temp += "OSR2";
}
else if(InfoStruct.dwMajorVersion == 4 && InfoStruct.dwMinorVersion == 10)
{
temp += "Windows 98 ";
if(InfoStruct.szCSDVersion[1] == 'A')
temp += "SE";
}
else if(InfoStruct.dwMajorVersion == 4 && InfoStruct.dwMinorVersion == 90)
{
temp += "Windows Me";
}
}
else if(InfoStruct.dwPlatformId == VER_PLATFORM_WIN32s)
{
temp += "Microsoft Win32s";
}
else if(InfoStruct.dwPlatformId == VER_PLATFORM_WIN32_NT)
{
if(InfoStruct.dwMajorVersion == 5 && InfoStruct.dwMinorVersion == 2)
temp += "Windows Server 2003 family";
else if(InfoStruct.dwMajorVersion == 5 && InfoStruct.dwMinorVersion == 1)
temp += "Windows XP ";
else if(InfoStruct.dwMajorVersion == 5 && InfoStruct.dwMinorVersion == 0)
temp += "Windows 2000 ";
else if(InfoStruct.dwMajorVersion <= 4)
temp += "Windows NT ";
else if(InfoStruct.dwMajorVersion == 6)
{
if( InfoStruct.dwMinorVersion == 0 )
{
if( InfoStruct.wProductType == VER_NT_WORKSTATION )
temp +="Windows Vista ";
else temp +="Windows Server 2008 ";
}
if ( InfoStruct.dwMinorVersion == 1 )
{
if( InfoStruct.wProductType == VER_NT_WORKSTATION )
{ temp += "Windows 7 "; osid=1; }
else temp +="Windows Server 2008 R2 ";
}
}
if(bOSVERSIONINFOEX)
{
if(InfoStruct.wProductType == VER_NT_WORKSTATION)
{
if(InfoStruct.dwMajorVersion == 4)
temp += "Workstation 4.0 ";
else if(InfoStruct.wSuiteMask & VER_SUITE_PERSONAL)
temp += "Home Edition ";
else temp += "Professional ";
}
}
else if(InfoStruct.wProductType == VER_NT_SERVER)
{
if(InfoStruct.dwMajorVersion == 5 && InfoStruct.dwMinorVersion == 2)
{
if(InfoStruct.wSuiteMask & VER_SUITE_DATACENTER)
temp += "Datacenter Edition ";
else if(InfoStruct.wSuiteMask & VER_SUITE_ENTERPRISE)
temp += "Enterprise Edition ";
else if(InfoStruct.wSuiteMask & VER_SUITE_BLADE)
temp += "Web Edition";
else
temp += "stan**** Edition ";
}
else if(InfoStruct.dwMajorVersion == 5 && InfoStruct.dwMinorVersion == 0)
{
if(InfoStruct.wSuiteMask & VER_SUITE_DATACENTER)
temp += "Datacenter Server ";
else if(InfoStruct.wSuiteMask & VER_SUITE_ENTERPRISE)
temp += "Advanced Server ";
else
temp += "Server ";
}
else
{
if(InfoStruct.wSuiteMask & VER_SUITE_ENTERPRISE)
temp += "Server 4.0, Enterprise Edition ";
else
temp += "Server 4.0 ";
}
}
}
write_logfile ("OS version: %s",(char *)temp.data());
return osid;
}
BOOL save_configfile(LPCTSTR pszFileName)
{
HANDLE hFile;
int t;
int act_type;
write_logfile("saving design configuration: %s",(char *)pszFileName);
hFile = CreateFile(pszFileName, GENERIC_WRITE, 0, NULL,CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
if (!IsWindow(ghWndToolbox))
GLOBAL.showtoolbox=-1;
strcpy(GLOBAL.configfile,pszFileName);
save_settings();
save_property(hFile,"objects",P_INT,&GLOBAL.objects);
save_property(hFile,"main-top",P_INT,&GLOBAL.top);
save_property(hFile,"main-left",P_INT,&GLOBAL.left);
save_property(hFile,"main-right",P_INT,&GLOBAL.right);
save_property(hFile,"main-bottom",P_INT,&GLOBAL.bottom);
save_property(hFile,"anim-top",P_INT,&GLOBAL.anim_top);
save_property(hFile,"anim-left",P_INT,&GLOBAL.anim_left);
save_property(hFile,"anim-right",P_INT,&GLOBAL.anim_right);
save_property(hFile,"anim-bottom",P_INT,&GLOBAL.anim_bottom);
save_property(hFile,"design-top",P_INT,&GLOBAL.design_top);
save_property(hFile,"design-left",P_INT,&GLOBAL.design_left);
save_property(hFile,"design-right",P_INT,&GLOBAL.design_right);
save_property(hFile,"design-bottom",P_INT,&GLOBAL.design_bottom);
save_property(hFile,"tool-top",P_INT,&GLOBAL.tool_top);
save_property(hFile,"tool-left",P_INT,&GLOBAL.tool_left);
save_property(hFile,"tool-right",P_INT,&GLOBAL.tool_right);
save_property(hFile,"tool-bottom",P_INT,&GLOBAL.tool_bottom);
save_property(hFile,"showdesign",P_INT,&GLOBAL.showdesign);
save_property(hFile,"showtoolbox",P_INT,&GLOBAL.showtoolbox);
save_property(hFile,"autorun",P_INT,&GLOBAL.autorun);
save_property(hFile,"minimized",P_INT,&GLOBAL.minimized);
save_property(hFile,"comport",P_INT,&TTY.PORT);
save_property(hFile,"bidirect",P_INT,&TTY.BIDIRECT);
save_property(hFile,"connected",P_INT,&TTY.CONNECTED);
save_property(hFile,"devicetype",P_INT,&TTY.devicetype);
save_property(hFile,"samplingtype",P_INT,&TTY.samplingrate);
save_property(hFile,"baudtype",P_INT,&TTY.BAUDRATE);
save_property(hFile,"flow_control",P_INT,&TTY.FLOW_CONTROL);
save_property(hFile,"captfilename",P_STRING,CAPTFILE.filename);
save_property(hFile,"captfiletype",P_INT,&CAPTFILE.filetype);
save_property(hFile,"captfileoffset",P_INT,&CAPTFILE.offset);
save_property(hFile,"dialoginterval",P_INT,&GLOBAL.dialog_interval);
save_property(hFile,"drawinterval",P_INT,&GLOBAL.draw_interval);
save_property(hFile,"samplingrate",P_INT,&PACKETSPERSECOND);
save_property(hFile,"end Object",P_END,NULL);
for (t=0;t<GLOBAL.objects;t++)
{ act_type=objects[t]->type;
save_property(hFile,"next Object",P_INT,&act_type);
objects[t]->save(hFile);
store_links(hFile,objects[t]);
save_property(hFile,"end Object",P_END,NULL);
}
CloseHandle(hFile);
return TRUE;
}
return FALSE;
}
BOOL load_configfile(LPCTSTR pszFileName)
{
HANDLE hFile;
int t, act_samplingrate=DEF_PACKETSPERSECOND;
int act_type,num_objects, save_toolbox, save_connected, try_connect;
const char * d_name;
char new_name[256],szdata[20];
write_logfile("loading design configuration: %s",(char *)pszFileName);
hFile = CreateFile(pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
GLOBAL.loading=1;
d_name=pszFileName;
while (strstr(d_name,"\\")) d_name=strstr(d_name,"\\")+1;
strcpy(new_name,"BrainBay - ");strcat(new_name,d_name);
SetWindowText(ghWndMain,new_name);
strcpy(GLOBAL.configfile,pszFileName);
save_settings();
save_toolbox=-1;
save_connected=TTY.CONNECTED;
SendMessage(ghWndStatusbox,WM_COMMAND, IDC_STOPSESSION,0);
//TTY.read_pause=1;
close_captfile();
if (ghWndAnimation!=NULL) SendMessage(ghWndAnimation,WM_CLOSE,0,0);
ghWndAnimation=NULL;
close_toolbox();actobject=NULL;
//InvalidateRect(ghWndMain, NULL, TRUE);
while (GLOBAL.objects>0)
free_object(0);
GLOBAL.run_exception=0;
GLOBAL.minimized=FALSE;
load_next_config_buffer(hFile);
load_property("objects",P_INT,&GLOBAL.objects);
load_property("main-top",P_INT,&GLOBAL.top);
load_property("main-left",P_INT,&GLOBAL.left);
load_property("main-right",P_INT,&GLOBAL.right);
load_property("main-bottom",P_INT,&GLOBAL.bottom);
load_property("anim-top",P_INT,&GLOBAL.anim_top);
load_property("anim-left",P_INT,&GLOBAL.anim_left);
load_property("anim-right",P_INT,&GLOBAL.anim_right);
load_property("anim-bottom",P_INT,&GLOBAL.anim_bottom);
load_property("design-top",P_INT,&GLOBAL.design_top);
load_property("design-left",P_INT,&GLOBAL.design_left);
load_property("design-right",P_INT,&GLOBAL.design_right);
load_property("design-bottom",P_INT,&GLOBAL.design_bottom);
load_property("tool-top",P_INT,&GLOBAL.tool_top);
load_property("tool-left",P_INT,&GLOBAL.tool_left);
load_property("tool-right",P_INT,&GLOBAL.tool_right);
load_property("tool-bottom",P_INT,&GLOBAL.tool_bottom);
load_property("showdesign",P_INT,&GLOBAL.showdesign);
load_property("hidestatus",P_INT,&GLOBAL.hidestatus);
load_property("showtoolbox",P_INT,&GLOBAL.showtoolbox);
load_property("autorun",P_INT,&GLOBAL.autorun);
load_property("minimized",P_INT,&GLOBAL.minimized);
save_toolbox=GLOBAL.showtoolbox;
TTY.PORT=0;try_connect=0;
load_property("comport",P_INT,&TTY.PORT);
load_property("connected",P_INT,&try_connect);
load_property("bidirect",P_INT,&TTY.BIDIRECT);
load_property("devicetype",P_INT,&TTY.devicetype);
load_property("samplingtype",P_INT,&TTY.samplingrate);
load_property("baudtype",P_INT,&TTY.BAUDRATE);
load_property("flow_control",P_INT,&TTY.FLOW_CONTROL);
if (save_connected) { update_p21state(); save_connected=TTY.CONNECTED; }
BreakDownCommPort();
if (try_connect) { TTY.CONNECTED=SetupCommPort(TTY.PORT); update_p21state(); }
load_property("captfilename",P_STRING,CAPTFILE.filename);
load_property("captfiletype",P_INT,&CAPTFILE.filetype);
load_property("captfileoffset",P_INT,&CAPTFILE.offset);
load_property("dialoginterval",P_INT,&GLOBAL.dialog_interval);
load_property("drawinterval",P_INT,&GLOBAL.draw_interval);
load_property("samplingrate",P_INT,&act_samplingrate);
PACKETSPERSECOND=act_samplingrate;
MoveWindow(ghWndMain,GLOBAL.left,GLOBAL.top,GLOBAL.right-GLOBAL.left,GLOBAL.bottom-GLOBAL.top,TRUE);
MoveWindow(ghWndDesign,GLOBAL.design_left,GLOBAL.design_top,GLOBAL.design_right-GLOBAL.design_left,GLOBAL.design_bottom-GLOBAL.design_top,TRUE);
if (!GLOBAL.showdesign)
{
ShowWindow(ghWndDesign, FALSE);
SetDlgItemText(ghWndStatusbox,IDC_DESIGN,"Show Design");
}
else
{
ShowWindow(ghWndDesign,TRUE);
SetWindowPos(ghWndDesign,0,0,0,0,0,SWP_DRAWFRAME|SWP_NOMOVE|SWP_NOSIZE);
SetDlgItemText(ghWndStatusbox,IDC_DESIGN,"Hide Design");
}
if (!GLOBAL.hidestatus)
ShowWindow(ghWndStatusbox, TRUE);
else ShowWindow(ghWndStatusbox,FALSE);
num_objects=GLOBAL.objects;
GLOBAL.objects=0;
for (t=0;t<num_objects;t++)
{
act_type=load_next_config_buffer(hFile);
if (act_type>=0)
{
create_object(act_type);
if (actobject != NULL )
{
actobject->load(hFile);
link_object(actobject);
}
else critical_error("Could not load all objects, quitting ...\ndelete brainbay.cfg to prevent this at program startup ... ");
}
}
CloseHandle(hFile);
for (t=0;t<num_objects;t++) objects[t]->update_inports();
update_dimensions();
CAPTFILE.filehandle=INVALID_HANDLE_VALUE;
CAPTFILE.do_read=0;
if (strcmp(CAPTFILE.filename,"none"))
{
char st[150];
reduce_filepath(st,CAPTFILE.filename);
strcpy(CAPTFILE.filename,GLOBAL.resourcepath);
strcat(CAPTFILE.filename,"ARCHIVES\\");
strcat(CAPTFILE.filename,st);
open_captfile(CAPTFILE.filename);
}
init_system_time();
reset_oscilloscopes();
PACKET.readstate=0;
ShowWindow( ghWndMain, TRUE ); UpdateWindow( ghWndMain );
update_samplingrate(act_samplingrate);
update_devicetype();
get_session_length();
SetDlgItemInt(ghWndStatusbox,IDC_SAMPLINGRATE,act_samplingrate,0);
SetDlgItemText(ghWndStatusbox,IDC_STATUS,"Configuration loaded");
SetDlgItemText(ghWndStatusbox,IDC_TIME,"0.0");
SetDlgItemText(ghWndStatusbox,IDC_JUMPPOS,"0.0");
sprintf(szdata, "%.1f", (float)GLOBAL.session_length/(float)PACKETSPERSECOND);
SetDlgItemText(ghWndStatusbox,IDC_SESSLEN,szdata);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETPOS,TRUE,(LONG)0);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELEND,TRUE,(LONG)0);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELSTART,TRUE,(LONG)0);
SetWindowPos(ghWndMain,0,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
InvalidateRect(ghWndMain,NULL,TRUE);
InvalidateRect(ghWndDesign,NULL,TRUE);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELSTART,TRUE,0);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELEND,TRUE,1000);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETPOS,TRUE,(LONG)(0));
if (GLOBAL.minimized) ShowWindow(ghWndMain, SW_MINIMIZE);
GLOBAL.loading=0;
if ((GLOBAL.autorun) && (!GLOBAL.run_exception)) SendMessage(ghWndStatusbox,WM_COMMAND, IDC_RUNSESSION,0);
if (save_toolbox!=-1)
{
GLOBAL.showtoolbox=save_toolbox;
actobject=objects[GLOBAL.showtoolbox];
actobject->make_dialog();
}
write_logfile("load successful");
return TRUE;
}
write_logfile("could not load design configuration file.");
return FALSE;
}
void create_object(int type)
{
int i;
close_toolbox();
write_logfile("creating object: %s",objnames[type]);
switch(type)
{
case OB_EEG: actobject=new EEGOBJ(GLOBAL.objects);
deviceobject=actobject;
actobject->object_size=sizeof(EEGOBJ);break;
case OB_MIDI: actobject=new MIDIOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MIDIOBJ);break;
case OB_OSCI: actobject=new OSCIOBJ(GLOBAL.objects);
actobject->object_size=sizeof(OSCIOBJ);break;
case OB_FFT: actobject=new FFTOBJ(GLOBAL.objects);
actobject->object_size=sizeof(FFTOBJ);break;
case OB_THRESHOLD: actobject=new THRESHOLDOBJ(GLOBAL.objects);
actobject->object_size=sizeof(THRESHOLDOBJ);break;
case OB_FILTER: actobject=new FILTEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(FILTEROBJ);break;
case OB_MAGNITUDE: actobject=new MAGNITUDEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MAGNITUDEOBJ);break;
case OB_PARTICLE: actobject=new PARTICLEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(PARTICLEOBJ);break;
case OB_TRANSLATE: actobject=new TRANSLATEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(TRANSLATEOBJ);break;
case OB_SIGNAL: actobject=new SIGNALOBJ(GLOBAL.objects);
actobject->object_size=sizeof(SIGNALOBJ);break;
case OB_AND: actobject=new ANDOBJ(GLOBAL.objects);
actobject->object_size=sizeof(ANDOBJ);break;
case OB_OR: actobject=new OROBJ(GLOBAL.objects);
actobject->object_size=sizeof(OROBJ);break;
case OB_NOT: actobject=new NOTOBJ(GLOBAL.objects);
actobject->object_size=sizeof(NOTOBJ);break;
case OB_WAV: actobject=new WAVOBJ(GLOBAL.objects);
actobject->object_size=sizeof(WAVOBJ);break;
case OB_TCP_RECEIVER:actobject=new TCP_RECEIVEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(TCP_RECEIVEOBJ);break;
case OB_DOKU: actobject=new DOKUOBJ(GLOBAL.objects);
actobject->object_size=sizeof(DOKUOBJ);break;
case OB_EVAL: actobject=new EVALOBJ(GLOBAL.objects);
actobject->object_size=sizeof(EVALOBJ);break;
case OB_AVI: actobject=new AVIOBJ(GLOBAL.objects);
actobject->object_size=sizeof(AVIOBJ);break;
case OB_AVERAGE: actobject=new AVERAGEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(AVERAGEOBJ);break;
case OB_CORR: actobject=new CORRELATIONOBJ(GLOBAL.objects);
actobject->object_size=sizeof(CORRELATIONOBJ);break;
case OB_EDF_READER: actobject=new EDF_READEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(EDF_READEROBJ);break;
case OB_EDF_WRITER: actobject=new EDF_WRITEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(EDF_WRITEROBJ);break;
case OB_TCP_SENDER: actobject=new TCP_SENDEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(TCP_SENDEROBJ);break;
case OB_COMPARE: actobject=new COMPAREOBJ(GLOBAL.objects);
actobject->object_size=sizeof(COMPAREOBJ);break;
case OB_BALLGAME: actobject=new BALLGAMEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(BALLGAMEOBJ);break;
case OB_MIXER4: actobject=new MIXER4OBJ(GLOBAL.objects);
actobject->object_size=sizeof(MIXER4OBJ);break;
case OB_MOUSE: actobject=new MOUSEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MOUSEOBJ);break;
case OB_ERPDETECT: actobject=new ERPDETECTOBJ(GLOBAL.objects);
actobject->object_size=sizeof(ERPDETECTOBJ);break;
case OB_COM_WRITER: actobject=new COM_WRITEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(COM_WRITEROBJ);break;
case OB_CAM: actobject=new CAMOBJ(GLOBAL.objects);
actobject->object_size=sizeof(CAMOBJ);break;
case OB_INTEGRATE: actobject=new INTEGRATEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(INTEGRATEOBJ);break;
case OB_DEBOUNCE: actobject=new DEBOUNCEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(DEBOUNCEOBJ);break;
case OB_SAMPLE_HOLD: actobject=new SAMPLE_HOLDOBJ(GLOBAL.objects);
actobject->object_size=sizeof(SAMPLE_HOLDOBJ);break;
case OB_CONSTANT: actobject=new CONSTANTOBJ(GLOBAL.objects);
actobject->object_size=sizeof(CONSTANTOBJ);break;
case OB_MATLAB: actobject=new MATLABOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MATLABOBJ);break;
case OB_COUNTER: actobject=new COUNTEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(COUNTEROBJ);break;
#ifndef MINGW
case OB_SKINDIALOG: actobject=new SKINDIALOGOBJ(GLOBAL.objects);
actobject->object_size=sizeof(SKINDIALOGOBJ);break;
#endif
case OB_FILE_WRITER: actobject=new FILE_WRITEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(FILE_WRITEROBJ);break;
case OB_DEVIATION: actobject=new DEVIATIONOBJ(GLOBAL.objects);
actobject->object_size=sizeof(DEVIATIONOBJ);break;
case OB_MCIPLAYER: actobject=new MCIOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MCIOBJ);break;
case OB_KEYSTRIKE: actobject=new KEYSTRIKEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(KEYSTRIKEOBJ);break;
case OB_PEAKDETECT: actobject=new PEAKDETECTOBJ(GLOBAL.objects);
actobject->object_size=sizeof(PEAKDETECTOBJ);break;
case OB_SPELLER: actobject=new SPELLEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(SPELLEROBJ);break;
case OB_MARTINI: actobject=new MARTINIOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MARTINIOBJ);break;
case OB_FILE_READER: actobject=new FILE_READEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(FILE_READEROBJ);break;
case OB_PORT_IO: actobject=new PORTOBJ(GLOBAL.objects);
actobject->object_size=sizeof(PORTOBJ);break;
case OB_ARRAY3600: actobject=new ARRAY3600OBJ(GLOBAL.objects);
actobject->object_size=sizeof(ARRAY3600OBJ);break;
case OB_COMREADER: actobject=new COMREADEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(COMREADEROBJ);break;
case OB_NEUROBIT: actobject=new NEUROBITOBJ(GLOBAL.objects);
deviceobject=actobject;
actobject->object_size=sizeof(NEUROBITOBJ);break;
case OB_MIN: actobject=new MINOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MINOBJ);break;
case OB_MAX: actobject=new MAXOBJ(GLOBAL.objects);
actobject->object_size=sizeof(MAXOBJ);break;
case OB_ROUND: actobject=new ROUNDOBJ(GLOBAL.objects);
actobject->object_size=sizeof(ROUNDOBJ);break;
case OB_DIFFERENTIATE: actobject=new DIFFERENTIATEOBJ(GLOBAL.objects);
actobject->object_size=sizeof(DIFFERENTIATEOBJ);break;
case OB_DELAY: actobject=new DELAYOBJ(GLOBAL.objects);
actobject->object_size=sizeof(DELAYOBJ);break;
case OB_LIMITER: actobject=new LIMITEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(LIMITEROBJ);break;
case OB_EMOTIV: actobject=new EMOTIVOBJ(GLOBAL.objects);
deviceobject=actobject;
actobject->object_size=sizeof(EMOTIVOBJ);break;
case OB_FLOATVECTOR: actobject=new FLOATVECTOROBJ(GLOBAL.objects);
actobject->object_size=sizeof(FLOATVECTOROBJ);break;
case OB_VECTORFLOAT: actobject=new VECTORFLOATOBJ(GLOBAL.objects);
actobject->object_size=sizeof(VECTORFLOATOBJ);break;
case OB_DISPLAYVECTOR: actobject=new DISPLAYVECTOROBJ(GLOBAL.objects);
actobject->object_size=sizeof(DISPLAYVECTOROBJ);break;
case OB_BUFFER: actobject=new BUFFEROBJ(GLOBAL.objects);
actobject->object_size=sizeof(BUFFEROBJ);break;
}
if (actobject)
{
actobject->type = type;
actobject->xPos=50; actobject->yPos=40;
i=actobject->inports;
if (i<actobject->outports) i=actobject->outports;
if (!actobject->width) actobject->width=55;
if (!actobject->height) actobject->height=CON_START+i*CON_HEIGHT+5;
if (!actobject->tag[0]) strcpy(actobject->tag,objnames[type]);
for (i=0;i<MAX_CONNECTS;i++)
{
actobject->out[i].from_object=GLOBAL.objects; actobject->out[i].from_port=-1;
actobject->out[i].to_object=-1; actobject->out[i].to_port=-1;
strcpy(actobject->out[i].dimension,"uV");
actobject->out[i].min=-250;actobject->out[i].max=250;
}
objects[GLOBAL.objects]=actobject;
GLOBAL.objects++;
if (!GLOBAL.loading)
{
actobject->make_dialog();
// InvalidateRect(ghWndMain,NULL,TRUE);
InvalidateRect(ghWndDesign,NULL,TRUE);
}
if (actobject->displayWnd) SetForegroundWindow(actobject->displayWnd);
}
}
void GlobalInitialize()
{
InitCommonControls();
/* if(SDL_WasInit(SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_VIDEO) == 0)
{
if (SDL_InitSubSystem(SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_VIDEO) < 0)
report_error("Couldn't init SDL");
}
*/
if(SDL_Init(SDL_INIT_EVERYTHING)<0)
report_error("Couldn't init SDL");
if (!Sound_Init()) report_error("Couldn't init SDL_Sound");
if(SDLNet_Init()<0) report_error("Couldn't init SDL_Net");
GLOBAL.os_version=check_OS();
TTY.ThreadExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (TTY.ThreadExitEvent == NULL)
report_error("CreateEvent (Thread exit event)");
init_devicetype();
TTY.COMDEV=INVALID_HANDLE_VALUE;
TTY.CONNECTED=FALSE;
TTY.read_pause=TRUE;
TTY.amount_to_write=0;
TTY.writeMutex= CreateMutex( NULL, FALSE, NULL );
TTY.FLOW_CONTROL=0;
PACKET.readstate=0;
PACKET.info=0;
PACKET.requestedinfo=0;
GLOBAL.objects=0; actobject=NULL; actconnect=NULL;
GLOBAL.tool_left=400;GLOBAL.tool_top=100;
GLOBAL.tool_right=800;GLOBAL.tool_bottom=400;
GLOBAL.anim_left=20;GLOBAL.anim_right=420;
GLOBAL.anim_top=350;GLOBAL.anim_bottom=700;
GLOBAL.design_left=20;GLOBAL.design_right=500;
GLOBAL.design_top=20;GLOBAL.design_bottom=400;
GLOBAL.startup=0; GLOBAL.autorun=0; GLOBAL.configfile[0]=0;
GLOBAL.syncloss=0;
GLOBAL.dialog_interval=DIALOG_UPDATETIME;
GLOBAL.draw_interval=DRAW_UPDATETIME;
GLOBAL.neurobit_available=0;
GLOBAL.emotiv_available=0;
GLOBAL.use_cv_capture=0;
strcpy(GLOBAL.emotivpath,"C:\\Program Files (x86)\\Emotiv Development Kit_v1.0.0.3-PREMIUM");
GLOBAL.loading=false;
GLOBAL.read_tcp=0;
GLOBAL.packet_parsed=0;
GLOBAL.actcolumn=0;
GLOBAL.running=false;
GLOBAL.showdesign=TRUE;
GLOBAL.showtoolbox=-1;
GLOBAL.session_length=0;
GLOBAL.session_start=0;
GLOBAL.session_end=0;
GLOBAL.session_loop =0 ;
GLOBAL.session_sliding=0;
GLOBAL.main_maximized=0;
GLOBAL.minimized=0;
GLOBAL.run_exception=0;
GLOBAL.fly=0;
GLOBAL.P3ALC1=12;
GLOBAL.P3ALC2=12;
TIMING.timerid=0;
CAPTFILE.filetype=FILE_INTMODE;
CAPTFILE.filehandle=INVALID_HANDLE_VALUE;
CAPTFILE.file_action=0;
CAPTFILE.do_read=0;
CAPTFILE.do_write=0;
CAPTFILE.length=0;
CAPTFILE.start=0;
strcpy(CAPTFILE.filename,"none");
ghWndAnimation=NULL;
ghWndToolbox=NULL;
ghWndSettings=NULL;
ghWndDesign=NULL;
copy_object=NULL;
init_draw();
init_midi();
load_settings();
TIMING.timerid=0;
TIMING.pause_timer=0;
init_system_time();
write_logfile("application init successful.");
return ;
}
BOOL ARRAY3600OBJ::SetupComPort(int port)
{
connected=FALSE;
int sav_port;
DCB dcb = {0};
char PORTNAME[10];
sav_port=comport;
BreakDownComPort();
comport= port ;
// set tty structure for the specified port
if (!port) goto failed;
sprintf(PORTNAME,"\\\\.\\COM%d",port);
comdev = CreateFile( PORTNAME,GENERIC_READ | GENERIC_WRITE,
0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
if (comdev == INVALID_HANDLE_VALUE) goto failed;
if (!GetCommState(comdev, &dcb)) // get current DCB settings
{ report_error("GetCommState");goto failed; }
// update DCB rate, byte size, parity, and stop bits size
dcb.DCBlength = sizeof(dcb);
dcb.BaudRate = baudrate;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
dcb.EvtChar = '\0';
// update flow control settings
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
dcb.fOutxCtsFlow = FALSE;
dcb.fOutxDsrFlow = FALSE;
dcb.fDsrSensitivity = FALSE;;
dcb.fOutX = FALSE;
dcb.fInX = FALSE;
dcb.fTXContinueOnXoff = FALSE;
dcb.XonChar = 0;
dcb.XoffChar = 0;
dcb.XonLim = 0;
dcb.XoffLim = 0;
dcb.fParity = FALSE; //TRUE;
if (!SetCommState(comdev, &dcb)) // set new state
{ report_error("SetCommState failed"); goto failed;}
if (!SetupComm(comdev, 1024, 1024)) // set comm buffer sizes
{ report_error("SetupComm failed");goto failed;}
if (!EscapeCommFunction(comdev, SETDTR)) // raise DTR
{ report_error("EscapeCommFunction failed");goto failed;}
SetCommMask (comdev, EV_RXCHAR | EV_CTS | EV_DSR | EV_RLSD | EV_RING);
return(TRUE);
failed:
{
char sztemp[100];
sprintf(sztemp, "The Port COM%d is not available. Please select another Com-Port.",port);
write_logfile("COMPORT %d open failed.",port);
report_error(sztemp);
comport=sav_port;
comdev=INVALID_HANDLE_VALUE;
connected=FALSE;
return FALSE;
}
}
