from datetime import datetime
import os, time, csv, struct
from user_common import decompressBySection
    
def imageToCsvForSOAGK(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{disk}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) #读取image文件开头的12个字节
            with open(csvFilePath, "w") as fo:
                if diskNum == 0:
                    titleStr = 'DateTime, PGRAm, PGRBm, PGRCm, PGRUm, PGRDm, PGRLm, PGRRm, AGRM_CountAm, AGRM_CountBm, '
                    titleStr += 'CounterSector0, TimerSector0, CounterSector1, TimerSector1, CounterSector2, TimerSector2, '
                    titleStr += 'CounterSector3, TimerSector3, CounterSector4, TimerSector4, CounterSector5, TimerSector5, '
                    titleStr += 'CounterSector6, TimerSector6, CounterSector7, TimerSector7, SFlag\n'
                    fo.write(titleStr)
                    while(1):
                        dataBuf = fi.read(recordLength)  
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>2H', dataBuf[:4])
                            tempStr = f"{datetime.fromtimestamp(data[1] * 65536 + data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            dataBuf = dataBuf[4:]
                            tempBuf = bytearray()
                            for i in range(int(len(dataBuf)/2)):
                                tempBuf.append(dataBuf[2*i+1])
                                tempBuf.append(dataBuf[2*i])
                            data = struct.unpack('<7B18HB', tempBuf[0:44])
                            for i in range(0, len(data)):
                                if i < 7:
                                    tempStr += f", {decompressBySection(data[i])}"
                                else:
                                    tempStr += f", {data[i]}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
                elif diskNum == 1:
                    fo.write(f'DateTime, gyro_RMM_AD, vibr_X_AD, vibr_Y_AD, vibr_Z_AD\n')
                    while(1):
                        dataBuf = fi.read(256*28)  #每条记录长度32字节
                        if len(dataBuf) == 256*28:
                            timeStamp, = struct.unpack('>I', dataBuf[0:4])
                            gyro_RPM_AD = struct.unpack('>500H', dataBuf[4:1004])
                            vibr_X_AD = struct.unpack('>1000H', dataBuf[1024:3024])
                            vibr_Y_AD = struct.unpack('>1000H', dataBuf[3072:5072])
                            vibr_Z_AD = struct.unpack('>1000H', dataBuf[5120:7120])
                            for k in range(1000):
                                #fo.write(f"{datetime.fromtimestamp(timeStamp+0.001*k).strftime('%Y-%m-%d %H:%M:%S')}.{k%1000:03}, {gyro_RPM_AD[k//2]}, {gyro_RPM[k//2]}, {vibr_X_AD[k]}, {vibr_X}, {vibr_Y_AD[k]}, {vibr_Y}, {vibr_Z_AD[k]}, {vibr_Z}\n")
                                #fo.write(f"{datetime.fromtimestamp(timeStamp).strftime('%Y-%m-%d %H:%M:%S')}.{k%1000:03}, {gyro_RPM_AD[k//2]}, {vibr_X_AD[k]}, {vibr_Y_AD[k]}, {vibr_Z_AD[k]}\n")
                                fo.write(f"{datetime.fromtimestamp(timeStamp).strftime('%Y-%m-%d %H:%M:%S')}, {gyro_RPM_AD[k//2]}, {vibr_X_AD[k]}, {vibr_Y_AD[k]}, {vibr_Z_AD[k]}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForSOAGK(). {str(e)}")

def imageToCsvForAGR(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{disk}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 0:
                    titleStr = 'DateTime, PGRAm, PGRBm, PGRCm, PGRUm, PGRDm, PGRLm, PGRRm, AGRM_CountAm, AGRM_CountBm, '
                    titleStr += 'CounterSector0, TimerSector0, CounterSector1, TimerSector1, CounterSector2, TimerSector2, '
                    titleStr += 'CounterSector3, TimerSector3, CounterSector4, TimerSector4, CounterSector5, TimerSector5, '
                    titleStr += 'CounterSector6, TimerSector6, CounterSector7, TimerSector7, SFlag\n'
                    fo.write(titleStr)
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>2H', dataBuf[:4])
                            tempStr = f"{datetime.fromtimestamp(data[0] * 65536 + data[1]).strftime('%Y-%m-%d %H:%M:%S')}"
                            dataBuf = dataBuf[4:]                                
                            data = struct.unpack('>7B18HB', dataBuf[0:44])
                            for i in range(0, len(data)):
                                if i < 7:
                                    tempStr += f", {decompressBySection(data[i])}"
                                else:
                                    tempStr += f", {data[i]}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForAGR(). {str(e)}")
    
def imageToCsvForDSM(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{diskNum}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 0:
                    fo.write("DateTime, DMBM_DataIDm, DMBM_BootTimesm, DMBM_Statem, DMBM_TBusCurrentm, DMBM_TBusVoltagem, DMBM_BatCurrentm, DMBM_Capacitym, DMBM_BatVoltagem, DMBM_MudTempm\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I2BH6f', dataBuf)
                            fo.write(f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}, {data[1]}, {data[2]}, {data[3]}, {data[4]:2f}, {data[5]:2f}, {data[6]:2f}, {data[7]:2f}, {data[8]:2f}, {data[9]:2f}\n")
                        else:
                            break
                if diskNum == 1:
                    fo.write("DateTime, DMBM_FlagABCm, DMBM_ABCStatusm, DMBM_ABCStatus_Parsem, DMBM_DSMStatusm, DMBM_FlagUSDCm, DMBM_FlagVSTm, DMBM_FlagDMBR0m, DMBM_FlagACPRm, DMBM_FlagAGRm, DMBM_CPSCm, DMBM_FlagDIM2m, DMBM_DIM2Statusm, DMBM_FlagSFUm, DMBM_SFUStatusm, DMBM_CDLm, DMBM_TGCECHOm, DMBM_FlagINPm, DMBM_FlagLDIm, DMBM_FlagWAGRm, DMBM_FlagNBIGm, DMBM_FlagMASTm, DMBM_FlagDARTm, DMBM_FlagIFPTm, DMBM_FlagDWPRm\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I2B2H20B', dataBuf[:30])
                            tempStr = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(1, len(data)):
                                tempStr += f", {data[i]}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
                if diskNum == 2:
                    fo.write("DateTime, DPM_Borem, DPM_Annularm, DPM_BoreTempm, DPM_AnnularTempm\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>IB12H2B', dataBuf[:31])
                            for i in range(6):
                                tempStr = f"{datetime.fromtimestamp(data[0]+6*i).strftime('%Y-%m-%d %H:%M:%S')}"
#                                tempStr += f", {data[1]}"
                                tempStr += f", {data[i*2+2]}"
                                tempStr += f", {data[i*2+1+2]}"
                                tempStr += f", {data[14]}, {data[15]}"
                                fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForDSM(). {str(e)}")

def imageToCsvForDCM(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{diskNum}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 1:
                    fo.write("DateTime, datawidth, DL_state, ErrorFlg, instrCmd, instrData, status, highlevel, lowlevel, timer, bin, RPM\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I4BH6B', dataBuf[0:16])
                            fo.write(f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}, {data[1]}, {data[2]}, {data[3]}, {data[4]}, {data[5]}, {data[6]}, {data[7]}, {data[8]}, {data[9]}, {data[10]}, {data[11]}\n")
                        else:
                            break
                if diskNum == 0:
                    fo.write("DateTime, DCMM_DataID, DCMM_BootCount, DCMM_SysState, DCMM_BusUpCurrent, DCMM_BusVoltage, DCMM_Temperature, DCMM_MotorVoltage, DCMM_BusDownCurrent, DCMM_BatteryVoltage\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I2BH6f', dataBuf[:32])
                            tempStr = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(1, len(data)):
                                tempStr += f", {data[i]}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
                if diskNum == 2:
                    fo.write("DateTime, DPM_Borem, DPM_Annularm, DPM_BoreTempm, DPM_AnnularTempm\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>IB12H2B', dataBuf[:31])
                            for i in range(6):
                                tempStr = f"{datetime.fromtimestamp(data[0]+6*i).strftime('%Y-%m-%d %H:%M:%S')}"
#                                tempStr += f", {data[1]}"
                                tempStr += f", {data[i*2+2]}"
                                tempStr += f", {data[i*2+1+2]}"
                                tempStr += f", {data[14]}, {data[15]}"
                                fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForDSM(). {str(e)}")
       
def imageToCsvForDCM_T(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{disk}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 0:
                    titleStr = 'DateTime, DCM_BootTimesm, DCM_Statem, 3V6_VOLT_AD, 3V3OUT_VOLT_AD, TBus_Up_VOLT_AD, TBus_Down_VOLT_AD, '
                    titleStr += '90V_VOLT_AD, TBus_Up_CURR_AD, TBus_Down_CURR_AD, 48V_VOLT_AD, RPM, BOAT_TEMP\n '
                    fo.write(titleStr)
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>2H', dataBuf[:4])
                            tempStr = f"{datetime.fromtimestamp(data[1] * 65536 + data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            tempBuf = dataBuf[4:]
                            data = struct.unpack('<11Hf', tempBuf[0:26])
                            for i in range(0, len(data)):
                                tempStr += f", {data[i]}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForDCM(). {str(e)}")
    
def imageToCsvForPCM(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{diskNum}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 0:
                    fo.write("DateTime, DMBM_DataIDm, DMBM_BootTimesm, DMBM_Statem, DMBM_TBusCurrentm, DMBM_TBusVoltagem, DMBM_BatCurrentm, DMBM_Capacitym, DMBM_BatVoltagem, DMBM_MudTempm\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I2BH6f', dataBuf)
                            fo.write(f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}, {data[1]}, {data[2]}, {data[3]}, {data[4]:2f}, {data[5]:2f}, {data[6]:2f}, {data[7]:2f}, {data[8]:2f}, {data[9]:2f}\n")
                        else:
                            break
                if diskNum == 1:
                    fo.write("DateTime, DMBM_FlagABCm, DMBM_ABCStatusm, DMBM_ABCStatus_Parsem, DMBM_DSMStatusm, DMBM_FlagUSDCm, DMBM_FlagVSTm, DMBM_FlagDMBR0m, DMBM_FlagACPRm, DMBM_FlagAGRm, DMBM_CPSCm, DMBM_FlagDIM2m, DMBM_DIM2Statusm, DMBM_FlagSFUm, DMBM_SFUStatusm, DMBM_CDLm, DMBM_TGCECHOm, DMBM_FlagINPm, DMBM_FlagLDIm, DMBM_FlagWAGRm, DMBM_FlagNBIGm, DMBM_FlagMASTm, DMBM_FlagDARTm, DMBM_FlagIFPTm, DMBM_FlagDWPRm\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I2B2H20B', dataBuf[:30])
                            tempStr = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(1, len(data)):
                                tempStr += f", {data[i]}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
                if diskNum == 2:
                    fo.write("DateTime, DPM_Borem, DPM_Annularm, DPM_BoreTempm, DPM_AnnularTempm\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>IB12H2B', dataBuf[:31])
                            for i in range(6):
                                tempStr = f"{datetime.fromtimestamp(data[0]+6*i).strftime('%Y-%m-%d %H:%M:%S')}"
#                                tempStr += f", {data[1]}"
                                tempStr += f", {data[i*2+2]}"
                                tempStr += f", {data[i*2+1+2]}"
                                tempStr += f", {data[14]}, {data[15]}"
                                fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForPCM(). {str(e)}")
    
def imageToCsvForPMB(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{diskNum}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 0:
                    fo.write("DateTime, PMB_BootTimesm, PMB_Statem, PMB_AnnularTemp, PMB_AnnularAD, PMB_AnnularPressure, PMB_BoreTemp, PMB_BoreAD, PMB_BorePressure, PMB_Temperature\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I2HfHffHfh', dataBuf[0:30])
                            fo.write(f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}, {data[1]}, {data[2]}, {data[3]:2f}, {data[4]}, {data[5]:2f}, {data[6]:2f}, {data[7]}, {data[8]:2f}, {data[9]}\n")
                        else:
                            break
                if diskNum == 1:
                    fo.write("DateTime,  PMB_AnnularAD, PMB_BoreAD, PMB_AnnularTemp, PMB_BoreTemp\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I120H2H', dataBuf[:248])
                            timeStamp = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(0, 60):
                                tempStr = f"{timeStamp}, {data[2*i+1]}, {data[2*i+1+1]}, {data[121]}, {data[122]}"
                                fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForPMB(). {str(e)}")
    
def imageToCsvForNBMM(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{diskNum}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 0:
                    fo.write("DateTime, NBMM_BootTimesm, NBMM_Statem, NBMM_MudPressurem, NBMM_MudPressureTempm, NBMM_DrillPressurem, NBMM_Torquem, NBMM_BendingXm, NBMM_BendingYm, NBMM_ViberTempm, NBMM_RMS_XYm, NBMM_RMS_Zm, NBMM_ShockLXYm, NBMM_ShockLZm, NBMM_SSm, NBMM_MaxRMS_XY, NBMM_AveRMS_XY, NBMM_MaxRMS_Z, NBMM_AveRMS_Z, NBMM_ShockCX, NBMM_ShockCY, NBMM_ShockCZ, NBMM_MaxRPM, NBMM_MinRPM, NBMM_AveRPM\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I24H', dataBuf[:52])
                            tempStr = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(1, 4):
                                tempStr += f", {data[i]}"
                            tempStr += f", {data[4]/100:2f}, {data[5]/10-750:1f}, {data[6]/10-80:1f}, {data[7]/10-220:1f}, {data[8]/10-220:1f}"
                            for i in range(9, 22):
                                tempStr += f", {data[i]}"
                            tempStr += f", {data[22]/10:1f}, {data[23]/10:1f}, {data[24]/10:1f}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
                if diskNum == 1:
                    fo.write("DateTime, NBMM_MudPressureAD, NBMM_MudPressureTempAD, NBMM_DrillPressureAD, NBMM_TorqueAD, NBMM_BendingXAD, NBMM_BendingYAD\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I300H', dataBuf[:604])
                            timeStamp = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(50):
                                tempStr = ''
                                tempStr += f"{timeStamp}, {data[1+i*6]}, {data[2+i*6]}, {data[3+i*6]}, {data[4+i*6]}, {data[5+i*6]}, {data[6+i*6]}"
                                fo.write(f"{tempStr}\n")
                        else:
                            break
                if diskNum == 2:
                    fo.write("DateTime, NBMM_GyroAD, NBMM_ViberXAD, NBMM_ViberYAD, NBMM_ViberZAD\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data, = struct.unpack('>I', dataBuf[:4])
                            timeStamp = f"{datetime.fromtimestamp(data).strftime('%Y-%m-%d %H:%M:%S')}"
                            gyroData = struct.unpack('>500H', dataBuf[4:1004])
                            viberXData = struct.unpack('>1000H', dataBuf[1024:3024])
                            viberYData = struct.unpack('>1000H', dataBuf[3072:5072])
                            viberZData = struct.unpack('>1000H', dataBuf[5120:7120])
                            for i in range(1000):
                                tempStr = ''
                                tempStr += f"{timeStamp}, {gyroData[i//2]}, {viberXData[i]}, {viberYData[i]}, {viberZData[i]}"
                                fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForNBMM(). {str(e)}")
    
def imageToCsvForWBTM(imageFilePath, csvFilePath, disk, memoryParams):
    diskNum = disk
    try:
        recordLength = int(memoryParams[f"Disk{diskNum}"]['RecordLength'])
        with open(imageFilePath, "rb") as fi:
            fi.read(12) 
            with open(csvFilePath, "w") as fo:  
                if diskNum == 0:
                    fo.write("DateTime, WBTM_BootTimesm, WBTM_Statem, WBTM_AnnularPressurem, WBTM_BorePressurem, WBTM_AnnularTempm, WBTM_BoreTempm, WBTM_DrillPressurem, WBTM_Torquem, WBTM_BendingXm, WBTM_BendingYm, WBTM_Temperaturem\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I4H7h', dataBuf[:26])
                            tempStr = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(1, 5):
                                tempStr += f", {data[i]}"
                            tempStr += f", {data[5]/100:2f}, {data[6]/100:2f}, {data[7]/100-750:1f}, {data[8]/100-80:1f}, {data[9]/100-220:1f}, {data[10]/100-220:1f}, {data[11]/100:2f}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
                if diskNum == 1:
                    fo.write("DateTime, WBTM_EventType, WBTM_EventData_AnnularPressure, WBTM_EventData_BorePressure, WBTM_EventData_AnnularTemp, NBMM_EventData_BendingXAD, WBTM_EventData_BoreTemp, WBTM_EventData_DrillPressure, WBTM_EventData_Torque, WBTM_EventData_BendingX, WBTM_EventData_BendingY, WBTM_AnnularPressure_AD_Min, WBTM_AnnularPressure_AD_Max, WBTM_BorePressure_AD_Min, WBTM_BorePressure_AD_Max, WBTM_AnnularTemp_AD_Min, WBTM_AnnularTemp_AD_Max, WBTM_BoreTemp_AD_Min, WBTM_BoreTemp_AD_Max, WBTM_DrillPressure_AD_Min, WBTM_DrillPressure_AD_Max, WBTM_Torque_AD_Min, WBTM_Torque_AD_Max, WBTM_BendingX_AD_Min, WBTM_BendingX_AD_Max, WBTM_BendingY_AD_Min, WBTM_BendingY_AD_Maxs\n")
                    while(1):
                        dataBuf = fi.read(recordLength) 
                        if len(dataBuf) == recordLength:
                            data = struct.unpack('>I3H7h', dataBuf[:24])
                            tempStr = f"{datetime.fromtimestamp(data[0]).strftime('%Y-%m-%d %H:%M:%S')}"
                            for i in range(1, 4):
                                tempStr += f", {data[i]}"
                            tempStr += f", {data[4]/100:2f}, {data[5]/100:2f}, {data[6]/100-750:1f}, {data[7]/100-80:1f}, {data[8]/100-220:1f}, {data[9]/100-220:1f}, {data[10]/100:2f}"
                            data = struct.unpack('400H', dataBuf[24:824])
                            tempStr += f", {min(data[0:50])}, {max(data[0:50])}, {min(data[50:100])}, {max(data[50:100])}, {min(data[100:150])}, {max(data[100:150])}, {min(data[150:200])}, {max(data[150:200])}, {min(data[200:250])}, {max(data[200:250])}, {min(data[250:300])}, {max(data[250:300])}, {min(data[300:350])}, {max(data[300:350])}, {min(data[350:400])}, {max(data[350:400])}"
                            fo.write(f"{tempStr}\n")
                        else:
                            break
            fo.close()
        fi.close()
    except Exception as e:
        raise Exception(f"Error in imageToCsvForWBTM(). {str(e)}")