'
'
' ####################
' #####  PROLOG  #####
' ####################
'
PROGRAM	"SerRex"  ' 1-8 char program/file name without .x or any .extent
VERSION	"0.0.9"    ' version number - increment before saving altered program
'
' You can stop the PDE from inserting the following PROLOG comment lines
' by removing them from the prolog.xxx file in your \xb\xxx directory.
'
' Programs contain:  1: PROLOG          - no executable code - see below
'                    2: Entry function  - start execution at 1st declared func
' * = optional       3: Other functions - everything else - all other functions
'
' The PROLOG contains (in this order):
' * 1. Program name statement             PROGRAM "progname"
' * 2. Version number statement           VERSION "0.0000"
' * 3. Import library statements          IMPORT  "libName"
' * 4. Composite type definitions         TYPE <typename> ... END TYPE
'   5. Internal function declarations     DECLARE/INTERNAL FUNCTION Func (args)
' * 6. External function declarations     EXTERNAL FUNCTION FuncName (args)
' * 7. Shared constant definitions        $$ConstantName = literal or constant
' * 8. Shared variable declarations       SHARED  variable
'
' ******  Comment libraries in/out as needed  *****
'
IMPORT	"xma"   ' Math library     : SIN/ASIN/SINH/ASINH/LOG/EXP/SQRT...
IMPORT	"xcm"   ' Complex library  : complex number library  (trig, etc)
IMPORT	"xst"   ' Standard library : required by most programs
IMPORT	"xgr"   ' GraphicsDesigner : required by GuiDesigner programs
IMPORT	"xui"   ' GuiDesigner      : required by GuiDesigner programs
'
IMPORT "kernel32"
IMPORT "user32"

	TYPE CONVERT
		UNION
			UBYTE .ubyte
			STRING*1	.string
		END UNION
	END TYPE

DECLARE FUNCTION  Entry ()
DECLARE FUNCTION  SystemRexOpen ( CPort$, ctoParam )
DECLARE FUNCTION  SystemRexClose ()
DECLARE FUNCTION  SystemRexComm$ ( Command$, SendFF, Slow )
DECLARE FUNCTION WrapRexComm$ ( WhichCommand, Page$, Offset$, Data$ )
DECLARE FUNCTION  FindPort$ ( ctoParam )
DECLARE FUNCTION CalcRexChecksum$ ( Command$ )
DECLARE FUNCTION  ConvTime$ (outbuffer$)
'
' ######################
' #####  Entry ()  #####
' ######################
'
' Programs contain:
'   1. A PROLOG with type/function/constant declarations.
'   2. This Entry() function where execution begins.
'   3. Zero or more additional functions.
'
FUNCTION  Entry ()

	SHARED Debug
	SHARED hCom

' Default seetings
	Debug = 0
	LogFilename$ = ""
	hFile = -1


' start main program
	PRINT "Serrex          : Reading command file"

' check whether there is an input argument
	XstGetCommandLineArguments( @argCount, @argv$[] )
	IF (argCount>1)
		CommandFilename$ = argv$[1]
	ELSE
		CommandFilename$ = "serrex.cmd"
	ENDIF

' read command file
	XstLoadStringArray( @CommandFilename$, @commandLines$[] )

	count = UBOUND( commandLines$[] )
	IF (commandLines$[])

		PRINT "Serrex          : Found", count, "executable commands"

		'open port
		ctoParam = 1000														' dont know what this one does
		PcCommPort$ = FindPort$( ctoParam )
		SystemRexOpen( PcCommPort$, ctoParam )

		'loop through lines in commandfile
		FOR n=1 TO count

			'parse words in commandline
			'and drop comment lines
			index =  1
			IF (MID$(commandLines$[n-1],1,1)!="#")
				commandField1$ = XstNextField$( commandLines$[n-1], @index, @done )
				commandField2$ = XstNextField$( commandLines$[n-1], @index, @done )
				commandField3$ = XstNextField$( commandLines$[n-1], @index, @done )
				commandField4$ = XstNextField$( commandLines$[n-1], @index, @done )
				commandField5$ = XstNextField$( commandLines$[n-1], @index, @done )
				commandField1 = ULONG( commandField1$ )
				commandField2 = ULONG( commandField2$ )
				commandField3 = ULONG( commandField3$ )
				commandField4 = ULONG( commandField4$ )
				commandField5 = ULONG( commandField5$ )

				'check for special non executable commandlines
				IF (commandField1=0)

					IF (commandField1$="Debug")
						Debug = commandField2
					ENDIF
					IF (commandField1$="LogFilename")
						IF (hFile!=-1)
							dummy = CloseHandle( hFile )
						ENDIF
						LogFilename$ = commandField2$
						hFile = CreateFileA(&LogFilename$,ULONG($$GENERIC_READ)| ULONG($$GENERIC_WRITE), 0, 0, ULONG($$CREATE_ALWAYS), 0, 0)
					ENDIF
					IF (commandField1$="DataInFilename")
						DataInFilename$ = commandField2$
					ENDIF
					IF (commandField1$="DataOutFilename")
						DataOutFilename$ = commandField2$
					ENDIF

				'otherwise execute command
				ELSE

					WhichCommand = ULONG(commandField1)
					Page1$ = commandField2$
					Page2$ = commandField3$
					fileName$ = commandField4$

					SELECT CASE WhichCommand

						CASE 8:

							IF LEN(Page1$)<4
								p1 = ULONG(Page1$)
								p2 = ULONG(Page2$)
								outbuffer$ = ""
								FOR m=p1 TO p2
									FOR l=0 TO 0
										offset$ = HEX$(l*512,4)
										outbuffer$ = outbuffer$ + WrapRexComm$( WhichCommand, HEX$(m,4), offset$, "")
									NEXT l
								NEXT m
							ENDIF

							IF LEN(fileName$)>0
								sFile = OPEN( fileName$, $$WRNEW )
								WRITE[sFile], outbuffer$
								CLOSE( sFile )
							ENDIF

						CASE 9:

							IF LEN(Page1$)<4
								p1 = ULONG(Page1$)
								p2 = ULONG(Page2$)
								outbuffer$ = ""
								FOR m=p1 TO p2
									outbuffer$ = outbuffer$ + WrapRexComm$( WhichCommand, HEX$(m,4), "", "")
								NEXT m
							ENDIF

							IF LEN(fileName$)>0
								sFile = OPEN( fileName$, $$WR )
								WRITE[sFile], outbuffer$
								CLOSE( sFile )
							ENDIF

						CASE 10:

							PRINT "not implemented yet"

						CASE 11:

							PRINT "not implemented yet"

						CASE ELSE

							Data$ = commandData$
							outbuffer$ = WrapRexComm$( WhichCommand, Page$, Offset$, Data$ )

					END SELECT

				ENDIF

			ENDIF

		NEXT n

		IF (hFile!=-1)
			dummy = CloseHandle( hFile )
		ENDIF

		PRINT "Serrex          : Terminated"

	ELSE

		PRINT "Command file empty or non-existent. Terminating serrex"

	ENDIF



'	FOR i=110 TO 120
'		WhichCommand = 8
'		Page$ = HEX$(i,4)
'		Data$ = "01F4"
'		FOR n=15 TO 15
'			Offset$ = HEX$(n*512,4)
'			outbuffer$ = "|---"+Page$+Offset$+"--->"
'			numwritten = 0
'			dummy = WriteFile(hFile,&outbuffer$,LEN(outbuffer$),&numwritten,0)
'			outbuffer$ = WrapRexComm$( WhichCommand, Page$, Offset$, Data$ )
'			numwritten = 0
'	 dummy = WriteFile(hFile,&outbuffer$,LEN(outbuffer$),&numwritten,0)
'		NEXT n
'		PRINT i
'	NEXT i

'	WhichCommand = 9
'	Page$ = HEX$(47,4)
'	Offset$ = HEX$(0*512,4)
'	Data$ = "0200"
'	numwritten = 0
'	outbuffer$ = WrapRexComm$( WhichCommand, Page$, Offset$, Data$ )
'			numwritten = 0
'			dummy = WriteFile(hFile,&outbuffer$,LEN(outbuffer$),&numwritten,0)

'	WhichCommand = 11
'	Page$ = HEX$(47,4)
'	Offset$ = HEX$(0*512,4)
'	Data$ = CHR$(65,512)
'	numwritten = 0
'	outbuffer$ = WrapRexComm$( WhichCommand, Page$, Offset$, Data$ )

'	WhichCommand = 12
'	Page$ = "0080"
'	Offset$ = HEX$(0*512,4)
'	Data$ = CHR$(65,512)
'	numwritten = 0
'	outbuffer$ = WrapRexComm$( WhichCommand, Page$, Offset$, Data$ )

'	WhichCommand = 9
'	Page$ = HEX$(47,4)
'	Offset$ = HEX$(0*512,4)
'	Data$ = "0200"
'	numwritten = 0
'	outbuffer$ = WrapRexComm$( WhichCommand, Page$, Offset$, Data$ )
'			numwritten = 0
'			dummy = WriteFile(hFile,&outbuffer$,LEN(outbuffer$),&numwritten,0)

'		WhichCommand = 8
'		outbuffer$ = WrapRexComm$( WhichCommand, "0002", "0000", Data$ )
'		numwritten = 0
'		dummy = WriteFile(hFile,&outbuffer$,LEN(outbuffer$),&numwritten,0)


		'close the port
		SystemRexClose ()

END FUNCTION
'
'
' ##############################
' #####  SystemRexOpen ()  #####
' ##############################
'
FUNCTION  SystemRexOpen ( CPort$, ctoParam )

	SHARED Debug
	SHARED hCom

	DCB dcb
  COMMTIMEOUTS cto

  cto.ReadIntervalTimeout = ctoParam
  cto.ReadTotalTimeoutMultiplier = 0
  cto.ReadTotalTimeoutConstant = ctoParam
  cto.WriteTotalTimeoutMultiplier = 0
  cto.WriteTotalTimeoutConstant = ctoParam


	hCom = CreateFileA(&CPort$,ULONG($$GENERIC_READ)| ULONG($$GENERIC_WRITE), 0, 0, ULONG($$OPEN_EXISTING), 0, 0)

	IF (Debug>1) THEN
		IF (hCom>0) THEN
			PRINT "SystemRexOpen   : CreateFile Succeded"
		ELSE
			PRINT "SystemRexOpen   : CreateFile Failed"
			RETURN 0
		ENDIF
	ELSE
		IF (hCom=0) THEN
			PRINT "SystemRexOpen   : CreateFile Failed"
			RETURN 0
		ENDIF
  ENDIF

	dummy = SetCommMask( hCom, 1 )

	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexOpen   : SetCommMask Succeded"
		ELSE
			PRINT "SystemRexOpen   : SetCommMask Failed"
			RETURN 0
		ENDIF
	ELSE
		IF (dummy=0) THEN
			PRINT "SystemRexOpen   : SetCommMask Failed"
			RETURN 0
		ENDIF
	ENDIF

  dummy = SetupComm(hCom,8212,8212)
	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexOpen   : SetupComm Succeded"
		ELSE
			PRINT "SystemRexOpen   : SetupComm Failed"
			RETURN 0
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexOpen   : SetupComm Failed"
			RETURN 0
		ENDIF
 	ENDIF

	dummy = SetCommTimeouts(hCom,&cto)
	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexOpen   : SetCommTimeouts Succeded"
		ELSE
			PRINT "SystemRexOpen   : SetCommTimeouts Failed"
			RETURN 0
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexOpen   : SetCommTimeouts Failed"
			RETURN 0
		ENDIF
 	ENDIF

	dummy = GetCommState(hCom,&dcb)
	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexOpen   : GetCommState Succeded"
		ELSE
			PRINT "SystemRexOpen   : GetCommState Failed"
			RETURN 0
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexOpen   : GetCommState Failed"
			RETURN 0
		ENDIF
 	ENDIF

  dcb.BaudRate = 57600
	dcb.Parity = 0
	dcb.StopBits = 0
  dummy =	SetCommState(hCom,&dcb)
	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexOpen   : SetCommState Succeded"
		ELSE
			PRINT "SystemRexOpen   : SetCommState Failed"
			RETURN 0
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexOpen   : SetCommState Failed"
			RETURN 0
		ENDIF
 	ENDIF

	RETURN 1

END FUNCTION
'
'
' ###############################
' #####  SystemRexClose ()  #####
' ###############################
'
FUNCTION  SystemRexClose ()

	SHARED Debug
	SHARED hCom

	dummy = CloseHandle( hCom )
	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexClose  : Succeded"
		ELSE
			PRINT "SystemRexClose  : Failed"
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexClose  : Failed"
		ENDIF
  ENDIF

END FUNCTION
'
' ##############################
' #####  SystemRexComm$ ()  ####
' ##############################
'
FUNCTION  SystemRexComm$ ( Command$, SendFF, Slow )

	SHARED Debug
	SHARED hCom

	tx1 = 0xFF

	numwritten = 0
	numread = 0
	numread2 = 0
	outbuffer$ = CHR$(0,8212)
	outbuffer2$ = CHR$(0,8212)

	IF (SendFF=1) THEN

' write first character to port
 		dummy = WriteFile(hCom,&tx1,ULONG(1),&numwritten,0)
		IF (Debug>1) THEN
			IF (dummy=1) THEN
				PRINT "SystemRexComm$  : 1st FF Succeded"
			ELSE
				PRINT "SystemRexComm$  : 1st FF Failed"
			ENDIF
		ELSE
			IF (dummy<>1) THEN
				PRINT "SystemRexComm$  : 1st FF Failed"
			ENDIF
  	ENDIF

'write second character to port
		dummy = WriteFile(hCom,&tx1,ULONG(1),&numwritten,0)
		IF (Debug>1) THEN
			IF (dummy=1) THEN
				PRINT "SystemRexComm$  : 2nd FF Succeded"
			ELSE
				PRINT "SystemRexComm$  : 2nd FF Failed"
			ENDIF
		ELSE
			IF (dummy<>1) THEN
				PRINT "SystemRexComm$  : 2nd FF Failed"
			ENDIF
  	ENDIF


' hopefully we won"t need this, because I don"t know the right params
'lpError = $$CE_BREAK
'lpStatus = ULONG(0)
'dummy = ClearCommError(hCom,&lpError,&lpStatus)

	ENDIF


'write the actual command to the Rex
	dummy = WriteFile(hCom,&Command$,ULONG(LEN(Command$)),&numwritten,0)
	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexComm$  : Sending command succeded"
		ELSE
			PRINT "SystemRexComm$  : Sending command failed"
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexComm$  : Sending command failed"
		ENDIF
  ENDIF

	dummy = FlushFileBuffers(hCom)
	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexComm$  : Flushing buffer succeded"
		ELSE
			PRINT "SystemRexComm$  : Flushing buffer failed"
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexComm$  : Flushing buffer failed"
		ENDIF
  ENDIF

'read what we got
	IF (Slow>0) THEN
		PRINT "SystemRexComm$  : Waiting",Slow/1000,"secs"
		XstSleep( Slow )
	ENDIF
	dummy = ReadFile(hCom,&outbuffer$,8212,&numread,0)
	outbuffer$ = MID$(outbuffer$,1,numread)

'check for answer type
	IF (MID$(outbuffer$,1,1)="N") THEN
		PRINT "Error"
	ELSE
		IF (MID$(outbuffer$,1,4)!="OK9A") THEN
			numtoread = ULONG("0x"+MID$(outbuffer$,3,4))+12
			count = 1
			DO WHILE ( (numread<numtoread) & (count<=10) )
				XstSleep(200)
				outbuffer2$ = CHR$(0,8212)
				dummy = ReadFile(hCom,&outbuffer2$,8212,&numread2,0)
				outbuffer2$ = MID$(outbuffer2$,1,numread2)
				outbuffer$ = outbuffer$+outbuffer2$
				numread = numread+numread2
				count = count+1
			LOOP
		ENDIF
	ENDIF

	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "SystemRexComm$  : Reading succeded"
		ELSE
			PRINT "SystemRexComm$  : Reading failed"
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "SystemRexComm$  : Reading failed"
		ENDIF
  ENDIF

	RETURN outbuffer$

END FUNCTION
'
'
' ############################
' #####  WrapRexComm$ ()  ####
' ############################
'
FUNCTION  WrapRexComm$ ( WhichCommand, Page$, Offset$, Data$ )

	SHARED Debug
	SHARED hCom

	SELECT CASE WhichCommand
		CASE 1:										'initialize session
			Command$ = "DSBS0000"
			SendFF = 1
			Slow = 0
		CASE 2:										'get firmware version
			Command$ = "DSVR"
			SendFF = 0
			Slow = 0
		CASE 3:										'get Rex time
			Command$ = "DSTR"
			SendFF = 0
			Slow = 0
		CASE 4:										'set Rex time
			Command$ = "DSTW"
			outbuffer$ = ConvTime$("1")
			Command$ = Command$+outbuffer$
			SendFF = 0
			Slow = 0
		CASE 5:										'defragment memory
			Command$ = "DSSG"
			SendFF = 0
			Slow = 5000
		CASE 6:										'end session
			Command$ = "DSBE"
			SendFF = 0
			Slow = 0
		CASE 7:										'Rex id?, misc info
			Command$ = "DSPR"
			SendFF = 0
			Slow = 0
		CASE 8:										'read a standard record
			Command$ = "DSSR"
			Command$ = Command$+Page$+Offset$+"01F40001"
			SendFF = 0
			Slow = 0000
		CASE 9:										'read a 8k physical page
			Command$ = "DSFR"
			Command$ = Command$+Page$+"000020000001"
			SendFF = 0
			Slow = 0500
		CASE 10:									'write into userspace
			Command$ = "DSSW"
			Command$ = Command$+Page$+Offset$+HEX$(LEN(Data$),4)+"0001"
			SendFF = 0
			Slow = 0000
		CASE 11:									'write into firmware
			Command$ = "DSFW"
			Command$ = Command$+Page$+Offset$+HEX$(LEN(Data$),4)+"0001"
			SendFF = 0
			Slow = 0000
		CASE 12:										'erase firmware block (8 pages)
			Command$ = "DSFE"
			Command$ = Command$+Page$
			SendFF = 0
			Slow = 0000
	END SELECT

	IF (Debug>0)
		PRINT "WrapRexComm     : Sending ",Command$
	ENDIF

	Csum$ = CalcRexChecksum$( Command$ )
	Command$ = Command$ + Csum$ + CHR$(10)
	outbuffer$ = SystemRexComm$( Command$, SendFF, Slow )

	IF ((WhichCommand=10) | (WhichCommand=11))
		IF (Debug>0)
			PRINT "WrapRexComm     : Received ",LEN(outbuffer$),"bytes"
			PRINT "WrapRexComm     : Received ",outbuffer$
		ENDIF
		Csum$ = CalcRexChecksum$( Data$ )
		Command$ = Data$ + Csum$ + CHR$(10)
		IF (Debug>0)
			PRINT "WrapRexComm     : Sending Data ",Command$
		ENDIF
		outbuffer$ = SystemRexComm$( Command$, SendFF, 0000 )
	ENDIF

	IF (Debug>0)
		PRINT "WrapRexComm     : Received ",LEN(outbuffer$),"bytes"
		PRINT "WrapRexComm     : Received ",outbuffer$
	ENDIF

	SELECT CASE WhichCommand
		CASE 1:
		CASE 2:
		CASE 3:
			outbuffer$ = ConvTime$(outbuffer$)
			PRINT "WrapRexComm     : RexTime is ",outbuffer$
		CASE 4:
			outbuffer$ = ConvTime$(outbuffer$)
			PRINT "WrapRexComm     : RexTime set to ",outbuffer$
		CASE 5:
		CASE 6:
		CASE 7:
			PRINT "WrapRexComm     : Rex serial no",MID$(outbuffer$,7,12)
		CASE 8:
			outbuffer2$ = MID$(outbuffer$,10,LEN(outbuffer$)-12)
			csum$ = CalcRexChecksum$(outbuffer2$)
			csum2$ = MID$(outbuffer$,LEN(outbuffer$)-2,2)
			IF ( csum2$ = csum$ ) THEN
				outbuffer$ = outbuffer2$
			ELSE
				PRINT "checksum does not agree", csum$,csum2$
			ENDIF
		CASE 9:
			outbuffer2$ = MID$(outbuffer$,6,LEN(outbuffer$)-8)
			csum$ = CalcRexChecksum$(outbuffer2$)
			csum2$ = MID$(outbuffer$,LEN(outbuffer$)-2,2)
			IF ( csum2$ = csum$ ) THEN
				outbuffer$ = outbuffer2$
			ELSE
				PRINT "checksum does not agree", csum$,csum2$
			ENDIF
	END SELECT

	RETURN outbuffer$

END FUNCTION
'
'
' ##########################
' #####  FindPort$ ()  #####
' ##########################
'
FUNCTION  FindPort$ ( ctoParam )

	SHARED Debug

	IF (dummy=0) THEN
		port$ = "COM1:"
		dummy = SystemRexOpen( port$, ctoParam )
	ENDIF

	IF (dummy=0) THEN
		port$ = "COM2:"
		dummy = SystemRexOpen( port$, ctoParam )
	ENDIF

	IF (dummy=0) THEN
		port$ = "COM3:"
		dummy = SystemRexOpen( port$, ctoParam )
	ENDIF

	IF (dummy=0) THEN
		port$ = "COM4:"
		dummy = SystemRexOpen( port$, ctoParam )
	ENDIF

	IF (Debug>1) THEN
		IF (dummy=1) THEN
			PRINT "FindPort$       : Opened", port$, "for communication"
		ELSE
			PRINT "FindPort$       : Failed to open COM port"
		ENDIF
	ELSE
		IF (dummy<>1) THEN
			PRINT "FindPort$       : Failed to open COM port"
		ENDIF
  ENDIF

	IF (dummy=1) THEN
		SystemRexClose()
		RETURN port$
	ELSE
		RETURN "0"
	ENDIF

END FUNCTION
'
'
' ################################
' #####  CalcRexChecksum ()  #####
' ################################
'
FUNCTION  CalcRexChecksum$ ( Command$ )

	SHARED Debug

	CONVERT c

	dummy = 0

	FOR i = 1 TO LEN(Command$)
		c.string = MID$(Command$,i,1)
		dummy = dummy + c.ubyte
	NEXT i
	dummy = dummy MOD 256

	IF (Debug>1) THEN
		PRINT "CalcRexChecksum :",HEX$(dummy,2)
	ENDIF

	dummy$ = HEX$(dummy,2)

	RETURN dummy$

END FUNCTION
'
'
' #########################
' #####  ConvTime ()  #####
' #########################
'
FUNCTION  ConvTime$ (rextimestring$)

	IF (LEN(rextimestring$)>20) THEN
		yyyy$ = MID$(rextimestring$,3,4)
		mmmm$ = MID$(rextimestring$,7,4)
		dddd$ = MID$(rextimestring$,11,4)
		hhhh$ = MID$(rextimestring$,15,4)
		mmmi$ = MID$(rextimestring$,19,4)
		ssss$ = MID$(rextimestring$,23,4)
		year = ULONG("0x"+yyyy$)
		month = ULONG("0x"+mmmm$)
		day = ULONG("0x"+dddd$)
		hour = ULONG("0x"+hhhh$)
		minute = ULONG("0x"+mmmi$)
		second = ULONG("0x"+ssss$)
		outbuffer$ = STRING$(year)+"-"+STRING$(month)+"-"+STRING$(day)+" "+STRING$(hour)+":"+STRING$(minute)+":"+STRING$(second)
	ELSE
		year = 0
		month = 0
		day = 0
		hour = 0
		minute = 0
		second = 0
		weekday = 0
		millisecond = 0
		XstGetLocalDateAndTime(@year,@month,@day,@weekday,@hour,@minute,@second,@millisecond)
		yyyy$ = HEX$(year,4)
		mmmm$ = HEX$(month,4)
		dddd$ = HEX$(day,4)
		hhhh$ = HEX$(hour,4)
		mmmi$ = HEX$(minute,4)
		ssss$ = HEX$(second,4)
		rextimestring$ = yyyy$ + mmmm$ + dddd$ + hhhh$ + mmmi$ + ssss$
		outbuffer$ = rextimestring$

	ENDIF

	RETURN outbuffer$

END FUNCTION
END PROGRAM