• Added support for the PCI-DIO24 data acquisition board. Files changed: \threads\devutils.c, \threads\multi.c, \config\cthreads.c, \include\device.h, \threads\pcidas16.c. Files added: \source\threads\pcidio24.c

• Added several new functions for use in timing files: getCndsFilename, getItemsFilename, getTimingFilename, getExternsFilename. As their names suggest, these functions can be used to obtain the current filenames for the conditions file, items file, timing file, and external variables file. Refer to the online Function Reference Manual for more information. Files changed: \ufns\_userfns.c, \ufns\ufnlst.c, and \include\statefns.h.

• Added #define K_SPACEBAR, FILE, and NULL to css_inc.h. Files changed: css_inc.h

• Added some new simple demo files to show the following techniques: file i/o, playing movies, printing the keyboard scancode. Files added: \demos\newdemos\

• Changed the DXRecv initialization so that it could support more than 200 modes. File changed: \dxsource\dxgdp\initgks.cpp.

• Added the "getTimeDateString()" user function. This function puts the current date/time into a string and returns it to the user in the timing file. Note: The user must allocate space for the string in the timing file. Files changed: _userfns.c, ufnlst.c, and statefns.h.

• Added a new function called send_termination_signal(). This function sets up a flag and the other parameters, that tell Cortex to send a string out of the given serial port when the trials are over. If this flag is set, the port will be opened with Serial_Open(), the string will be written, one byte at a time, with Serial_Write(), and then the port will be closed with Serial_Close(). If the flag has not been set, the internal Cortex logic will just proceed as it has in previous versions, i.e., without a termination signal.Changed the files: block.h, runtrial.c, _userfns.c, ufnlst.c, and statefns.h.

• Enabled INIT/NO_INIT option for the PCI-DAS1602/12. The user can now change the I/O configuration for Ports A and B, but not Port C. Port C is still needed to provide lines for the reward, bar input, etc. Files changed: \config\cthreads.c, \threads\devutils.c, and \threads\pcidas16.c.

• Fixed a bug in the random() user function. If the parameters supplied for min and max are both zero, then Cortex would crash. Changed the code so that if min=max=0, then zero will be returned. File changed: \source\ufns\_userfns.c.

• Added the ability for the user to choose whether or not Cortex should send out the reset latch pulse for the PCI-DAS1602/12 only. This would free up another output line that users could access. (IMPORTANT NOTE: This option should only be used by users who are not using Cortex to collect spikes! For example, this would include those who are using a third party spike collection system, or who are not collecting spikes at all.) To specify this option, the user must put the word "NO_LATCH" on the DEVICE line in cortex.cfg. If this parameter is omitted, the reset latch pulse will be sent by default. Files changed: \threads\pcidas16.c, \config\cthreads.c, \config\cfglst.c, and \include\device.h.

• Added the ability to have 16 testscreens, instead of just 10. Files changed: \remote32\css_inc.h, \include\draw.h, \include\item.h, \interf\parse.c, \interf\condmenu.c.

• Added code to allow the user to call the internal Cortex function "MouseInit()" in a timing file. Most users will never have the need to call this function, since Cortex takes care of mouse input if the mouse driver has been loaded. This function was requested by users of a non-Microtouch touchscreen, which needed to be re-initialized each trial. Files changed: ufnlst.c, statefns.h, \menus\evt_dos.c, \ufns\_system.c, \include\menusyst.h.

• Made changes to the calculation of rIndex, gIndex, and bIndex for randCLT function. Also, added the new functions called CLTrandomAndFixed(),CLTrandomLMS(), CLTrandomLMS_OneIndex(), CLTbinaryLMS, CLTbinaryLMS_OneIndex, CLTtrinaryLMS, and CLTtrinaryLMS_OneIndex for this experiment. These functions are only available in the 32-bit versions of Cortex using the DirectX receive program. They were not added to the online function reference manual since they were added for a user with a very particular paradigm. I can't imagine anyone else needing these functions, but I added them to the release so that I wouldn't have to make a custom build. File changed: \dxsource\dxgdp\cltrand.cpp, \dxsource\dxgdp\cltrand.hpp, \dxsource\remcort\recvkern.cpp, \source\include\remcort.h, \source\include\statefns.h, \dxsource\include\statefns.hpp, \source\ufns\ufnlst.c, and \source\ufns\randclt.c.

• Made changes to the calculation of rIndex, gIndex, and bIndex for randCLT function. Also, added the new functions called CLTrandomAndFixed(),CLTrandomLMS(), CLTrandomLMS_OneIndex(), CLTbinaryLMS, CLTbinaryLMS_OneIndex, CLTtrinaryLMS, and CLTtrinaryLMS_OneIndex for this experiment. These functions are only available in the 32-bit versions of Cortex using the DirectX receive program. They were not added to the online function reference manual since they were added for a user with a very particular paradigm. I can't imagine anyone else needing these functions, but I added them to the release so that I wouldn't have to make a custom build. File changed: \dxsource\dxgdp\cltrand.cpp, \dxsource\dxgdp\cltrand.hpp, \dxsource\remcort\recvkern.cpp, \source\include\remcort.h, \source\include\statefns.h, \dxsource\include\statefns.hpp, \source\ufns\ufnlst.c, and \source\ufns\randclt.c.

• Fixed a bug where the subtraction was in the wrong order in the closing of the device (i.e., the Dpost() function), so the while loop was never executed. This code was intended to allow the reward pulse to finish, even if the end of the timing file was reached before the reward time expired. A Cortex user found the error since he was trying to give a long reward, and he noticed it was getting truncated. Files changed: \threads\dash16.c, \threads\pcidas16.c.

• Fixed a bug where the subtraction was in the wrong order in the closing of the device (i.e., the Dpost() function), so the while loop was never executed. This code was intended to allow the reward pulse to finish, even if the end of the timing file was reached before the reward time expired. A Cortex user found the error since he was trying to give a long reward, and he noticed it was getting truncated. Files changed: \threads\dash16.c, \threads\pcidas16.c.

• Added code to automatically load the external variables using the Disk->Get menu option, if an external variables filename was saved using Disk->Save. This code was contributed by Matt Smith and Ryan Kelly at CMU. Files changed: \css\cssio.c and \css\diskio.c.

The VCortex 2.2 release of the Windows 2000/XP version of Cortex has been uploaded to the Cortex web site (www.cortex.salk.edu).

Fixed some bugs that were found in the VCortex 2.1 code:

• The blocking parameters were not reset after a trial was stopped early. If the user then chose Run->Start it would cause the trial to resume from where it was stopped rather than at the beginning of the block.
• BLOCKset_next() was causing an occasional crash.
• The Tab order was incorrect in the Edit->Conditions dialog box
• Changed the Save->Block confirmation dialog box to be a message in the Status Bar.

The VCortex 2.1 release of the Windows 2000/XP version of Cortex has been uploaded to the Cortex web site (www.cortex.salk.edu).

New features:

• Added more data acquisition options. VCortex 2.1 now supports the use of the PCI-DAS1602/12 and/or the PCI-DIO24 data acquisition board. Additionally, VCortex 2.1 can run without any data acquisition board installed.
• Added messages to the status bar of the VCortex application window, so that unnecessary confirmation message boxes could be removed.
• The Run->Stop menu option now works during a trial, enabling you to end a trial at any time.
• Developed error checking for all blocking variables.
• Enabled the use of the inp() and outp() functions within timing files. Note: These functions require the use of an additional software library. Refer to Appendix B, item #10, in the VCortex User

The VCortex 2.0 release supports Win2000 and WinXP, and requires the PCI-DAS1602/12 data acquisition board

A new device driver, cdas16.sys, was written to control the timing and to collect data. Please refer to the VCortex User's Manual for installation instructions and more information.

The VCortex 2.0 code is based on VCortex 1.1. Note, however, that Win95/98 and the ISA-based boards are not supported by this release, so please use VCortex1.1 if you have these boards or operating systems.

Fixed some bugs that were found in the base 1.1 code:

• After a certain number of trials were run, the VCortex status windows would no longer be updated. Fixed this bug by releasing the device context handle after it was no longer needed.
• Fixed the crash that occurred when Edit:Individual_Condition was chosen from the menu.

Added one new feature:

• Added support for 16 test screens per condition. Refer to the demo files \demos\newdemos\tsmax.* for an example of how to use 16 test screens.

• Added Play mode (Play Alone and Play With Conditions). Play mode can be found under the Tools menu. More information about Play mode can be found in sections 5.5.3 and 5.5.4 of the VCortex User's Manual. Files added: \source\include\menuplay.h, playalone.h, playalonesheet.h, playthread.h, \vccode\menuplay.cpp, \vccode\playalone.cpp, \vccode\playalonepages.cpp, \vccode\playalonesheet.cpp, \vccode\playthread.cpp, \mousehooks\mousehooks.h, \mousehooks\mousehooks.cpp. Files changed: \config\cplay.c, \play\*.c.

• Added touchscreen support. Like the DOS version of Cortex, the code was written for and tested on a Microtouch touchscreen. Refer to the VCortex User's Manual for more details. Files changed: \source\ufns\_touch.c, cfglst.c, and ufnlst.c. Files added: \source\vccode\MyTouchThread.cpp, \source\vccode\MyTouchThread.h

• Added installation of the VCortex programs via InstallShield. There is a separate Installation package for the send programs and the receive program. Refer to section 3.6 of the VCortex User's Manual for more information.

• Fixed some bugs that were found in VCortex 1.0.
  • Direct I/O access to hardware with the inp(), inpw(), outp(), and outpw() commands was not supported in VCortex 1.0. In VCortex 1.1, these functions are supported. Files changed: ufnlst.c and _system.c.
  
  
  • When Run/Start is chosen from the menu, VCortex will prompt for the ouput data file name. If you click on the "No" button when it asks if you want to append to the current file, the directory changed to the "My Documents" directory, rather than the current data file directory. The code has been modified so that the directory is now the one from which you are running the VCortex executable. Files changed: \source\VCcode\globals.cpp.
  
  
  • If you chose Edit:Add_an_item, and then Cancel, it would add the item to the list anyway. Files changed: \source\VCcode\MenuEdit.cpp.
  
  
  • Fixed two problems with the View->Results of Most Recent Trial menu option. The first problem was that once the results windows were closed, VCortex would crash if the user tried to open the windows again with the View->Results menu option. The second problem was that if the results windows remained open, and you ran some more trials, the text inside the results windows would not be updated unless the windows were resized. In VCortex1.1, these windows cannot be closed, only minimized, so they will not crash if the user attempts to reopen them. Also, these windows are automatically updated without having to resize. Additionally, the code necessary to view the touchscreen values and EPP values was added to the View->Results of Most Recent Trial menu option. Files changed: \VCcode\mainfrm.cpp, \VCcode\MenuView.cpp, \VCcode\vccodesdoc.cpp, \VCcode\vccodesview.cpp, \VCcode\vceogvaluesdoc.cpp, \VCcode\vceogvaluesview.cpp. Files added: VCEPPValuesDoc.cpp, VCTouchValuesDoc.cpp, VCEPPValuesView.cpp, and VCTouchValuesView.cpp
  
  
  • Fixed a bug whereby the output error file, VCortex.err, was not always written to the same directory. For example, if a timing file was loaded from a directory other than the \vcwin32 directory, a new copy of the VCortex.err file was opened in that new directory. This results in some of the output messages being written in \vcwin32\vcortex.err file, and some being written in another directory. Modified the code so that the VCortex.err file will always be written in the directory from which the VCortex executable file is run. The path to this directory is obtained from the CORTDIR environment variable. This variable is placed into the autoexec.bat file automatically during the VCortex installation process. File changed: \source\screen\sputs.c.

• Added some other new features:
  • The File->Load and File->Save dialog boxes will remember the file extensions that the user has chosen for the particular type of file. Previously, the dialog boxes were hardcoded to "*.tim" for timing files, "*.itm" for items files, etc. File changed: MenuFile.cpp.
  
  
  • Changed the ordering of the options under the Run menu. Since "Stop" actually causes the program to exit, rather than just stop temporarily, it would cause a problem if the user would press it accidentally. It has therefore been moved to the bottom of the Run menu. A confirmation message box has also been added, so that the user can cancel out of the Stop if it was selected by accident. Files changed: \VCcode\MenuRun.cpp, \VCcode\VCortex.rc.
  
  
  • Added the "getTimeDateString()" user function. This function puts the current date/time into a string and returns it to the user in the timing file. Note: The user must allocate space for the string in the timing file. Files changed: _userfns.c, ufnlst.c, and statefns.hpp.
  
  
  • Added #define statements for the FILE and NULL variables into the css_inc.h file. File changed: \vcwin32\css_inc.h.
  
  
  • Added the ability to check what items, conditions, and timing file(s) are currently loaded. After a file is loaded via the File->Load menu option, any subsequent loading of that particular file type will display the current file name in the "File name" entry field of the dialog box. Files changed: \VCcode\MenuFile.cpp, \VCcode\MenuEdit.cpp
  
  
  • Added several new functions for use in timing files: getCndsFilename, getItemsFilename, getTimingFilename, getExternsFilename. As their names suggest, these functions can be used to obtain the current filenames for the conditions file, items file, timing file, and external variables file. Refer to the online Function Reference Manual for more information. Files changed: \ufns\_userfns.c, \ufns\ufnlst.c, and statefns.hpp
  
  
  • Changed the DXRecv initialization so that it could support more than 200 modes. File changed: \dxsource\dxgdp\initgks.cpp.
  
  
  • Added some new simple demo files to show the following techniques: file i/o, playing movies, printing the keyboard scancode. Files added: \demos\newdemos\

• Fixed a bug in the analog (EOG and EPP) data collection of the CIO-DAS1602/12 board. Unlike the old Compuboards, this board has an onboard buffer that stores the analog data. Since the old boards did not have this capability, there was not code to clear this buffer at the beginning of each trial. Therefore, it was noticed that this board had a leftover data point at the end of each trial. Changed the code so that this buffer is cleared before each trial begins. Files changed: \source\threads\dash16.c

• Fixed a bug in the analog (EOG and EPP) data collection of the PCI-DAS1602/12 board. By default, the board is set to 8 differential analog channels. Cortex expects the analog data to be set up as 16 single-ended channels. Since the PCI board does not have any jumpers, this needed to be set through software. By default, the board is shipped set at bipolar and 8 differential channels. Even though Cortex expects the analog data to be "bipolar and 16 single-ended channels", created optional parameters for the DEVICE line of the Cortex.cfg file to set them. Now the user can configure the PCI-DAS1602/12 board, so that it is bipolar vs. unipolar, and single-ended vs. differential. If these optional parameters are omitted, the board will be initialized to bipor and single-ended. Files changed: \source\threads\pcidas16.c, \source\config\cthreads.c, \source\config\cfglst.c, and cortex.cfg.

• Fixed a bug in the DEVxxx() series of functions, which was introduced in version 5.9.4. The problem would occur if the user had set the DEVICE line to COMPUBOARD in the Cortex.cfg file. If COMPUBOARD was instead split out into two DEVICE lines as DASH16 and PIO24, then the DEVxxx() functions would work. The bug was quite noticeable since the DEVoutp() , DEVinp(), DEVoutpw(), and DEVinpw() functions would not read or write digital I/O with the DEVxxx() functions. This has been fixed, so now COMPUBOARD will work as a DEVICE line. Files changed: \source\threads\devutils.c

• Fixed bug in the DirectX receive program (DXrecv.exe). If two items are defined as the same color in the items file, and appear in the same condition, only one lut index was being used for both items. What should happen is that each item is assigned a unique index into the lut, so that its color can be changed with GcolorABS(ITEM_POSlut_index(), r,g,b). This problem was occurring since Microsoft DirectX only uses one entry in the LUT if the same color is being used more than once. In a related issue, if the same item was used in multiple testscreens, GcolorABS(ITEM_POSlut_index(), r,g,b) would only change the color if the first occurrence (testscreen) was given as the parameter to ITEM_POSlut_index(). Changed the code so that this will not be the behavior of Microsoft DirectX in Cortex. Files changed: \dxsource\dxgdp\color.cpp, \dxsource\dxgdp\initgks.cpp, \dxsource\dxgdp\pattern.cpp, \dxsource\dxgdp\seq.cpp, and \dxsource\dxgdp\string.cpp.

• In version 5.9.4, a change was made so that the background will remain constant between trials if the user configures this feature in the GRAPHICS_SPECS line of Cortex.cfg. Extended this feature so this Cortex.cfg setting will also cause the background to remain constant when Play is exited as well. Files changed: \source\play\play.c

• Added a new serial function, Serial_SetPortHardware(), to the 32-bit versions of Cortex. This function allows the user to change the COM ports address to a non-standard IRQ and/or address. Please refer to the online Cortex Timing File Reference for more information about the function. Files changed: \source\include\serial.h, \source\include\statefns.h, \source\remcort\grenleaf.c, and \source\ufns\ufnlst.c.

• Added a new function, getDataFileName(), which allows the user to obtain the name of the output Cortex data file from inside the timing file. Please refer to the online Cortex Timing File Reference for more information about the function. Files changed: \source\include\statefns.h, \source\ufns\_userfns.c, and \source\ufns\ufnlst.c.

• Added a set of new functions to return various items from the header of the Cortex output data file. Also, added some functions to set the response codes inside Cortex. The new functions added were: set_response(), set_expected_response(), set_response_error(), set_trial_type(), get_repeat_num(), get_trial_type(), get_eye_storage_rate(), and get_kHz_resolution(). Please refer to the online Cortex Timing File Reference for more information about the functions. Files changed: \source\include\statefns.h, \source\ufns\_userfns.c, and \source\ufns\ufnlst.c.

• Created a 32-bit single-computer DOS version of Cortex, which does not display graphics. The serial communications functions and analog/digital data capabilities still work, so this version can be used when graphics are not necessary, or when the graphics are displayed by some other means. The new program is called "sgl32.exe", and can be found in the \remote32 directory of the Cortex release. Files changed: \source\remcort\testkern.c Files added: \source\remcort\remnull3.c and the directory \source\w_sgl32 which contains the project files necessary to build the executable.

• Added new functions to randomly change the LUT entries, based on a gamma table of values. The new functions are called: CTLrandom(), SetGammaRedValue(), SetGammaGreenValue(), and SetGammaBlueValue(). These functions are only available in the 32-bit versions of Cortex using the DirectX receive program. They were not added to the online function reference manual since they were added for a user with a very particular paradigm. I can't imagine anyone else needing these functions, but I added them to the release so that I wouldn't have to make a custom build. Files changed: \source\include\remcort.h, \source\include\statefns.h, \source\ufns\ufnlst.c, \dxsource\include\statefns.hpp, and \dxsource\remcort\recvkern.cpp Files added: \source\ufns\randclt.c, \dxsource\dxgdp\cltrand.cpp, and \dxsource\dxgdp\cltrand.hpp

• Updated the Cortex User's Manual to include the two-computer version of Cortex, current hardware/software requirements, installation instructions, compilation instructions, and a troubleshooting section containing answers to the most frequently asked questions. A copy of this new document can be found in the \docs directory of the release, and on the Cortex web site. Files added: \docs\CtxUser.doc

• Added support for the PCI-DAS1602/12 board. Refer to the document entitled "Using the PCI-DAS1602/12 board with Cortex" on the Cortex web page for details on how to use the board.
  (Files added: \source\threads\pcidas16.c
  Files changed: \source\threads\devutils.c, \source\include\device.h, and \source\config\cthreads.c)

• Added an optional parameter to the TOUCH_SCREEN line in cortex.cfg to allow the user to specify whether or not the Y value from the touchscreen should be inverted. If the user does not specify this parameter, the default behavior is to *not* invert the y. Note: This change has only been implemented for the two-computer version of Cortex. For the other versions, this parameter is not used. If the invert_y parameter is specified in the cortex.cfg file, then the store_touch_data parameter should be specified as well. (Files changed: \source\ufns\_touch.c and \source\config\cfglst.c)

• Added an optional parameter to the DEVICE line of cortex.cfg, so that the user can specify whether or not the PIO24, PIO96, and the PIO24 portion of the Compuboard, will be initialized by Cortex to Port A in, Port B out, and Port C split. If the user specifies NO_INIT for the parameter, then the user will be able to issue timing file commands that initialize the board. Refer to the document (written by Andy Mitz) on the Cortex web site entitled "Setting up Cortex for Recording Many Spike Channels".
  (Files changed: \source\config\cthreads.c, \source\threads\compbord.c, \source\threads\dash16.c, \source\threads\pio24.c, \source\threads\pio96.c, \source\threads\rand_dev.c, and \source\include\device.h)

• Added a new movie function, for use in timing files, called "Gmovie_one_time()". This function will play the movie one time through, rather than according to the timer. (Files changed: \source\graph\gkernel.c, \source\include\draw.h, \source\include\statefns.c, \source\ufns\ufnlst.c, and \source\ufns\_gkernel.c)

• Added an optional parameter to the GRAPHICS_SPECS line in cortex.cfg, to allow the user to specify whether or not the background color stays on the screen even after the set of trials has ended. In prior versions of Cortex, the screen remains the background color between trials, but once the trials are over, it goes to black.
  (Files changed: \source\config\cgspecs.c, \source\config\cfglst.c, \source\include\interf.h, and \source\interf\runmenu.c)

• Since the 1's complement operator (~ tilde) did not compile in the CSS, even though it is listed in the math functions, Andy Mitz suggested adding the following macro INV(x) to the css_inc.h file. Then, in timing files, the user can write: b = INV(a); to take the 1's complement of the variable "a", for example. (Files changed: \remote32\css_inc.h, \remcort\css_inc.h, \num9gxi\css_inc.h, and \sgtpeppr\css_inc.h)

• he DirectX receive program (DXRecv.exe) was not written to accept the command line options to change comport and baud rate like the programs rvesactx.exe and wcsend.exe. Added that functionality into DXrecv.exe. In order to use the command line arguments, the user must change them in the Properties page of the Dxrecv.exe shortcut on the desktop. The parameters should be added onto the "Target:" line. For example, the "Target:" line would read:
  nbsp;nbsp;c:\c594\wcortex\dxrecv.exe COM2 @115200
  Note that there are no spaces between the COM and the 2, and no spaces between the @ and the baudrate. If these command line arguments are omitted, the default values are a comport setting of COM1 and a baudrate of 115200.
  Note: For Win2000 users, the shortcut must be created from the directory \dxsource\dxrecv\release\dxrecv.exe for the command line arguments to work properly. If this is done, then the working directory of the dxrecv.exe program will be \dxsource\dxrecv\release, not \wcortex.
  (File changed: \dxsource\remcort\recvcort.cpp)

• Fixed a bug in the Cortview.exe utility. Now, when the user chooses to show the codes only, it does not display their meanings, too. (Code changed by Daniel Muldrew.)
  (File changed: \cortex\cortview.c)

• Added the C time() and clock() functions for use in timing files. The time() standard C function will allow the user to get the number of seconds since Jan 1, 1970. This value can be used to seed the random number generator, for instance. The C function clock() returns the number of clock ticks of elapsed processor time. The returned value is the product of the amount of time that has elapsed since the start of a process and the value of the CLOCKS_PER_SEC constant. The time in seconds is approximated by dividing the clock return value by the value of the CLOCKS_PER_SEC constant. Added the CLOCKS_PER_SEC value in css_inc.h. For the Watcom and Microsoft C compilers, the value of CLOCK_PER_SEC is 1000. Note: In MS-DOS, clock returns the time elapsed since the process started. This may not be equal to the actual processor time used by the process.
  (Files changed: \source\include\statefns.h, \source\ufns\ufnlst.c, and \source\ufns\_system.c.)

• Initialized CODEbuf[], ISIbuf[], EOGbuf[], and EPPbuf[] to zero for each trial. Previously, the CODE_ISIsize, EOGsize, and EPPsize were just set to zero, and the arrays were not reinitialized.
  (File changed: \source\config\cparams.c)

• For the DirectX version of the "receive" program (in two computer Cortex), added the ability to play AVI, MPEG, and QuickTime movies, in addition to the standard Cortex (CTX) image file format based movies. The type of movie file is determined by the file extension. That is, to be processed correctly: AVI files must have the extension .AVI; MPEG files must have the extension .MPG; and QuickTime files must have the extension .QT or .MOV. All other movie file extensions are assumed to be the standard Cortex (CTX) bitmap type. Therefore, this code change should be transparent if you continue to just use CTX type movies. Other details:
  • Colors for the movies look best when you are running at 32 bpp. For 8 bpp, you will need to generate a LUT that will look good with the movie.
  • The movies are very slow to load, so you might want to use the "dont_unload_conds()" function in your timing file, if the movie is to be used repeatedly.
  • Since it uses the DirectShow component of DirectX to display the movies, Microsoft Internet Explorer version 4.0 or higher must be installed on the receive computer.
  • Only the video track of the movie file will be played by Cortex. The audio track will be ignored.
  • Not all video codecs are supported by DirectShow.
    
    
  (Files changed: \DXSource\dxgdp\bitimage.cpp, \DXSource\dxgdp\initgks.cpp, \DXSource\dxgdp\mbmpsize.cpp, \DXSource\dxgdp\movie.cpp, \DXSource\dxgdp\dxgks.hpp, \Source\mglgdp\mbmpsize.c, \Source\mglgdp\bitimage.c, and \Source\mglgdp\mglgks.h)
  
  
• Fixed several other bugs in the DirectX receive program:
  • No longer generates a grey screen upon termination of the the DirectX receive program.
    
    (Files changed: \DXSource\dxgdp\initgks.cpp, \DXSource\remcort\recvcort.cpp, and \DXSource\dxgdp\dxgks.hpp)
  • Fixed bug where Item:Display of a movie file would cause DirectX receive to crash.
    
    (File changed: \DXSource\dxgdp\seq.cpp)
  • Fixed a bug where DirectX receive was running out of "brush" handles, which is the structure used to fill in solid color objects. When the handles ran out, the items would just be filled in with white. The fix recycles the handles, so they should never run out.
    
    (Files changed: \DXSource\dxgdp\ellipse.cpp and \DXSource\dxgdp\polygon.cpp)
  • Fixed a bug where the fixspot would not appear on the first trial, if the fixspot was black.
    
    (File changed: \source\graph\gdraw.c)
  • Changed DirectX receive program so that the "realtime" priority is only activated during a trial. Between trials the priority is changed back to "normal" priority. (Previously, the program was realtime when the program started, and was not released to normal priority until the program terminated.) This will allow Windows to do any background processing it needs to do in the non-critical time between trials.
    
    (Files changed: \DXSource\dxgdp\initgks.cpp, \DXSource\dxgdp\dxgks.hpp, and \DXSource\dxgdp\wkst.cpp.)
  • Created a custom icon for the DirectX receive program.
    
    (File changed: \DXSource\remcort\recvcort.cpp. File added: \DXSource\remcort\dxrecv.ico)
  • Fixed a bug in the DirectX receive program where black rectangular extents were appearing around primitive circular items, when using a color depth greater than 8 bits per pixel.
    
    (File changed: \DXSource\dxgdp\wkst.cpp)
  • Fixed a bug in the DirectX receive program where the background color was not appearing correctly when the color depth was greater than 8 bits per pixel. Now it appears correctly for 32 bits per pixel.
    
    (File changed: \DXSource\dxgdp\initgks.cpp)
  • Fixed bug in Cortview.exe such that when response_error equals NO_ERROR, Cortview reported it as "Unknown response_err").
    
    (File changed: \source\cortex\cortview.c)
    
    
• Added a parameter to the TOUCHSCREEN line of cortex.cfg so that the EPPbuf and CODE/ISIbuf buffers are not filled in with touchscreen data unless the user wants that to be. Now, the data can be stored selectively into the EPPbuf, CODE/ISIbuf, both buffers, or neither buffer. See the comments in the Cortex.cfg file for details about the TOUCHSCREEN parameter. Please note that the default case is to store the data in both places, so current users do not have to alter their cortex.cfg file if they want the default behavior.
  
  (Files changed: \source\ufns\_touch.c, \source\config\cfglst.c, and cortex.cfg)
  
  
• Changed so that LUT:View/Change pop-up menu will display the LUT entries as indexed from 0 through 255, instead of from 1 through 256.
  
  (Files changed: \source\menus\pmenu.c and \source\menus\pmenu2.c)
  
  
• Changed so that a larger stack size is available to the Cortex compiler (CSS) for the 32-bit version of Cortex (REMOTE32). This will allow larger array sizes to be used in timing files.
  
  (File changed: \source\include\css.h)

• For the DirectX version of the "receive" program (in two computer Cortex), added the capability to play sound. The sound component of the DirectX receive program has more functionality than the DOS version of the sound code. For example, DirectX supports the overlaying of multiple sounds, the ability to continually loop a sound, the individual control of the volume of each sound, and the ability to stop each sound one at a time. DirectX also allows the user to specify what kind of speakers are being used, and also the orientation of the stereo speakers, in order to optimize the sound produced. A new SOUND parameter in the CORTEX.CFG file can be used to customize these features.
  
  For complete details regarding installation, interface, and features of the sound code with the DXRECV.EXE program, please read the document "Using Sound with Dual Computer Cortex" in the \DOCS\ directory of the Cortex distribution or in the Documentation section of the Cortex web page.
  
  (Files added: Source code in \DXSource\sound directory, and \Source\config\csound.c. Files changed in \DXSource directory: \dxgdp\dxgks.hpp, \include\statefns.hpp, \remcort\recvkern.cpp, and \remcort\recvcort.cpp. Files changed in \Source directory: \config\cfglist.c, \ufns\ufnlst.c, \sound\sound.c, \sound\soundrem.c, \include\cfglst.h, \include\remcort.h, and \remcort\recvkern.c. "Release" executable in \DXSource\dxrecv\Release\ directory and in \WCortex\. "Debug" executable in \DXSource\dxrecv\Debug\ directory.)
  
  
• Fixed a bug in Cortex where the data file was not being closed properly, resulting in the error "no more file handles".
  
  (File changed: \rtime\runtrial.c)
  
  
• Created an environment variable (CORTEX_ESC_OPT) to be used to specify whether to use an alternate keyboard escape sequence to terminate two computer cortex. If the environment variable is not set or is set to 0, then the default SHIFT+ALT+CTRL will be used. If the environment variable is set to 1, then SHIFT+ALT+CAPSLOCK will be used. Since CAPSLOCK toggles between ON and OFF, it may be necessary to hit the escape sequence twice to actually terminate the programs. The environment variable must be set, using "SET CORTEX_ESC_OPT=0" (or =1) from the DOS prompt or in AUTOEXEC.BAT prior to running RVESACTX.EXE and WCSEND.EXE. Note that keyboard escape sequences can not be used to terminate the DirectX receive program.
  
  (Files changed: \cortex\main.c, \remcort\recvcort.c, and \remcort\grenleaf.c)
  
  
• Fixed a bug in DXrecv.exe whereby the color was not being set properly in GcolorABS().
  
  (File changed: \DXSource\dxgdp\seq.cpp)
  
  
• Added command line parameter to determine the behavior of setting and realizing the color palette in the Scitech MGL version of the receive program (RVESACTX.EXE). When a color palette change is made in a timing file using the GcolorABS() function, it needs to be followed by a call to the Gflush() function to actually appear. If Gflush(1) is called, the color palette change occurs during the next vertical refresh of the display. If Gflush(0) is called, the color change occurs immediately, perhaps causing tearing of the display. Since tearing appears as a distracting and variable artifact on the screen, the user is forced to use Gflush(1). When changing only one color, this is fine. However, if multiple color palette changes are desired during a single vertical refresh, it was not possible. Therefore, the code was changed so that if multiple GcolorABS() or GcolorREL() calls were made in a timing file, the color changes will be accumulated. When a Gflush(1) was finally called, all the color changes will be realized.
  
  To run the RVESACTX.EXE program with this new behavior, you must supply a new command line argument (%1) when you start RVESACTX.EXE. That is, type "RVESACTX %1".
  
  (Files changed: \remcort\reccort.c and \mglgdp\seq.c)
  
  
• Fixed a bug in DXrecv.exe whereby the default item #1 would appear as an unfilled square the first time it was displayed using the Item:Display menu.
  
  (File changed: \DXSource\dxgdp\initgks.cpp)
  
  
• Added a new demo to demonstrate the capabilities of the DirectX sound code.
  
  (File added: \demos\dx\dxsound.tim, music1.wav, music2.wav, music3.wav, and music4.wav)

• For the two computer version of Cortex, added a new "receive" program written using Microsoft DirectX 6.0 SDK as the graphics library. In previous versions of Cortex, the receive program (RVESACTX.EXE) utilized the Scitech MGL graphics library, and therefore required the installation of Scitech Display Doctor software. The DirectX receive program (DXRECV.EXE) only requires the installation of the DirectX 6.x driver, which is freely available at the Microsoft web site.
  
  Cortex users who have had trouble finding graphics cards which were supported by Scitech Display Doctor, might want to give this DirectX version a try. Also, if you are interested in using source transparency with bitmap files (i.e., areas of a bitmap can be transparent over a background), this feature is available in the DirectX version. However, please note that not all the functionality of the current RVESACTX.EXE has been implemented into DXRECV.EXE. Also, there are several known bugs in the DXRECV.EXE version. For complete details regarding installation, use, features, and limitations of the DXRECV.EXE program, please read the document "Instructions for the DirectX Receive Program (DXRECV.EXE)" in the \DOCS\ directory of the Cortex distribution or in the Documentation section of the Cortex web page.
  
  (Files added: Source code and project files in \DXSource\ directory. "Release" executable in \DXSource\dxrecv\Release\ directory and in \WCortex\. "Debug" executable in \DXSource\dxrecv\Debug\ directory.)
  
  
• Added a demo to demonstrate the bitmap source transparency capability of the DirectX receive program. The necessary item, condition, timing, and image files can be found in the directory \DEMOS\DX\. (Remember that the .LUT file must be on the send computer to display the .CTX image!)
• Added srand2() and rand2() as CSS functions, which can now be used in a timing file. Functions definitions are:
  • void srand2(unsigned long seed);
  • long rand2(void);
    
    
  For full code of these functions, see \rtime\random.c.
  
  (Files changed: \include\statefns.h, \ufns\ufnlst.c, and \ufns\_system.c)
  
  
• Added "ms_reward_duration" to the list of external variables that can be accessed via the timing file. Previously, this value could only be set through the Run:Parameters:General menu in Cortex. This variable is valuable since it allows the user to control the length of the TTL reward output pulse through the timing file.
  
  (Files changed: \ufns\ufnlst.c)
• Fixed a problem in the Play mode of Cortex, whereby if the fixspot, rfield, etc. item was modified using the Item:View/Modify menu, then the next time Play was chosen, the entire subject's screen was the color of the modified item. The reason this occurred was that there was no space reserved in the LUT for these items, and the color.index was set to 0. Therefore, when Play tried to draw the play object, it set color.index 0 (the background item) to the color of the play item.
  
  With this fix, there will only be one space in the LUT reserved for the special items FIXSPOT, RFIELD, RPOINT, PLAY_ITEM, FIRST_ITEM. It is assumed that one of these special items would be the fixpoint and only one would be displayed at a time, so only one LUT entry is reserved.
  
  (Files changed: \interf\parse.c and \config\cparams.c)
  
  
• Added code in an attempt to fix a reported intermittent problem where the RVESACTX.EXE (receive program) sometimes crashes on shutdown. Added more checks on shutdown to make sure that the COM port is not being referenced after it has been released.
  
  (Files changed: \mglgdp\initgks.c and \remcort\grenleaf.c)
  
  
• Changed the code for the drawing of the circular and elliptical annulus, so a pattern does not fill in the center. In the previous code, the pattern file was being passed in to draw the inner and outer circles, even though it is only necessary for the outer circle.
  
  (Files changed: \graph\gobjects.c)

• The ability to play sounds in Cortex via a SoundBlaster card has been added to the dual computer Cortex program. With this code, up to 256 different sound (.wav) files can be played during an experiment. Additionally, the volume and mix of the sound from the speakers can be changed during the experiment through function calls in the Cortex timing file.
  
  The sound code for Cortex was written by David Mechner at New York University. The sound code is provided "as-is. Because the sound code was integrated with the 32-bit Cortex "send/receive" code, it can only be used with the two computer 32-bit version of Cortex. Also, be aware that the sound code has not yet been tested for latencies. More information can be found in the \DOCS\ directory of the Cortex distribution or in the Documentation section of the Cortex web page.
  
  (Files changed and/or added: \include\remcort.h, \include\statefns.h, \ufns\ufnlst.c, \remcort\recvcort.c, \remcort\recvkern.c, \w_csend\wcsend.wpj, \w_vesa\rvesactx.wpj, \sound\sound.c, \sound\soundrem.c, \sound\soundrem.h, \sound\soundint.c, \sound\soundint.h)
  
  
• Fixed a bug in the two computer version of Cortex whereby the background color was not set properly when the bits-per-pixel was greater than 8. (Files changed: \mglgdp\color.c, \mglgdp\mglgks.h) As an aside: This problem was caused since Cortex handles the color changes using a palette/LUT-based system. When using more than 8 bpp, palettes are no longer relevant. Therefore, if you need to change and set colors dynamically from your timing file, you must still use the 8 bpp setting.
  
  
• Fixed a bug in Gmovie_step() when using the MOVIE_STEP_WRAP option, where stepping backwards from the first frame of a movie did not wrap properly to the last frame.
  
  (Files changed: \graph\gseq.c)
  
  
• Changed the code so that the output data file is opened and closed when the data is being saved to disk between each trial, instead of just at the end of all trials. Without this change, all data would be lost if the system crashed while running.
  
  (Files changed: \rtime\runtrial.c)
  
  
• Added a comment to CORTEX.CFG regarding the difference in the device port offsets for CIO-AD16 and CIO-DAS1600 data acquisition boards.
  
  
• Updated the Cortex version string that is written to the user screen on startup to say "***CORTEX 5.8.1***". Note that the user will not be able to use Disk:Save files from version 5.7beta4 and later anyway, since the CSS size changed with the addition of the sound functions.
  
  (Files changed: \cortex\main.c)

• Changed the code so that a touchscreen could be used with the two computer version of Cortex. The interrupt driven _touch.c code was designed to be run on a single computer. The new code uses the mouse emulation capability of the touchscreen driver to generate the touch locations. This code has only been tested using a Microtouch touchscreen. The touchscreen driver used was Microtouch's TouchWare 3.4 for DOS.
  
  To specify the use of a touchscreen, the CORTEX.CFG file must have a positive TOUCH_SCREEN value. To use a mouse instead of a touchscreen, specify a negative TOUCH_SCREEN value. (Files changed: \menus\evt_dos.c, \ufns\_touch.c, \include\menusyst.h)

• Added another touchscreen related demo in the directory \DEMOS\TOUCH3. This demo is essentially the same as TOUCH1, except the extra mouse threading was removed. Also, the items file is slightly different, since it was hard to test with the overlapping items. The user is no longer asked if the mouse is being used, since the TOUCH_SCREEN setting in CORTEX.CFG determines this.

• Fixed a bug in the CORTEX 5.7b9 code where the memory was not being freed after the display of JPEG, BMP, or PCX bitmaps. (Files changed: \mglgdp\bitimage.c and \mglgdp\mbmpsize.c. Only applies to the remote version of Cortex.)

For the remote version of Cortex (\REMCORT and \REMOTE32):

• Added the ability to display JPEG, BMP, and PCX bitmaps, in addition to the standard Cortex (CTX) image files. The type of bitmap file is determined by the file extension. That is, to be processed correctly: JPEG files must have the extension .JPG; BMP files must have the extension .BMP; and PCX files must have the extension .PCX. All other bitmap file extensions are assumed to be the standard Cortex (CTX) bitmap type. Therefore, this code change should be transparent if you continue to just use CTX type bitmaps. It is assumed that the CTX files follow the documented format, or were generated with the TARGCORT.EXE utility.
  
  (Files changed: \mglgdp\bitimage.c, \mglgdp\mbmpsize.c, \mglgdp\mglgks.h, \mglgdp\movie.c, \mglgdp\initgks.c) Please note that only the remote version of Cortex is able to support these other bitmap formats. This is because the MGL graphics library, which is used in the remote version of Cortex, natively supports the display of these file formats.

• Fixed a bug which prevented items from being displayed in 32 bit per pixel mode. (Files changed: \mglgdp\color.c, \mglgdp\bitimage.c)

• Added the ability to set the GRAPHICS_SPECS "bits_per_pixel" parameter in CORTEX.CFG to be 16 or 24, in addition to 1, 2, 4, 8, 32. However, it is the responsibility of the Cortex user to make sure that the bitmap files are stored in the proper bit depth. (For example, an 8 bpp CTX bitmap, will not be displayed properly when the GRAPHICS_SPECS parameter is set to 32 bits per pixel.) (Files changed: \config\cgspecs.c, \interf\extern.c, \interf\paramenu.c)

• Changed the code so that if the graphics card can not be initialized for the remote version of Cortex, the user screen will display an error message and then Cortex will exit. In previous versions of Cortex, this was not an immediate fatal error. Therefore, Cortex would try to continue and perhaps crash later. (Changed files: cgspecs.c, mglkernl.c, sendkern.c, and cgdp.c) Please note that some additional information about initialization errors may be written to the executable directory on the receive computer in the file RVESACTX.ERR.

• Changed the "ints" to "shorts" so that the data files generated with the 32-bit version of remote CORTEX would be compatible with the 16-bit version files. (Changed files: disk.h, histogra.h, and data.c)

• Fixed a bug in 32-bit CORTVIEW.EXE that caused the program to terminate immediately if any of the buffers (EOG, EPP, etc.) were of size zero. (Changed file: cortview.c)

• Compiled 32-bit version of CORTEX with Watcom C/C++ version 11.0, instead of version 10.6. Also, compiled with the latest Greenleaf CommLib libraries for Watcom 11.0.

• Compiled 16-bit version of CORTEX with less optimization flags. (Changed file: Makefile)

• CROSS object type added

• \remote32 now contains only three executables:
  • csend32.exe - the send side - contains preppy and cortexcc within it, so you won't see these accessory files
  • rvesactx.exe - the receive side.
  • cview32.exe - the 32 bit equivalent of cortview.exe

• \demos directory is in the process of being restructured

• \source directory now contains the \w_* directories, instead of cluttering up the root directory with them.

With this release, the remote (two computer version) of CORTEX is fully 32 bit. This effectively removes all memory limitations from the data files. The 32 bit versions are located in the \remote32 directory. It should be noted that the data files will have a slightly different format, since ints are 32 bits in the 32 bit version, and 16 bits in the 16 bit version (which is located in the usual places). Thus, the \remote32 directory also contains new versions of cortexcc.exe, preppy.exe, and cortview.exe. The control side program is wcsend.exe, and the graphics side program is rvesactx.exe. Thegraphics side must be running on a VESA compliant board, and requires SciTech's Display Doctor (or native VESA 2.0 compatibility) to run.

This new version also supports two simultaneous serial ports - (so that one can use the remote version and also control another serial port) using the Serial_*() routines.

Several minor bugs related to loading large bitmaps in remote CORTEX have also been fixed.

With this release, remote (two computer versions of) cortex is fully operational, as are the VESA drivers. Thus, you no longer need to be completely reliant upon failing Sgt Peppr or #9Gxi boards. However, until Windows supports two monitors attached to a single computer, it will be necessary to use two computers connected by a serial cable to take advantage of the VESA drivers.

This version is compatible with CORTEX5.x.x, except for the usual save file format incompatibilities.

• BUG FIXES
  • PLAY
    • only updates the PLAY object when necessary - this will eliminate the time lag between manual movement of the PLAY item and the visible changes on the screen for Sgt Peppr cards. TIGA/#9Gxi was never effected by this bug.
    • Color changes are now queued. This prevents mid-refresh color changes to the background or item colors.
  • REMOTE CORTEX - CTRL-Break is now properly detected. The Greenleaf CommLib package automatically turns off CTRL-Break checking when a port is opened. It can be turned back on again using their function breakchk(ON);

• ENHNACEMENTS
• Remote cortex is fully operational. The necessary files are in \remcort. To use remote cortex, do the following:
• The data collection computer must run cortsend.exe
• The graphics computer must run one of the receive_cortex binarys: NNIOS: rcvnnctx.exe TIGA: rtigactx.exe TEST: rtestctx.exe // printf()s name of each function called VESA: rvesactx.exe // a 32 bit DOS4G program
  
  VESA requires the files DOS4GW.exe and pc8x8.fnt to be in the current directory.
• Both computers must have 16550 or better serial ports, and need to be connected by a null modem cable.
• The data computer needs the items, conditions, and timing files, as well as any color lookup tables listed in the conditions files.
• The graphics computer needs to have access to all bitmaps, movies, and pattern files listed in the items and conditions files.
• As the startup text indicates, if the serial connection hangs at any time, you can abort the current transfer using CTRL+ALT+SHIFT (all three at the same time). For example, if you disconnect the graphics computer before quitting cortsend.exe, cortsend will seem to hang while waiting for a response from receive_cortex. CTRL+ALT+SHIFT will fix this.
• Because of a bug in the commercial Greenleaf CommLib package used for the serial communications, some Windows 95 machines booted to DOS mode (rather than running a DOS window from within Win95) really do hang when the serial communications are shut down. This does not corrupt any of the saved CORTEX data, but can be a bit of a nuissance. I have not seen this problem on machines running Windows 3.1, or vanilla DOS, although booting a Win95 machine with a DOS6.2 system disk floppy doesn't help.
• CORTEX now supports unlimited numbers of items and conditions. A dummy example of this is in \source\demos\500.cnd.
• SERIAL HANDSHAKING - further streamlined to pass the absolute mininum number of bytes necessary to communicate graphics update messages. Should improve performance by about a factor of two.
• PLAY - on-screen representation of PLAY item now reflects the actual size, rotation, sweeping, and flashing speed of the PLAY object. This can be turned off from Params:General:"Show dynamic Play item position".
• UFNS - some cartesian <-> polar coordinate functions added: void polar2cartesian(float r, float theta, pfloat x, pfloat y); void cartesian2polar(float x, float y, pfloat r, pfloat theta); float polar2x(float r, float theta); float polar2y(float r, float theta); float cart2r(float x, float y); float cart2theta(float x, float y);
• Much larger movies are now supported. A simple example is found in \source\demos\canon177.mvi (a 177 frame movie).
• Added \docs\Demos.doc - brief documentation of files in \source\demos, and how to use them. This is a Word 7 document. Validated that all demo files work correctly.

• PROGRAMMER NOTES:
• rvesactx.exe is a 32 bit DOS4G program compiled under Watcom 10.6. The necessary project files are in \vesa. However, the commercial libraries necessary to rebuild this file have NOT been included in the general distribution.
• All other programs are compiled with Microsoft C/C++ version 1.0. To allow forward compatibility with a potential 32 bit version of CORTEX, a single common header file is now used for nearly all files. In addition, Microsoft's dos.h had to be ammended to update the union REGS structure: 32 bit machines use BYTEREGS, WORDREGS, and DWORDREGS like this:
  
  union REGS {
  

Other than a few minor bug fixes, the major impetus for this release was to ease porting of sections to 32 bit systems, and to ease the development and testing of GDP kernels for new graphics boards. Other than the usual annoyance of save file incompatibilities, this version is compatible with 5.5+

• BUG FIXES
• In PLAY, can now draw a zero sized object and have it disappear.
• In PLAY, bar width is now always orthogonal to direction of automatic sweeping.
• Fixed minor rounding bug: -x.5 was rounded to -x instead of -(x+1)
• In CSS, fixed bug in set_fixwin_params() which prevented fixation window from being resized.
• In Gkernel, fixed potential memory leak associated with bars which could not be drawn.

• REMOTE CORTEX
• MULTI_SPIKE now has optional 5th parameter - starting_bit. See cortex.cfg for documentation.

• PROGRAMMERS NOTES
• All "int"s replaced with "short"s, since "short" means 2 bytes, but "int" means 2 bytes on a 16 bit system, and 4 bytes on a 32 bit system. However, did not change the keyword for short integers in CSS: CSS files still use "int"s, but these are mapped internally to "short"s.
• \tigdp\pixinfo.c and \nngdp\pixinfo.c removed. Replaced with \graph\gbmpsize.c. As with \graph\gclt.c, the function BITMAPget_info() needs to be run on the graphics computer, but it is not really part of a GDP implementation. This was necessary to fascilitate the development of the GDP_DEBUG options below.
• Added GDP_DEBUG #define to \tigdp\tikernel.c and \graph\gclt.c. When compiled with nmake GDP_DEBUG=1, will cause ticortex, and/or rtigactx.exe to write a C file gdptest.c which contains all of the gkernel calls passed to the GDP module. Gdptest.c can be compiled and linked using nmake gdptest.exe to form an executable for use in testing new GDP implementations. The code for gdptest.exe is located at the very end of the makefile.
• Modified CMENUbool() to now return 0, 1, or -1 (last means ESC pressed) instead of just 0 or 1.
• Removed short timing loop from play.c which prevented PLAYupdate_positions() from being called faster than every 10 ms.

Note, as long as one upgrades their css_inc.h, there should be no 
incompatibilities between CORTEX5.5 and CORTEX5.5.1.

(1) BUG FIXES
        (a) Fixed slow memory leak in THREADadd() which was eventually causing
        errors like "CSS: unable to allocate 4000 bytes" for some people after
        long runs.

        (b) Fixed bug in Serial_Read().  Using the handshaking approach for
        remcort CSS Serial_*() functions tested to work reliably at
        19200bps, and intermittently at faster speeds.  For example, at 
        115200bps, using ser_test.tim and dosflow.exe, there is a dropped byte
        about every 1000 bytes.  Thus, if one uses a handshaking protocol
        which handles dropped bytes gracefully, faster speeds may be usable.
                Also added CSS file \source\demos\ser_test.tim which demonstrates
        the use of the Serial_*() functions.  In order to run this demo,
        you will need to do the following:
                (1) load ser_test.tim from Timing:Add
                (2) Load ser_test.tim from Timing:Help:ExternVar:create_Subset
                (3) run a terminal emulation program, such as dosterm.exe (in
                \remcort directory) to send/get data from CORTEX.  Can also use
                dosflow.exe, which allows you to send rapid blocks of data to
                test the integrity of the line.

(3) REMOTE CORTEX
        (a) The two computer version of CORTEX in which the master computer
        drives the slave graphics computer via a serial port, is now fully
        operational, and has been  tested for the #9gxi board (I don't have a
        NNIOS board with which to test it).

        (b) Handshaking streamlined to minimize number of bytes transferred.  
        (e.g. ints cast to chars, and then back again where possible).

        (c) CRC checks removed, since no communication errors found at 115200bps 
        using the Greanleaf serial communications package.  Errors were seen at
        these speeds using the Serial_*() functions, however, so will continue
        to use Greanleaf.

        (d) Found to be impractical to have two computers determine best 
        common speed.  Instead, both cortex.cfg and command line options can
        be used to specify the port and speed.
                (1) Cortex.cfg:         
                        COM_PORT                1       115200          // COM1 @ 115200bps
                (2) Command line:       ( com? @*bps)
                        cortsend        com1 @115200
                        rtigactx        com3 @57600
                        rcvnnctx        COM2 @38400
                        rtestctx        Com4 @19200

        (e) Executables used by REMCORT
                (1) cortsend:  Master front-end.  Reads items, conditions, and 
                timing files.  Also reads and uploads CLTs.  Runs CSS, passing
                graphics calls over serial line at up to 115200bps (reliably).

                (2) Slave (graphics) side:
                        rtigactx.exe:   TIGA based (e.g. #9Gxi)
                        rcvnnctx.exe:   NNIOS based (e.g. SgtPepper)
                        rtestctx:               Debug - prints message for commands rec'ved

        (f) Designed to be easy to add support for VESA or other graphics
        interface.

(4) MULTIPLE SPIKE ACQUISITION
        (a) Optional arguments to SPIKE_CHANNELS (greater than one arg), which 
        were added only with the last release, and which weren't fully tested,
        have been removed.  SPIKE_CHANNELS  is being retained
        for backwards compatibility.

        (b) New cortex.cfg syntax, MULTI_SPIKE, added:
                MULTI_SPIKE   <#spikes> 
        This allows users to specify up to 5 different spike input sources, with
        any combination of valid numbers of spikes, and user definable encode
        values.  CORTEX checks the validity of the  (i.e. makes
        sure you don't try to read in more spikes than a given board will
        support), and demands each  be declared via the DEVICE syntax.
        However, CORTEX does not check for overlaping encode values or 
        multiple declarations of a given device and port.

        e.g.
        MULTI_SPIKE     DASH16          0x03    2       1       // default for DASH16
        MULTI_SPIKE     PIO24           0x02    4       102     // 4 spikes from PIO24 port C
        MULTI_SPIKE     PIO24           0x00    8       1004    // 8 spikes from PIO24 port A
        MULTI_SPIKE     COMPUBOARD      0x03    2       1       // default for DASH16
        MULTI_SPIKE     COMPUBOARD      0x10    8       102     // 8 spikes from PIO24 port A
        MULTI_SPIKE     COMPUBOARD      0x12    4       1008    // 4 spikes from PIO24 port C

        (c) "THREAD  defaults" now internally maps to a single
        function, regardless of which device is specified.  This thread 
        processes all of the MULTI_SPIKE data acquisition, resets the latches,
        and optionally processes analog to digital arguments if DASH16 was one
        of the declared DEVICEs.
                When PIO24 or PIO96 are used by themselves, it is assumed that the
        control register is accessed via , and that the latches
        are reset with the commands 
                        outp((base_addr+2),0); 
                        outp((base_addr+2),0x10);
        Otherwise, it is assumed that the latches are connected to D01 on 
        the DASH16 (or the DASH16 part of a COMPUBOARD).

        (d) HISTOGRAM syntax within cortex.cfg now supports up to 16 spike
        channels, where the histogram number corresponds to the spike number.
        Additionally, the spike number is now printed on the screen whenever
        the histograms are updated.

(5) COLOR LOOKUP TABLES (CLT)s

        (a) Rewritten to optimize two-computer operation.  CORTEX supports
        multiple 256 entry color palettes (variously called CLTs or LUTs
        interechangeably).  Since the graphics boards do not necessarily
        support as many palettes as might be needed, CORTEX makes room for
        temporary CLTs, and allows data transfer between them and the
        graphics boards active CLT.  To optimize the speed of two computer
        operations, the temporary color palettes (CLTs) must reside on the
        graphics computer.  Thus, there are three classes of CLT operations:
                (1) get/change values of temporary CLTs
                        CLTrealloc_remote();
                        CLTfree_remote();
                        CLTupload();                    // multi:  from master to CLT
                        CLTdownload();                  // multi:  from CLT to master
                        CLTset_val();                   // single: from master to CLT
                        CLTget_val();                   // single: from CLT to master
                (2) Transfer data between temporary and active CLTs
                        CLTactivate();                  // multi: make CLT active on screen
                        CLTretrieve();                  // capture screen CLT into temp CLT
                (3) get/change values of CLT active on screen
                        GDPset_CLT();                   // from master to screen CLT
                        GDPget_CLT();                   // from screen CLT to master

        There are also CLT functions which interface with eventually call the
        functions listed above:
                (1) get/change values of temporary CLTs
                        get_CLT_val();                  
                        set_CLT_val();
                (2) Transfer data between temporary and active CLTs
                        GactivateCLT();         // calls CLTactivate, can be queued
                                GcolorLUT();            // #defined to GactivateCLT
                                GcolorLUTsubset();      // #defined to GactivateCLT
                        load_CLT();                     // calls CLTactivate immediately
                        load_CLT_subset();              // calls CLTactivate immediately
                (3) get/change values of active CLT
                        GcolorABS();                    // queued call to GDPset_CLT
                        GcolorREL();                    // queued call to GDPset_CLT
                        set_colorABS();         // immediate call to GDPset_CLT
                        set_colorREL();         // immediate call to GDPset_CLT
                (4) Accessory functions strictly on non-graphics side
                        GRAPHICSread_color_palette();
                        set_CLT_load_index();

        CLT functions expect CLT number to be base 1 (first = 1), and all
        RGB values to be between 0 and 255.

        (b) Added LUT:sTore and LUT:Retrieve menu entries.  These allow all
        CLTs to be written to/ read from disk separately from the save file.
        This will make it easier to use a standard set of color palettes with
        different versions of CORTEX, thus getting around the incompatibility
        of save files between versions.

        (c) Modified Gkernel (graphics kernel) slightly:  
                (1) Replaced GSEQ_LUT and GSEQ_LUT_SUBSET with GSEQ_ACTIVATE_CLT
                (2) Made GcolorLUT and GcolorLUTsubset #defines of GactivateCLT
                (3) Changed css_inc.h accordingly

        (d) Naming system standardized internally, and obsolete/redundant
        internal calls removed.  CLT is now the common extension.

        (e) Added \source\demos\luttest.2 file to test/demonstrate many
        of these function calls.

(6) MISCELLANEOUS
        (a) CSS infinite loops can now be aborted by pressing CTRL-BREAK 4
        times.  This will execute CSSabort().  If you are running remote cortex,
        and a communication error occurs such that the compters are out of sync,
        this won't fix the problem.

        (b) Modified MAKEFILE and some contingent files to eliminate linking
        errors for cortexcc, and minimize conditional compilation.
                (1) CSS_?s() macros redefined to not include pointer to functions
                when compiling ufnlst.c for cortexcc.exe.  SYSFN() macro added to 
                do the same thing for manually specified SystemFns.

                (2) GDPopen() modified to return 1 if connecting to fast graphics
                boards on which palette changes would be too fast if Gflush(0) not
                mapped to Gflush(1).  This removes need to conditional compilation
                for TIGA versus NNIOS.

                (3) Now correctly assesses whether executables are up to date.

        (c) Added MEMCHECK error checking ability to CORTEX.  If you suspect an
        error, remake CORTEX with
                nmake MEMCHECK=1 /A all
        and try to reproduce the problem.  MEMCHECK is completely transparant
        if the environment variable MEMCHECK is undefined, although it still
        makes the executable size a bit larger, so it is unclear whether it
        should remain linked in to the general distribution.

        (d) Modified /ufns/_system.c to work around internal compiler error
        in MSVC 1.0 in order to support memcmp().  Also modified
        /ufns/_system.c to support fopen(),fclose(), fread(), fwrite(), and
        system(), which would not compile correctly with MEMCHECK.

• GRAPHICS KERNEL
• Delayed color operations, using the CSS functions GcolorABS, GcolorREL(), GloadLUT(), and GloadLUTsubset() now have been confirmed to work for both NNIOS and TIGA. One order of operations note, however: All drawing operations are performed first. Then, once the electron guns get to the bottom of the screen, all color operations are performed. Thus, a sequence of commands like:
      Gon_off(TEST0,ON);
      GloadLUT(2);
      Gflush(1);
  will result in TEST0 being turned on, and then during the next frame, the new colors will become active. Thus, if TEST0's colors are changed by GloadLUT(2), then TEST0 will appear to flicker in color when it is turned on. The way around this is to know the order of operations and either change the color of TEST0 before turning it on, or have some objects which are unaffected by given palettes (since GloadLUTsubset() can selectively load the new palette to the proper location).

SERIAL COMMUNICATIONS

• CSS has several added functions, all beginning with "Serial_" to perform simple serial operations. The necessary macros have been added to css_inc.h. The available functions include: int Serial_Ready(void); // is there a character waiting to be read? int Serial_Read(void); // read a byte, if one is waiting void Serial_Write(char ch); // write a byte using polled output void Serial_Print(char *string,int cr); // write a string, optional     // carriage return (cr) int Serial_Open(int port_base, int baud, int configuration);     // open a serial port for use with these functions:     // port_base: base address: e.g. COM_1 = 0x3F8     // baud divisors: currently only up to SERIAL_BAUD_19200     // configuration: (send_bits | stop_bits | parity) int Serial_Close(void); // close the open port void Serial_Flush(void); // read and discard incoming data
• Remote CORTEX isn't quite done at this point. Everything works other than determining the fastest reliable connection speed between two computers.

• CORTVIEW
• two extra parameters have been added: use_popup, which makes the data appear in a scrollable popup window instead of streaming across the screen, and show_noncodes, which lets the user optionally view the EOG, EPP, and/or TOUCH_SCREEN data.
• CORTVIEW now uses the new encodes.h approach, so the user can regulate what is printout out and what is ignored.
• cortview is now included in the /util_bin directory.

• GRAPHICS KERNEL
• Gflush(1) in TIGA now actually waits until the graphical operations have completed before returning control to the user. Because of the way Gflush() has been changed, though, Gflush(0) may now return control so quickly as to be unusable. Internally, this has meant the conditional compilation of 3 files which normally use Gflush(0) to implement smooth motion. It was necessary to have them use Gflush(1) when compiled for TIGA.
• Color operations can now be queued. GcolorABS(), GcolorREL(), GloadLUT(), and GloadLUTsubset() have been added. Internally, color operations are added to a separate queue from movement operations, since TIGA implements color changes immediately. It was necessary to ensure that the vertical scan-line had passed the bottom of the bottom-most item before executing the color changes, otherwise odd banding would occur. These have also been implemented for NNIOS, but since I do not have a NNIOS setup, they have not been checked yet.
• The color operations have been added to the PLAY interface. Thus, fast color switching in PLAY will no longer slow down sweeping operations. In addition, it is now possible for PLAY items and running conditions to work together without interference. However, in order to modify the PLAY values, it is necessary to call timer_expired() (this function allows mouse and keyboard entries to be directed to PLAY.
• Gadd() has had an extra parameter added to it. It now takes and extra argument. This was necessary to properly support the Gcolor() and GloadLUTsubset() calls, which each require three parameters (e.g. GcolorABS(index,r,g,b)), instead of the usual two (e.g. GmoveABS(who,x,y)). All macros have been changed to reflect this. Naturally, Gadd_with_wait() also has an additional parameter. Internally, \tigdp\seq.c and \nngdp\seq.c had to be changed to support the extra parameter being passed.
• css_inc.h has been changed. Some of the values of the G_??? macros have been changed. There used to be a g_color #define. this was replaced with G_COLOR_ABS, and G_COLOR_REL, and G_COLOR_LUT_SUBSET were added. There was some minor number-value shifting involved, so use of the old values (instead of the macros, may yield odd graphical behavior. I apologize for any potential confusion. However, because of other changes to css_inc.h described next, all users should use the new versions anyway.

• ENCODES
• css_inc.h no longer directly include encode values. Instead, css_inc.h #includes , which has all the old values.
• CORTEX now reads the encodes.h file to generate the mapping between encode() values and the values printed from Run:Display or cortview. Cortex parses the encode values, expecting a format like
      #define SPIKE1 1 // optional comments
  Two other #defines are reserved, each of which can be used multiple times:
      #define DISPLAYABLE_ENCODES
      #define NONDISPLAYABLE_ENCODES
  #define values after the first will be visible from Run:Display, whereas values after the second will not. This way, one can specify high spike values (like #define SPIKE3 1000), or other user-defined values, and choose whether or not to have them clutter up the Run:Display menu.

• EPP values:
• EPP values (either when collected from 4 A2D channels, or when collected from the touch screen) now include the channel number in the low 4 bits.
• EPPconvert(), EPPunconvert() and EPPget_chan() have been added to CSS.

• COLOR palettes:
• The internal format of color lookup tables has been changed. The only affect that users will see is that they can load more than twice as many palettes now as in the past.
• Two functions have been added to CSS to allow dynamic changing of the dynamic color palettes (those which can be used to change the color palette on the graphics card using load_LUT_subset(), etc. These are set_CLT_val(int source, int index, int r, int g, int b) and get_CLT_val(int source, int index, pint r, pint g, pint b). Source is the LUT number (from 1 to n), and index is the color index (from 0-255).

• CONFIG
• Jamie Mazer added the ability to handle separate vertical and horizontal gains. Thus, the GRAPHICS_SPECS line in cortex.cfg now expects 7 arguments: .
• It is now possible to chain the original clock interrupt to the end of CORTEX's timer system. This is necessary for supporting devices whose legacy code has changed the system timer (for example Driss's touch screen). The syntax is THREAD chain_INT08
• Jamie Mazer added EOG_STYLE - lets eog-tracing be represented by erased dots, non-erased dots, or connected dots. See comments in cortex.cfg
• Jamie added A2D_GAIN for DASH16 boards. See his comments in cortex.cfg. I believe this is related to separate horizontal and vertical gains, although I am not certain.

• I/O
• Jamie Mazer added the use of an environmental variable named CORTDIR. When this is set, CORTEX will search for cortexcc, preppy, etc in that directory. This alleviates the problem of having to copy your state system files to the same directory as the exectutables and #include files.

• Serial Port Communication:

Serial Port operations should now be supported, although I have not had a chance to test how well they work (I lack the necessary setup). The file \ufns\_serial.c lists the functions, and the necessary macros have been appended to css_inc.h.

• Touch Screen:

Found bug - must chain original int08 by adding a line like

• I/O:
• CSS now supports fopen(), fread(), fprintf(), fscanf(), ... (all the f????() functions. The (FILE *)s stdio, stdin, and stderr are included in the ExternVars array. Since CSS does not currently support structures, I have temporarily called (FILE *)s plongs. As long as you do not try to modify the values returned by fopen(), etc, these functions will work just fine.
• restored the PIO24 functions get_digital_input(), get_a_input(), byte_out(), and byte_c_out() to CSS.
• Added "errno" to CSS's ExternVars for debugging of file access problems.

• COLOR:

Added a function "load_CLT_subset" which takes 4 arguments: int load_CLT_subset(int num_elements, int CLTsource, int srt_start, int dst_start);

• TOUCH_SCREEN:

Still trying to resolve some issues. Have changed all TOUCH_??? variables to volatile in the hopes that this will resolve the problem. Additionally,if the cortex.cfg line for TOUCH_SCREEN has a negative value for the ms_btwn_interrupts, a mouse emulation of the touch screen will be used. This is akin to the one in touch.h, but is written in C rather than CSS.

BUGS STILL TO FIX:

• Block problem with clear_circ_bufs (Giuseppe)

ENHANCEMENTS IN THE WORKS:

• Multiple simultaneous PLAY items
• Structs in CSS

This is an incomplete list of the changes between CORTEX5.3 and CORTEX5.4:
I have endeavered to fix all bugs which have been reported, as well as
implement a number of enhancement requests.

Thomas White
rev 6/30/95 (CORTEX5.0)
Email: