Subversion Repositories ha1588

///*
// * ptpv2_timing_analyzer.sce
// * 
// * Copyright (c) 2013, BABY&HW. All rights reserved.
// *
// * This library is free software; you can redistribute it and/or
// * modify it under the terms of the GNU Lesser General Public
// * License as published by the Free Software Foundation; either
// * version 2.1 of the License, or (at your option) any later version.
// *
// * This library is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// * Lesser General Public License for more details.
// *
// * You should have received a copy of the GNU Lesser General Public
// * License along with this library; if not, write to the Free Software
// * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
// * MA 02110-1301  USA
// */

clear;
clc;
stacksize('max');
/////////////////////////////////////
// Read pcap file for PTP
/////////////////////////////////////
pcapFile='ptpdv2_long.pcap';
fd1=mopen(pcapFile,'rb');
// skip file header
// check endianness
mseek(24); //24B

// parse capture
packetNum_cap         = {};
messageId_cap         = {};
clockId_cap           = {};
sequenceId_cap        = {};
embeddedTimestamp_cap = {};
capturedTimestamp_cap = {};
packetNum = 0;
while 1
  // parsing capture header per frame
  // get time stamp in second
  capturedTimestamp_Sec =mget(1,'uil',fd1);
  // get time stamp in nsecond
  capturedTimestamp_NSec=mget(1,'uil',fd1);
  // get capture length
  lCaptr=mget(1,'uil',fd1);
  // get frame length
  lFrame=mget(1,'uil',fd1);
  
  // ptp packet parsing here
  
  // ptp packet address filter here
  
  // ptp packet number
  packetNum=packetNum+1;
  
  // skip packet header
  mseek(mtell(fd1)+(14+20+8)); //14B:MAC, 20B:IP, 8B:UDP
  
  // messageId
  mseek(mtell(fd1)+0); // 0B from beginning of ptp
  messageId=modulo(mget(1,'ucb',fd1),2^4); //1B
  mseek(mtell(fd1)-(0+1)); //return to beginning of ptp
  
  // ClockIdentity
  mseek(mtell(fd1)+20); // 20B from beginning of ptp
  clockId=mget(1,'uib',fd1); //4B
  clockId=mget(1,'uib',fd1); //4B
  mseek(mtell(fd1)-(20+4+4)); //return to beginning of ptp
  
  // sequenceId
  mseek(mtell(fd1)+30); // 30B from beginning of ptp
  sequenceId=mget(1,'usb',fd1); //2B
  mseek(mtell(fd1)-(30+2)); //return to beginning of ptp
  
  // embeddedTimestamp
  mseek(mtell(fd1)+34); // 34B from beginning of ptp
  embeddedTimestamp_SecH=mget(1,'usb',fd1); //2B
  embeddedTimestamp_SecL=mget(1,'uib',fd1); //4B
  embeddedTimestamp_NSec=mget(1,'uib',fd1); //4B
  mseek(mtell(fd1)-(34+2+4+4)); //return to beginning of ptp
  
  // return to beginning of packet
  mseek(mtell(fd1)-(14+20+8)); //14B:MAC, 20B:IP, 8B:UDP
  
  // go to end of packet
  mseek(mtell(fd1)+lCaptr);
  
  // get ptp messages
  packetNum_cap         = [packetNum_cap, packetNum];
  messageId_cap         = [messageId_cap, messageId];
  clockId_cap           = [clockId_cap, clockId];
  sequenceId_cap        = [sequenceId_cap, sequenceId];
  embeddedTimestamp_cap = [embeddedTimestamp_cap, (embeddedTimestamp_SecH*4294967296 + embeddedTimestamp_SecL) + embeddedTimestamp_NSec*10^(-9)];
  capturedTimestamp_cap = [capturedTimestamp_cap,  capturedTimestamp_Sec                                       + capturedTimestamp_NSec*10^(-9)];
  
  // EOF checking
  mget(1,'ui',fd1);
  if meof(fd1)
    // break from the loop
    break;
  else
    // switch to the next packet
    mseek(mtell(fd1)-4);
  end
end
mtell;
mclose(fd1);

// find Master and Slave clockId
clockId_mastrs=clockId_cap(find(messageId_cap==0));
clockId_mastr =clockId_mastrs(1);
clockId_slaves=clockId_cap(find(clockId_cap~=clockId_mastr));
clockId_slave =clockId_slaves(1);

// function: calc_delta
funcprot(0);
function timestamp_delta=calc_delta(timestamp)
  timestamp=timestamp-timestamp(1);
  timestamp_delta=zeros(1,length(timestamp)-1);
  for i = 1:(length(timestamp)-1)
    timestamp_delta(i)=timestamp(i+1)-timestamp(i);
  end
endfunction

///////////////////////////////////////
// Generate CSV
///////////////////////////////////////
// [packetNum_cap', capturedTimestamp_cap', messageId_cap', clockId_cap', sequenceId_cap', embeddedTimestamp_cap']

// Port Direction
clockId_str_cap={};
for i = 1:length(clockId_cap)
  select clockId_cap(i)
    case  clockId_mastr then clockId_str_cap = {clockId_str_cap, 'M -> S'},
    else                     clockId_str_cap = {clockId_str_cap, 'M <- S'},
  end
end

// MessageId
messageId_str_cap={};
for i = 1:length(messageId_cap)
  select messageId_cap(i)
    case  0 then messageId_str_cap = {messageId_str_cap, '0x0: EVENT:SYNC'},
    case  1 then messageId_str_cap = {messageId_str_cap, '0x1: EVENT:DELAY_REQ'},
    case  2 then messageId_str_cap = {messageId_str_cap, '0x2: EVENT:PATH_DELAY_REQ'},
    case  3 then messageId_str_cap = {messageId_str_cap, '0x3: EVENT:PATH_DELAY_RESP'},
  //case  4- 7 Reserved
    case  8 then messageId_str_cap = {messageId_str_cap, '0x8: GENER:FOLLOW_UP'},
    case  9 then messageId_str_cap = {messageId_str_cap, '0x9: GENER:DELAY_RESP'},
    case 10 then messageId_str_cap = {messageId_str_cap, '0xA: GENER:PATH_DELAY_RESP_FOLLOW_UP'},
    case 11 then messageId_str_cap = {messageId_str_cap, '0xB: GENER:ANNOUNCE'},
    case 12 then messageId_str_cap = {messageId_str_cap, '0xC: GENER:SIGNALLING'},
    case 13 then messageId_str_cap = {messageId_str_cap, '0xD: GENER:MANAGEMENT'},
  //case 14-15 Reserved
    else         messageId_str_cap = {messageId_str_cap, messageId},
  end
end

// Inter-Packet Time
interPacketTime={0, calc_delta(capturedTimestamp_cap)};

// Inter-Message Time
interMessageTime=zeros(1,length(capturedTimestamp_cap));
indexMastr=find(clockId_cap==clockId_mastr);
indexSlave=find(clockId_cap==clockId_slave);
indexSync=indexMastr(find(messageId_cap(indexMastr)== 0));
indexDreq=indexMastr(find(messageId_cap(indexMastr)== 1));
indexPreq=indexMastr(find(messageId_cap(indexMastr)== 2));
indexPres=indexMastr(find(messageId_cap(indexMastr)== 3));
indexFlup=indexMastr(find(messageId_cap(indexMastr)== 8));
indexDres=indexMastr(find(messageId_cap(indexMastr)== 9));
indexPrfl=indexMastr(find(messageId_cap(indexMastr)==10));
indexAnnc=indexMastr(find(messageId_cap(indexMastr)==11));
indexSign=indexMastr(find(messageId_cap(indexMastr)==12));
indexMang=indexMastr(find(messageId_cap(indexMastr)==13));
interMessageTime(indexSync)={0, calc_delta(capturedTimestamp_cap(indexSync))};
interMessageTime(indexDreq)={0, calc_delta(capturedTimestamp_cap(indexDreq))};
interMessageTime(indexPreq)={0, calc_delta(capturedTimestamp_cap(indexPreq))};
interMessageTime(indexPres)={0, calc_delta(capturedTimestamp_cap(indexPres))};
interMessageTime(indexFlup)={0, calc_delta(capturedTimestamp_cap(indexFlup))};
interMessageTime(indexDres)={0, calc_delta(capturedTimestamp_cap(indexDres))};
interMessageTime(indexPrfl)={0, calc_delta(capturedTimestamp_cap(indexPrfl))};
interMessageTime(indexAnnc)={0, calc_delta(capturedTimestamp_cap(indexAnnc))};
interMessageTime(indexSign)={0, calc_delta(capturedTimestamp_cap(indexSign))};
interMessageTime(indexMang)={0, calc_delta(capturedTimestamp_cap(indexMang))};
indexSync=indexSlave(find(messageId_cap(indexSlave)== 0));
indexDreq=indexSlave(find(messageId_cap(indexSlave)== 1));
indexPreq=indexSlave(find(messageId_cap(indexSlave)== 2));
indexPres=indexSlave(find(messageId_cap(indexSlave)== 3));
indexFlup=indexSlave(find(messageId_cap(indexSlave)== 8));
indexDres=indexSlave(find(messageId_cap(indexSlave)== 9));
indexPrfl=indexSlave(find(messageId_cap(indexSlave)==10));
indexAnnc=indexSlave(find(messageId_cap(indexSlave)==11));
indexSign=indexSlave(find(messageId_cap(indexSlave)==12));
indexMang=indexSlave(find(messageId_cap(indexSlave)==13));
interMessageTime(indexSync)={0, calc_delta(capturedTimestamp_cap(indexSync))};
interMessageTime(indexDreq)={0, calc_delta(capturedTimestamp_cap(indexDreq))};
interMessageTime(indexPreq)={0, calc_delta(capturedTimestamp_cap(indexPreq))};
interMessageTime(indexPres)={0, calc_delta(capturedTimestamp_cap(indexPres))};
interMessageTime(indexFlup)={0, calc_delta(capturedTimestamp_cap(indexFlup))};
interMessageTime(indexDres)={0, calc_delta(capturedTimestamp_cap(indexDres))};
interMessageTime(indexPrfl)={0, calc_delta(capturedTimestamp_cap(indexPrfl))};
interMessageTime(indexAnnc)={0, calc_delta(capturedTimestamp_cap(indexAnnc))};
interMessageTime(indexSign)={0, calc_delta(capturedTimestamp_cap(indexSign))};
interMessageTime(indexMang)={0, calc_delta(capturedTimestamp_cap(indexMang))};

u=file('open',PWD+'/ptpv2_'+'parsed'+'.csv','unknown');
  fprintf(u,"Port, Packet #, Arrival Time, Inter-Packet Time, Inter-Message Time, messageType, sequenceId, embedded Time");
for i = 1:(length(packetNum_cap))
  fprintf(u,"%s, %d, %6.9f, %6.9f, %6.9f, %s, %d, %6.9f", clockId_str_cap(i), packetNum_cap(i), capturedTimestamp_cap(i)-capturedTimestamp_cap(1), interPacketTime(i), interMessageTime(i), messageId_str_cap(i), sequenceId_cap(i), embeddedTimestamp_cap(i));
end
file('close',u);

///////////////////////////////////////
// Generate graph
///////////////////////////////////////

// 1. SYNC PDV
subplot(8,1,1);
xtitle('', '', 'SYNC PDV/s');
indexSync=find(messageId_cap==0);
indexFlup=find(messageId_cap==8);
indexSync=indexSync(find(clockId_cap(indexSync)==clockId_mastr)); // SYNC M->S
indexFlup=indexFlup(find(clockId_cap(indexFlup)==clockId_mastr)); // FLUP M->S
capturedTimestamp_sync=capturedTimestamp_cap(indexSync); // t2
sequenceId_sync       =sequenceId_cap       (indexSync);
embeddedTimestamp_flup=embeddedTimestamp_cap(indexFlup); // t1
sequenceId_flup       =sequenceId_cap       (indexFlup);

captured_sync={};
embedded_flup={};
for i=1:length(sequenceId_sync)
  index=find(sequenceId_flup==sequenceId_sync(i));
  if index==[]
    continue;
  else
    captured_sync={captured_sync, capturedTimestamp_sync(i)};
    embedded_flup={embedded_flup, embeddedTimestamp_flup(index)};
  end
end

captured_syncDelta=calc_delta(captured_sync);
embedded_flupDelta=calc_delta(embedded_flup);
plot((captured_sync(2:length(captured_sync))-capturedTimestamp_cap(1)), (captured_syncDelta-embedded_flupDelta));

// 2. DELAY_REQ PDV
subplot(8,1,2);
xtitle('', '', 'DELAY_REQ PDV/s');
indexReq=find(messageId_cap==2);
indexRes=find(messageId_cap==3);
indexReq=indexSync(find(clockId_cap(indexReq)==clockId_slave)); // DELAY_REQ S->M
indexRes=indexFlup(find(clockId_cap(indexRes)==clockId_mastr)); // DELAY_RES M->S
capturedTimestamp_req=capturedTimestamp_cap(indexReq); // t3
sequenceId_req       =sequenceId_cap       (indexReq);
embeddedTimestamp_res=embeddedTimestamp_cap(indexRes); // t4
sequenceId_res       =sequenceId_cap       (indexRes);

captured_req={};
embedded_res={};
for i=1:length(sequenceId_req)
  index=find(sequenceId_res==sequenceId_req(i));
  if index==[]
    continue;
  else
    captured_req={captured_req, capturedTimestamp_req(i)};
    embedded_res={embedded_res, embeddedTimestamp_res(index)};
  end
end

captured_reqDelta=calc_delta(captured_req);
embedded_resDelta=calc_delta(embedded_res);
plot((captured_req(2:length(captured_req))-capturedTimestamp_cap(1)), (captured_reqDelta-embedded_resDelta));

// 3. FOLLOW_UP PDV
subplot(8,1,3);
xtitle('', '', 'FOLLOW_UP PDV/s');
indexSync=find(messageId_cap==0);
indexFlup=find(messageId_cap==8);
indexSync=indexSync(find(clockId_cap(indexSync)==clockId_mastr)); // SYNC M->S
indexFlup=indexFlup(find(clockId_cap(indexFlup)==clockId_mastr)); // FLUP M->S
capturedTimestamp_sync=capturedTimestamp_cap(indexSync); // t2
sequenceId_sync       =sequenceId_cap       (indexSync);
capturedTimestamp_flup=capturedTimestamp_cap(indexFlup);
sequenceId_flup       =sequenceId_cap       (indexFlup);

captured_sync={};
captured_flup={};
for i=1:length(sequenceId_sync)
  index=find(sequenceId_flup==sequenceId_sync(i));
  if index==[]
    continue;
  else
    captured_sync={captured_sync, capturedTimestamp_sync(i)};
    captured_flup={captured_flup, capturedTimestamp_flup(index)};
  end
end

captured_syncDelta=calc_delta(captured_sync);
captured_flupDelta=calc_delta(captured_flup);
plot((captured_sync(2:length(captured_sync))-capturedTimestamp_cap(1)), (captured_flupDelta-captured_syncDelta));

// 4. Slave Clock Wander
subplot(8,1,4);
xtitle('', '', 'Slave Clock Wander/s');
indexReq=find(messageId_cap==2);
indexReq=indexReq(find(clockId_cap(indexReq)==clockId_slave)); // PATH_DELAY_REQ S->M
capturedTimestamp_req=capturedTimestamp_cap(indexReq); // t4
embeddedTimestamp_req=embeddedTimestamp_cap(indexReq);
sequenceId_req       =sequenceId_cap       (indexReq);

captured_req={};
embedded_req={};
for i=1:length(sequenceId_req)
  index=find(sequenceId_req==sequenceId_req(i));
  if index==[]
    continue;
  else
    captured_req={captured_req, capturedTimestamp_req(index)};
    embedded_req={embedded_req, embeddedTimestamp_req(index)};
  end
end

embedded_reqDelta=calc_delta(embedded_req);
plot((captured_req(2:length(captured_req))-capturedTimestamp_cap(1)), embedded_reqDelta-mean(embedded_reqDelta));

// 5. Round Trip Delay variation
subplot(8,1,5);
xtitle('', '', 'RTD Variation/s');
indexSync=find(messageId_cap==0);
indexFlup=find(messageId_cap==8);
indexSync=indexSync(find(clockId_cap(indexSync)==clockId_mastr)); // SYNC M->S
indexFlup=indexFlup(find(clockId_cap(indexFlup)==clockId_mastr)); // FLUP M->S
capturedTimestamp_sync=capturedTimestamp_cap(indexSync); // t2
sequenceId_sync       =sequenceId_cap       (indexSync);
embeddedTimestamp_flup=embeddedTimestamp_cap(indexFlup); // t1
sequenceId_flup       =sequenceId_cap       (indexFlup);

captured_sync={};
embedded_flup={};
for i=1:length(sequenceId_sync)
  index=find(sequenceId_flup==sequenceId_sync(i));
  if index==[]
    continue;
  else
    captured_sync={captured_sync, capturedTimestamp_sync(i)};
    embedded_flup={embedded_flup, embeddedTimestamp_flup(index)};
  end
end

indexReq=find(messageId_cap==2);
indexRes=find(messageId_cap==3);
indexReq=indexReq(find(clockId_cap(indexReq)==clockId_slave)); // DELAY_REQ S->M
indexRes=indexRes(find(clockId_cap(indexRes)==clockId_mastr)); // DELAY_RES M->S 
capturedTimestamp_req=capturedTimestamp_cap(indexReq); // t3
sequenceId_req       =sequenceId_cap       (indexReq);
embeddedTimestamp_res=embeddedTimestamp_cap(indexRes); // t4
sequenceId_res       =sequenceId_cap       (indexRes);

captured_req={};
embedded_res={};
for i=1:length(sequenceId_req)
  index=find(sequenceId_res==sequenceId_req(i));
  if index==[]
    continue;
  else
    captured_req={captured_req, capturedTimestamp_req(i)};
    embedded_res={embedded_res, embeddedTimestamp_res(index)};
  end
end

captured_syncDelta=calc_delta(captured_sync);
embedded_flupDelta=calc_delta(embedded_flup);
captured_reqDelta=calc_delta(captured_req);
embedded_resDelta=calc_delta(embedded_res);
commonLength=min(length(captured_sync),length(captured_req));
captured_syncDelta=captured_syncDelta(1:commonLength-1);
embedded_flupDelta=embedded_flupDelta(1:commonLength-1);
captured_reqDelta=captured_reqDelta(1:commonLength-1);
embedded_resDelta=embedded_resDelta(1:commonLength-1);
plot((captured_req(2:commonLength)-capturedTimestamp_cap(1)), ((captured_syncDelta-embedded_flupDelta)+(embedded_resDelta-captured_reqDelta))/2); //((t2-t1)+(t4-t3))/2

// 6. Asymmetry
subplot(8,1,6);
xtitle('', '', 'Delay Asymmetry/s');
indexSync=find(messageId_cap==0);
indexFlup=find(messageId_cap==8);
indexSync=indexSync(find(clockId_cap(indexSync)==clockId_mastr)); // SYNC M->S
indexFlup=indexFlup(find(clockId_cap(indexFlup)==clockId_mastr)); // FLUP M->S
capturedTimestamp_sync=capturedTimestamp_cap(indexSync); // t2
sequenceId_sync       =sequenceId_cap       (indexSync);
embeddedTimestamp_flup=embeddedTimestamp_cap(indexFlup); // t1
sequenceId_flup       =sequenceId_cap       (indexFlup);

captured_sync={};
embedded_flup={};
for i=1:length(sequenceId_sync)
  index=find(sequenceId_flup==sequenceId_sync(i));
  if index==[]
    continue;
  else
    captured_sync={captured_sync, capturedTimestamp_sync(i)};
    embedded_flup={embedded_flup, embeddedTimestamp_flup(index)};
  end
end

indexReq=find(messageId_cap==2);
indexRes=find(messageId_cap==3);
indexReq=indexReq(find(clockId_cap(indexReq)==clockId_slave)); // DELAY_REQ S->M
indexRes=indexRes(find(clockId_cap(indexRes)==clockId_mastr)); // DELAY_RES M->S 
capturedTimestamp_req=capturedTimestamp_cap(indexReq); // t3
sequenceId_req       =sequenceId_cap       (indexReq);
embeddedTimestamp_res=embeddedTimestamp_cap(indexRes); // t4
sequenceId_res       =sequenceId_cap       (indexRes);

captured_req={};
embedded_res={};
for i=1:length(sequenceId_req)
  index=find(sequenceId_res==sequenceId_req(i));
  if index==[]
    continue;
  else
    captured_req={captured_req, capturedTimestamp_req(i)};
    embedded_res={embedded_res, embeddedTimestamp_res(index)};
  end
end

commonLength=min(length(captured_sync),length(captured_req));
captured_sync=captured_sync(1:commonLength);
embedded_flup=embedded_flup(1:commonLength);
captured_req=captured_req(1:commonLength);
embedded_res=embedded_res(1:commonLength);
plot((captured_req(1:commonLength)-capturedTimestamp_cap(1)), (captured_sync-embedded_flup)-(embedded_res-captured_req)); //(t2-t1)-(t4-t3)

// 7. Sync Inter-Packet Gap
subplot(8,1,7);
xtitle('', '', 'SYNC IPG/s');
indexSync=find(messageId_cap==0);
indexSync=indexSync(find(clockId_cap(indexSync)==clockId_mastr)); // SYNC M->S
capturedTimestamp_sync=capturedTimestamp_cap(indexSync); // t2
sequenceId_sync       =sequenceId_cap       (indexSync);

captured_sync={};
for i=1:length(sequenceId_sync)
  index=find(sequenceId_sync==sequenceId_sync(i));
  if index==[]
    continue;
  else
    captured_sync={captured_sync, capturedTimestamp_sync(index)};
  end
end

captured_syncDelta=calc_delta(captured_sync);
plot((captured_sync(2:length(captured_sync))-capturedTimestamp_cap(1)), captured_syncDelta);

// 8. Delay-Resp Round Trip Delay
subplot(8,1,8);
xtitle('', '', 'Delay-Resp Latency/s');
indexReq=find(messageId_cap==2);
indexRes=find(messageId_cap==3);
indexReq=indexReq(find(clockId_cap(indexReq)==clockId_slave)); // DELAY_REQ S->M
indexRes=indexRes(find(clockId_cap(indexRes)==clockId_mastr)); // DELAY_RES M->S 
capturedTimestamp_req=capturedTimestamp_cap(indexReq); // t3
sequenceId_req       =sequenceId_cap       (indexReq);
capturedTimestamp_res=capturedTimestamp_cap(indexRes);
sequenceId_res       =sequenceId_cap       (indexRes);

captured_req={};
captured_res={};
for i=1:length(sequenceId_req)
  index=find(sequenceId_res==sequenceId_req(i));
  if index==[]
    continue;
  else
    captured_req={captured_req, capturedTimestamp_req(i)};
    captured_res={captured_res, capturedTimestamp_res(index)};
  end
end

plot((captured_req(1:length(captured_req))-capturedTimestamp_cap(1)), (captured_res-captured_req));