updates for 3r parsing

Author: JongChern

ShimmerDriver/src/main/java/com/shimmerresearch/driver/ShimmerObject.java

@@ -841,6 +841,11 @@ public ObjectCluster buildMsg(byte[] newPacket, COMMUNICATION_TYPE fwType, boole
 			numAdditionalChannels += 1;
 		} 
 		else {
+			if (fwType == COMMUNICATION_TYPE.SD && getHardwareVersion()==HW_ID.SHIMMER_3R) {
+				//plus 1 because of: timestamp, because we are no longer relying on interpretdatapacketformat within ShimmerSDLog
+				numAdditionalChannels += 1;
+			}
+			
 			if (!isRtcDifferenceSet()){
 				//sd log time stamp already included in mnChannels
 			} 
@@ -2922,23 +2927,47 @@ protected int getSignalIndex(String signalName) {
 	public void interpretDataPacketFormat(int numChannels, byte[] signalId){
 		String [] signalNameArray=new String[MAX_NUMBER_OF_SIGNALS];
 		String [] signalDataTypeArray=new String[MAX_NUMBER_OF_SIGNALS];
+		int packetSize=mTimeStampPacketByteSize; // Time stamp
+		
+		int iTS=0;
+		
+		if (getHardwareVersion()==HW_ID.SHIMMER_3R && this.getClass().getSimpleName().equals("ShimmerSDLog") ) {
+			mNChannels = numChannels;
+			if (isSyncWhenLogging() 
+					&& (getFirmwareIdentifier()==FW_ID.SDLOG || getFirmwareIdentifier()==FW_ID.GQ_802154 
+					||(UtilShimmer.compareVersions(getShimmerVerObject(),Configuration.Shimmer3.CompatibilityInfoForMaps.svoShimmer3LogAndStreamWithSDLogSyncSupport))
+					||(UtilShimmer.compareVersions(getShimmerVerObject(),Configuration.Shimmer3.CompatibilityInfoForMaps.svoShimmer3RLogAndStreamWithSDLogSyncSupport)))){
+				signalNameArray[iTS]=SensorShimmerClock.ObjectClusterSensorName.TIMESTAMP_OFFSET;
+				if (OFFSET_LENGTH==5){
+					signalDataTypeArray[iTS]="u32signed";
+					mNChannels += 1;
+					packetSize+=5;
+				} else if (OFFSET_LENGTH==9){
+					signalDataTypeArray[iTS]="u72";
+					mNChannels += 1;
+					packetSize+=9;
+				}
+				iTS++;
+			} 
+		}
+		
 
 		if (getHardwareVersion()==HW_ID.SHIMMER_SR30 || getHardwareVersion()==HW_ID.SHIMMER_3 || getHardwareVersion() == HW_ID.SHIMMER_3R){
-			signalNameArray[0]=Configuration.Shimmer3.ObjectClusterSensorName.TIMESTAMP;
+			signalNameArray[iTS]=Configuration.Shimmer3.ObjectClusterSensorName.TIMESTAMP;
 		}
 		else{
-			signalNameArray[0]=Configuration.Shimmer2.ObjectClusterSensorName.TIMESTAMP;
+			signalNameArray[iTS]=Configuration.Shimmer2.ObjectClusterSensorName.TIMESTAMP;
 		}
 
-		int packetSize=mTimeStampPacketByteSize; // Time stamp
+
 		if (mTimeStampPacketByteSize==2){
-			signalDataTypeArray[0]="u16";
+			signalDataTypeArray[iTS]="u16";
 		} else if (mTimeStampPacketByteSize==3) {
-			signalDataTypeArray[0]="u24";
+			signalDataTypeArray[iTS]="u24";
 		}
 
 		int enabledSensors= 0x00;
-		for (int i=0;i<numChannels;i++) {
+		for (int i=iTS;i<numChannels+iTS;i++) {
 			if ((byte)signalId[i]==(byte)0x00){
 				if (getHardwareVersion()==HW_ID.SHIMMER_SR30 || getHardwareVersion()==HW_ID.SHIMMER_3 || getHardwareVersion()==HW_ID.SHIMMER_3R){
 					signalNameArray[i+1]=Shimmer3.ObjectClusterSensorName.ACCEL_LN_X;

ShimmerDriver/src/main/java/com/shimmerresearch/driverUtilities/UtilParseData.java

@@ -308,4 +308,53 @@ public static long calculatetwoscomplement(long signedData, int bitLength){
 
 		return newData;
 	}
+	
+	public static int countBytesFromDataTypes(String[] dataType) {
+	    int totalBytes = 0;
+
+	    for (String type : dataType) {
+	    	if(type==null) {
+	    		continue;
+	    	}
+	        switch (type) {
+	            case "u8":
+	            case "i8":
+	                totalBytes += 1;
+	                break;
+	            case "u12":
+	            case "u14":
+	            case "i12>":
+	            case "i12*>":
+	            case "u16":
+	            case "u16r":
+	            case "i16":
+	            case "i16r":
+	                totalBytes += 2;
+	                break;
+	            case "u24":
+	            case "u24r":
+	            case "i24r":
+	                totalBytes += 3;
+	                break;
+	            case "u32":
+	            case "u32r":
+	            case "i32":
+	            case "i32r":
+	                totalBytes += 4;
+	                break;
+	            case "u32signed":
+	                totalBytes += 5;
+	                break;
+	            case "u72":
+	                totalBytes += 9;
+	                break;
+	            default:
+	                throw new IllegalArgumentException("Unknown data type: " + type);
+	        }
+	    }
+
+	    return totalBytes;
+	}
+
+	
 }

ShimmerDriver/src/test/java/com/shimmerresearch/driverUtilities/API_XXXXX_UtilParseData.java

@@ -0,0 +1,61 @@
+package com.shimmerresearch.driverUtilities;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class API_XXXXX_UtilParseData {
+	 @Test
+	    public void testSingleByteTypes() {
+	        String[] types = {"u8", "i8"};
+	        assertEquals(2, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test
+	    public void testTwoByteTypes() {
+	        String[] types = {"u12", "u14", "i12>", "i12*>", "u16", "u16r", "i16", "i16r"};
+	        assertEquals(2 * types.length, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test
+	    public void testThreeByteTypes() {
+	        String[] types = {"u24", "u24r", "i24r"};
+	        assertEquals(9, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test
+	    public void testFourByteTypes() {
+	        String[] types = {"u32", "u32r", "i32", "i32r"};
+	        assertEquals(4 * types.length, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test
+	    public void testFiveByteType() {
+	        String[] types = {"u32signed"};
+	        assertEquals(5, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test
+	    public void testNineByteType() {
+	        String[] types = {"u72"};
+	        assertEquals(9, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test
+	    public void testMixedTypes() {
+	        String[] types = {"u8", "i8", "u16", "u24", "u32signed", "u72"};
+	        int expected = 1 + 1 + 2 + 3 + 5 + 9;
+	        assertEquals(expected, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test
+	    public void testEmptyInput() {
+	        String[] types = {};
+	        assertEquals(0, UtilParseData.countBytesFromDataTypes(types));
+	    }
+
+	    @Test(expected = IllegalArgumentException.class)
+	    public void testUnknownTypeThrows() {
+	        String[] types = {"u8", "invalidType"};
+	        UtilParseData.countBytesFromDataTypes(types);
+	    }
+}