ondemand ovl load pretty much working

loadlvl.py

@@ -18,310 +18,565 @@
 # - reduced sleeps
 # - inc var i with chunkSize
 
+
+#TODO
+# - reduce/remove sleeps
+# - keep listening!
+
 import sys
+import os
 import serial
 import time
+import calendar
 import math
+import signal
+
+DEBUG = 1
+
+# Working directory
+
+cwd = os.getcwd()
+
+levelsFolder = cwd + os.sep + os.sep
+
+# Receive commands from PSX
+# ~ Run = True
+
+Listen    = 1 
+
+uniDebugMode = 0
+
+Command = ""
+
+memAddr = ""
+
+flagAddr = ""
+
+loadFile = ""
+
+# One byte
+
+uno = int(1).to_bytes(1, byteorder='little', signed=False)
+
+data = 0
+
+# ~ dataSize = 0
+
+# Serial connection setup
 
 ser = serial.Serial('/dev/ttyUSB0')
 
+# Unirom can do 115200 and 510000 ( https://github.com/JonathanDotCel/NOTPSXSerial/blob/bce29e87cb858769fe60eb34d8eb123f9f36c8db/NOTPSXSERIAL.CS#L842 )
+
 ser.baudrate = '115200'
 
+# The data needs to be split in 2K chunks 
+
 chunkSize = 2048
 
-responseBuffer = ''
+numChunk = 0
 
-address = '800b1470' # We're receiving this info as a string from the psx
+# checkSum is the checkSum for the full data
 
-# test data
+checkSum = 0
 
-data = int(111111111111111111111111111111111).to_bytes(14, byteorder='little', signed=False)
+# If set, it means the data transfer has been initiated 
 
-size = len( data )
+Transfer = 0
 
-checkSum = 0 # should be 1701
+# Delay between write operations. These seem to be needed for the connection not to hang.
 
-Ssbin = 0
+sleepTime = 0.08    # Seems like safe minimum
 
-Saddr = 0
+def sig_interrupt_handler(signal, frame):
     
-Slen = 0
+    global Run
+    
+    Run = False
+
+def setDEBG():
+    
+    global sleepTime, ser, uniDebugMode
+    
+    if DEBUG:
+        
+        print("Sending DEBG command...")
+    
+    ser.write( bytes( 'DEBG' , 'ascii' ) )
+    
+    time.sleep(sleepTime)
+                
+    # Empty in waiting buffer
+    
+    ser.reset_input_buffer()
+    
+    time.sleep(sleepTime)
+    
+    uniDebugMode = 1
 
 def WaitForResponse( expectedAnswer ):
 
+    # Get incoming data from the serial port in a rolling buffer 
+    # when the content of the buffer corresponds to 'expectedAnswer', returns True
+    
+    global DEBUG
+    
     responseBuffer = ""
     
+    success = False
+    
     while True:
         
+        # If data in serial's incoming buffer
+        
         if ser.in_waiting:
         
-            print( "Input buffer : " + str(ser.in_waiting))
+            # Read 1 byte
         
-            chkValue = ser.read(1)
+            byteValue = ser.read(1)
             
-            # Make sure byte value is < 128 so that it can be decoded to ascii :: always getting '\xc7' 'q' '\x1c' '\xc7'  '\xab' '\xed' '1' '\x05'
+            # Make sure byte value is < 128 so that it can be decoded to ascii
             
-            if chkValue[0] < 128:
+            if byteValue[0] < 128:
             
-                responseBuffer += chkValue.decode('ascii')  
+                responseBuffer += byteValue.decode('ascii')  
             
             else:
                 
                 responseBuffer += '.'
             
+            # Always keep response buffer 4 chars long
+            
             if len( responseBuffer ) > 4:
                 
-                # remove first char in buffer
+                # Remove first char in buffer
                 
                 responseBuffer = responseBuffer[1:]
             
-                print( "Response buffer : " + responseBuffer )
             
+            # If response is ERR!, checksum check does not check, so check it again
             
-            if responseBuffer == expectedAnswer:
+            if responseBuffer == "ERR!":
+                
+                success = False
                 
                 break
                 
-    print( "Got response : " + responseBuffer + " - " + expectedAnswer )
+            # When expected response shows up, break from the while loop
             
-def main(args):
+            if responseBuffer == expectedAnswer:
                 
-    global checkSum, responseBuffer, Ssbin, Saddr, Slen, chunkSize
+                success = True
                 
+                break
+    if DEBUG:
     
-    # Just to be sure 
+        print( "Got : " + responseBuffer )
+    
+    return success
+    
+def CalculateChecksum( inBytes, skipFirstSector = False):
+    
+    returnVal = 0;
+    
+    i = 0
+    
+    if skipFirstSector:
+        
+         i = 2048
+    
+    while i < len( inBytes ):
+
+        returnVal += inBytes[i];
+        
+        i += 1
+    
+    return returnVal;
+
+def WriteBytes( inData ):
+    
+    if DEBUG:
+        
+        print("Preparing to write bytes...")
+        
+    global chunkSize, numChunk
+    
+    # BEGIN WHILE DATA
+    
+    i = 0
+    
+    while i < len( inData ):
+        
+        # BEGIN WHILE TRUE
+        
+        while True:
+            
+            # BEGIN TRY/EXCEPT
+            
+            try:
+                    
+                # Calculate number of 2K chunks we're about to send
+                
+                numChunk = math.ceil( len( inData ) / chunkSize )
+                
+                # Calculate current chunk
+                
+                currentChunk = math.ceil( (i + 1) / chunkSize)                
+                
+                if DEBUG:
+                    
+                    print( str ( numChunk + 1 - currentChunk ) + " chunks to send" )
+                
+                # Avoid going out of range
+                
+                if ( i + chunkSize ) > len( inData ):
+                    
+                    chunkSize = len( inData ) - i
+                    
+                print("Writing chunk " + str( currentChunk ) + " of " + str( numChunk ) )
+                                
+                # ~ ser.write(inData)
+
+                chunkChecksum = 0
+                
+                # Send inData in 2048B chunks
+                
+                for byte in range( chunkSize ):
+                    
+                    # Send byte
+                    
+                    ser.write( inData[ i + byte ].to_bytes(1, byteorder='little', signed=False) )
+                    
+                    # Calculate chunk checksum
+                    
+                    chunkChecksum += inData[ i + byte ]
+                                            
+                time.sleep(sleepTime)
+                
+                if DEBUG:                        
+                
+                    print( "Chunk cheksum : " + str( chunkChecksum ) ) 
+                
+                # Wait for output buffer to be empty
+                # REMOVE ? Is this needed ?
+                
+                while ser.out_waiting:
+                    
+                    print("*")
+                    
+                    wait += 1
+                
+                time.sleep(sleepTime)
+                
+                # Wait for unirom to request the checksum
+                
+                if DEBUG:
+                
+                    print( "Chunk " + str( currentChunk ) + " waiting for unirom to request checksum (CHEK)..." )
+                
+                WaitForResponse( "CHEK" )
+                
+                # Send checksum
+                
+                if DEBUG:
+                
+                    print( "Sending checksum to unirom..." );
+                
+                # ~ chunkChecksum = 170
+                
+                bytesChunkChecksum = chunkChecksum.to_bytes( 4, byteorder='little', signed = False )
+                
+                ser.write( bytesChunkChecksum )
+                
+                # ~ time.sleep( sleepTime )
+            
+                if DEBUG:
+                    
+                    print( "Waiting for unirom to request more data (MORE)..." )
+            
+                # Wait for unirom to request MORE inData ( next chunk )
+            
+                if not WaitForResponse("MORE"):
+                    
+                    if DEBUG:
+                        
+                        print("ERROR ! Retrying...")
+
+                    raise Exception()
+            
+                if DEBUG:
+                    
+                    print( str( currentChunk ) + " chunk sent with correct checksum.")
+        
+                # Increment i from chunkSize
+        
+                i += chunkSize
+                
+            except Exception:
+                
+                continue
+            
+            # END TRY/EXCEPT
+            
+            break
+        
+        # END WHILE TRUE
+    
+        numChunk = 0
+    
+    # END WHILE DATA
+
+def SendBin( inData, memAddr ):
+    
+    global sleepTime 
+    
+    dataSize = len( inData )
+    
+    if DEBUG:
+        
+        print("Data size : " + str( dataSize ) )
+    
+    # Prepare unirom for data reception - sent "SBIN" - received : "OKV2"
+    
+    if DEBUG:
+        
+        print("Sending SBIN command...")
+    
+    ser.write( bytes( 'SBIN' , 'ascii' ) )
+    
+    time.sleep(sleepTime)
+    
+    # We're using unirom in debug mode, which means protocol version 2 is available
+    # Upgrade protocol  - sent "UPV2" - received : "OKAY"
+    
+    ser.write( bytes( 'UPV2' , 'ascii' ) )
+
+    time.sleep(sleepTime)
+
+    # Initialisation done, set flag
+    
+    # ~ Init = 1
+    
+    # From now on, we're using the rolling buffer
+    if DEBUG:
+        
+        print("Waiting for OKAY...")
+    
+    WaitForResponse("OKAY")
+    
+    # Calculate data checkSum
+
+    checkSum = CalculateChecksum( inData )
+
+    if DEBUG:
+        
+        print("checkSum : " + str(checkSum) )
+    
+    # Send memory address to load data to, size of data and checkSum
+    # Unirom expects unsigned longs ( 32bits ), byte endianness little
+    
+    # Convert address from string to integer, then to ulong 32b
+    
+    bytesAddr = int( memAddr, 16 ).to_bytes( 4, byteorder='little', signed=False )
+    
+    # Write address to serial
+    
+    ser.write( bytesAddr )
+    
+    time.sleep(sleepTime)
+    
+    # Convert and write int size to serial
+    
+    bytesSize = dataSize.to_bytes( 4, byteorder='little', signed = False )
+    
+    ser.write( bytesSize )
+    
+    time.sleep(sleepTime)
+    
+    # Convert and write int chekSum to serial
+    
+    bytesChk = checkSum.to_bytes( 4, byteorder='little', signed = False )
+    
+    ser.write( bytesChk )
+    
+    time.sleep(sleepTime)
+
+    # Send dat data
+    
+    WriteBytes( inData )
+
+def resetListener():
+    
+    global checkSum, data, Listen, Transfer, dataSize, memAddr, loadFile, flagAddr
+    
+    memAddr = ""
+
+    flagAddr = ""
+    
+    loadFile = ""
+    
+    checkSum = 0
+    
+    data = 0
+    
+    dataSize = 0
+    
+    Transfer = 0
+    
+    Listen = 1
 
     ser.reset_input_buffer()
     
     ser.reset_output_buffer()
     
-    i = 0
     
-    while i < len( data ):
 
-        checkSum += data[i];
+def main(args):
     
-        i += 1
+    # ~ signal.signal(signal.SIGINT, sig_interrupt_handler)
     
-    print("checkSum : " + str(checkSum) )
+    # ~ global Run, memAddr
     
-    # ~ while True:
+    while True:
     
-    # ~ global responseBuffer, Ssbin, Saddr, Slen, chunkSize
+        global checkSum, chunkSize, data, Listen, Transfer, dataSize, memAddr, loadFile, flagAddr
         
-    if not Ssbin:
+        # Flush serial buffers to avoid residual data
-        
-        print("Sending DEBG command...")
-        
-        ser.write( bytes( 'DEBG' , 'ascii' ) )
-        
-        time.sleep(.3)
-                    
-        # Empty in waiting buffer to get rid of 'DEBGOKAY'
         
         ser.reset_input_buffer()
         
-        time.sleep(.5)
+        ser.reset_output_buffer()
         
-        print("Sending SBIN command...")
+        inputBuffer = ""
             
-        ser.write( bytes( 'SBIN' , 'ascii' ) )
+        # Listen to incomming connections on serial
         
-        time.sleep(.1)
+        if Listen:
 
-        ser.write( bytes( 'UPV2' , 'ascii' ) )
 
-        Ssbin = 1
+            print("Listening for incoming data...")
             
-        time.sleep(.1)
+            if DEBUG:
             
-        # ~ while True:
+                print("memAddr : " + str(memAddr) + " - loadFile" + loadFile )
             
-            #while ser.in_waiting:
+            while True:
-            # ~ print(".")
 
-            # ~ responseBuffer += ser.read(12).decode('ascii' )
+                # If data on serial, fill buffer
                 
-            # ~ break
+                while ser.in_waiting:
                     
-        # ~ print( "Buffer : " + responseBuffer )
+                    inputBuffer += ser.read().decode('ascii')
                 
-    # ~ if responseBuffer[-4:] == "OKAY":
+                if inputBuffer:
                     
-        responseBuffer = ""
+                    if DEBUG == 1:
                     
-        print("Waiting for OKAY...")
+                        print( "Incoming data : " + inputBuffer )
                     
-        WaitForResponse("OKAY")
+                    # parse command ADDRESS:FILENAME
                     
+                    parsedBuffer = inputBuffer.split(':')
                     
-        # convert addr str > int > bytes
+                    if inputBuffer.startswith(str(800)):
                     
-        bytesAddr = int( address, 16 ).to_bytes( 4, byteorder='little', signed=False )
+                        if len( parsedBuffer ) > 2:
                         
-        # same as ?
+                            memAddr   = str(parsedBuffer[0])
                         
-        # ~ hexAddr = bytearray()
+                            flagAddr  = str(parsedBuffer[1])
                         
-        # ~ hexAddr.append( 0x80)
+                            loadFile     = str(parsedBuffer[2])
                             
-        # ~ hexAddr.append( 0x0b)
+                            ser.reset_input_buffer()
                             
-        # ~ hexAddr.append( 0x14)
+                            inputBuffer = ""
                             
-        # ~ hexAddr.append( 0x70)
+                            if DEBUG:
                             
-        # ~ hexAddr.reverse()
+                                print( memAddr + " - " + flagAddr + " - " + loadFile )
                             
-        # Convert and write address bytes to serial
+                            Listen = 0
                             
-        ser.write( bytesAddr )
+                            break
         
-        time.sleep(.1)
+        if memAddr and loadFile:
         
-        # Convert and write size bytes to serial
+            # Remove separator and ';1' at end of the string
         
-        bytesSize = size.to_bytes( 4, byteorder='little', signed = False )
+            fileClean = loadFile.split(';')[0][1:]
 
-        ser.write( bytesSize )
+            print("Received addresses and filename : " + memAddr + " - " + flagAddr + " - " + fileClean)
             
-        time.sleep(.1)
+            # TODO : replace with a proper level naming scheme
             
-        # Convert and write chekSum bytes to serial
+            binFileName = ""
             
-        bytesChk = checkSum.to_bytes( 4, byteorder='little', signed = False )
+            if fileClean == "level0.bin":
             
-        ser.write( bytesChk )
+                binFileName = "Overlay.lvl0" 
             
-        time.sleep(.1)
+            if fileClean == "level1.bin":
                 
-        # Convert and write data bytes to serial
+                binFileName = "Overlay.lvl1"
             
-        numChunk = math.ceil( len( data ) / chunkSize )
+            if DEBUG:
 
-        wait  = 0
+                print(
                 
-        i = 0
+                    "Load Data to : " + memAddr + "\n" +
                     
-        while i < len( data ):
+                    "Reset flag at: " + flagAddr + "\n" +
                     
-            chunkChk = 0
+                    "File   : " + loadFile + "\n" +
                     
-            if ( i + chunkSize ) > len( data ):
+                    "Bin    : " + binFileName
             
-                chunkSize = len( data ) - i
+                     )
             
-            print("Writing chunk " + str( i + 1  ) + " of " + str( numChunk ) )
+            # Open file as binary if bin filename is defined
             
-            # we know data length is < 2048, we'd need some code to cut the data in 2K chunks in real use case
+            if binFileName:
 
-            # ~ print( "Input buffer b : " + str(ser.out_waiting))
+                binFile = open( levelsFolder + binFileName, 'rb' )
-            # ~ print( "Output buffer b : " + str(ser.out_waiting))
             
-            # ~ for byte in range( len( data ) ):
+                data = binFile.read()
             
-            ser.write( data )
+                Transfer = 1
             
-                # ~ time.sleep(.005)
+            else:
                 
-            time.sleep(.1)
+                print(" No filename provided, doing nothing ")
                 
-            # Put chunk checksum calculation here
+                resetListener()
         
-            # Wait for output buffer to be empty
+        # If Init was set, initialize transfer and send data
         
-            while ser.out_waiting:
+        if Transfer:
             
-                print("\*")
+            print("Initializing data transfer...")
             
-                wait += 1
+            if not uniDebugMode:
             
-            time.sleep(.1)
+                # Set unirom to debugmode - sent : "DEBG" - received : "DEBGOKAY"
             
-            print("Wait : "+ str(wait))
+                setDEBG()
             
-            # reset input buffer
+            # Send level data
             
-            # ~ print( "Input buffer : " + str(ser.in_waiting))
+            SendBin( data, memAddr )
-            # ~ print( "Output buffer : " + str(ser.out_waiting))
 
-            # ~ ser.reset_input_buffer()
+            # Set level changed flag 
             
-            # wait for unirom to request the checksum
+            SendBin( uno , flagAddr)
             
-            print( "Chunk" + str( i + 1 ) + " waiting for unirom to request checksum (CHEK)..." )
+            # Reset everything 
             
-            WaitForResponse( "CHEK" )
+            resetListener()
             
-            # Wait for "CHEK" - MOVED to WaitForResponse()
+            print("DONE!")
     
-            # ~ while True:
         
-                # ~ if ser.in_waiting:
-                
-                    # ~ print( "Input buffer : " + str(ser.in_waiting))
-                    
-                    #print(".")
-                    
-                    # ~ chkValue = ser.read()
-                    
-                    # ~ # Make sure byte value is < 128 so that it can be decoded to ascii :: always getting '\xc7' 'q' '\x1c' '\xc7'  '\xab' '\xed' '1' '\x05'
-                    
-                    # ~ print( "chkVal : " + str(chkValue) + " - " + str( int.from_bytes(chkValue, 'big') ) )
-                    
-                    # ~ if int.from_bytes(chkValue, 'big') < 128:
-                    
-                        # ~ responseBuffer += chkValue.decode('ascii')  
-                    
-                    # ~ if len( responseBuffer ) > 4:
-                        
-                        # ~ # remove first char in buffer
-                        
-                        # ~ responseBuffer = responseBuffer[1:]
-                    
-                    # ~ print( "Response buffer : " + responseBuffer )
-                    
-                    # ~ if responseBuffer == "CHEK":
-                        
-                        # ~ print( "Got response : " + responseBuffer )
-                        
-                        # ~ break
-            
-            print( "Sending checksum to unirom..." );
-            
-            ser.write( bytesChk )
-            
-            time.sleep( .1 )
-            
-            # Wait for "MORE" - replace with WaitForResponse()
-            
-            # ~ while True:
-                
-                # ~ if ser.in_waiting:
-                    
-                    # ~ print(".")
-                    
-                    # ~ responseBuffer += ser.read().decode('ascii')
-                    
-                    # ~ if len( responseBuffer ) > 4:
-                        
-                        # ~ # remove first char in buffer
-                        
-                        # ~ responseBuffer = responseBuffer[1:]
-                
-                    # ~ if responseBuffer == "MORE":
-                        
-                        # ~ print( "Got response : " + responseBuffer )
-                        
-                        # ~ break
-        
-            WaitForResponse("MORE")
-        
-            print( str(i+1) + "chunk sent with correct checksum.")    
-    
-            i += chunkSize
-    
-    print("DONE!")
     
     return 0
 

main.c

@@ -74,9 +74,9 @@ u_long overlaySize = 0;
 
 #include "levels/level1.h"
 
-short level = 1;
+uint8_t level = 1;
 
-short levelHasChanged = 0;
+uint16_t levelHasChanged = 0;
 
 static char* overlayFile;
 
@@ -172,18 +172,30 @@ MESH   meshPlan = {0};
 VECTOR modelPlan_pos = {0};
 
 LEVEL curLvl = {
+    
     &cmat,
-	&lgtmat,
+	
-	(MESH **)&meshes,
+    &lgtmat,
-	&meshes_length,
+	
-	&actorPtr,
+    (MESH **)&meshes,
-	&levelPtr,
+	
-	&propPtr,
+    &meshes_length,
-	&camPtr,
+	
-	&camPath,
+    &actorPtr,
-	(CAMANGLE **)&camAngles,
+	
-	&curNode,
+    &levelPtr,
-	&meshPlan
+	
+    &propPtr,
+	
+    &camPtr,
+	
+    &camPath,
+	
+    (CAMANGLE **)&camAngles,
+	
+    &curNode,
+	
+    &meshPlan
 };
 
 // Pad 
@@ -363,17 +375,19 @@ int main() {
             
             #ifdef USECD
             
-            SwitchLevel( overlayFile, &load_all_overlays_here, &curLvl, &level0);
+            LoadLevelCD( overlayFile, &load_all_overlays_here );
             
             #endif
             
-            printf("%p:%s", &load_all_overlays_here, overlayFile);
+            SwitchLevel( overlayFile, &load_all_overlays_here, &curLvl, &level0);
+            
+            //~ printf("%p:%p:%s", &load_all_overlays_here, &levelHasChanged, overlayFile);
              
             levelHasChanged = 0;
         
         }
         
-        FntPrint("Lvl : %s\n", overlayFile);
+        FntPrint("Ovl:%s\nLvlch : %x\nLvl: %x %d", overlayFile, levelHasChanged, &levelHasChanged, level );
 
         //~ FntPrint("%x\n", curLvl.actorPtr->tim);
         
@@ -1360,10 +1374,17 @@ void callback() {
         
         if (!levelHasChanged){
         
+            //~ #ifndef USECD
+            
+            printf("%p:%p:%s", &load_all_overlays_here, &levelHasChanged, overlayFile);
+
+            //~ #endif
+        
             level = !level;
             
             levelHasChanged = 1;
         }
+        
         timer = 30;
         
         lastPad = PADL;

psx.c

@@ -191,7 +191,7 @@ void SwitchLevel(const char*const LevelName,  u_long * LoadAddress, LEVEL * curL
     
     ScrRst();
     
-    LoadLevelCD( LevelName, LoadAddress );
+    //~ LoadLevelCD( LevelName, LoadAddress );
     
     LvlPtrSet( curLevel, loadLevel);