comparison core/ClockSync.cpp @ 139:4e2dd3eb1d28 ClockSync

The reported offset is now meaningful. The whole thing is waaay too jittery.

 	bufferLength=kSyncMessageLength;
 	T1=-1;
 	T1p=-1;
 	T2=-1;
 	T2p=-1;
-	receiveLoopSleepUs=10;
+	receiveLoopSleepUs=100;
 	receiveLoopTimeout=1e5;
-	movingAverage.setLength(201);
+	movingAverage.setLength(31);
 	expectedClockSyncType=isSlave() ? kSync : kNone;
 }
 ClockSync::ClockSync(bool thisIsSlave, int aPort, VirtualClock &aVirtualClock){
 	init(thisIsSlave, aPort, aVirtualClock);
 }

 }
 void ClockSync::setType(int clockSyncType){
 	((int*)buffer)[0]=clockSyncType;
 }
 void ClockSync::setTimestamp(myClock_t timestamp){
+//	printf("setting timestamp: %lld\n", timestamp);
 	((myClock_t*)((char*)buffer+sizeof(int)))[0]=timestamp;
 }
 void ClockSync::print(){
 	 //printf("type: %d, timestamp: %lld\n",*((int*)buffer),*((myClock_t*)(((int*)buffer)+1)));
 }

 		usleep(receiveLoopSleepUs); //how often to check for new clockSyncs;
 		//   //printf("waiting for clockSyncs\n");
 		localTimestamp=receive();
 		if(localTimestamp<=0){
 			if(localTimestamp==0){
-				//  //printf("Socket not ready to be read: %lld\n", localTimestamp);
+//				  printf("Socket not ready to be read: %lld\n", localTimestamp);
 			}
 			else if(localTimestamp==-1){
-				//printf("Error while receiving: %lld\n", localTimestamp);
+				printf("Error while receiving: %lld\n", localTimestamp);
 			}
 			else if(localTimestamp==-2){
-				//  //printf("Wrong size of the received clockSync: %lld\n", localTimestamp);
+				  printf("Wrong size of the received clockSync: %lld\n", localTimestamp);
 			}
 			continue ; //keep waiting
 		}
 		clockSyncType=getType();
 		clockSyncTimestamp=getTimestamp();
 		if(clockSyncType!=expectedClockSyncType){
 			//printf("Wrong clockSync type: %d, expected: %d\n",clockSyncType, expectedClockSyncType);
 			return -2; //start over
 		}
-		//printf("Received clockSync type: %d, clockSyncTimestamp: %lld\n", clockSyncType, clockSyncTimestamp);
+//		printf("Received clockSync type: %d, clockSyncTimestamp: %lld\n", clockSyncType, clockSyncTimestamp);
 		if(isSlave()==true){
 			int ret=slaveHandleMessage();
 			if(ret==1 && clockSyncType==kDelayResp){ //we are done, end of a cycle!
 				return 1;
 			} else if (ret!=1) {

 			break;
 		case kDelayResp: {//the clockSyncTimestamp is the instant when the master received the kDelayResp clockSync, the localTimestamp is meaningless
 			T2p=clockSyncTimestamp;
 			//TODO: evaluate things
 			double offset=(T1p-T1-T2p+T2)/2.0d;
-			printf("-----------OFFSET IS : %04.1f, average: %04.2f\n", offset, movingAverage.add(offset));
+			printf("-----------OFFSET IS : %04.4f seconds, average: %04.4f seconds\n",
+					offset/44100.f, movingAverage.add(offset)/44100.f);
 			expectedClockSyncType=kSync; //end of the cycle, wait for next sync.
 			break;
 		}
 		default:
 			//printf("Unexpected message type\n"); // we should never get here