/*Pack and send on event multicast ip adress a Sync message*/
static void issueSync(PtpClock *ptpClock)
{
Timestamp originTimestamp;
TimeInternal internalTime;
/* try to predict outgoing time stamp */
getTime(&internalTime);
fromInternalTime(&internalTime, &originTimestamp);
msgPackSync(ptpClock, ptpClock->msgObuf, &originTimestamp);
if (!netSendEvent(&ptpClock->netPath, ptpClock->msgObuf, SYNC_LENGTH, &internalTime))
{
ERROR("issueSync: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issueSync\n");
ptpClock->sentSyncSequenceId++;
/* sync TX timestamp is valid */
if ((internalTime.seconds != 0) && (ptpClock->defaultDS.twoStepFlag))
{
// waitingForLoopback = false;
addTime(&internalTime, &internalTime, &ptpClock->outboundLatency);
issueFollowup(ptpClock, &internalTime);
}
else
{
// waitingForLoopback = ptpClock->twoStepFlag;
}
}
}
/* loop forever. doState() has a switch for the actions and events to be
checked for 'port_state'. the actions and events may or may not change
'port_state' by calling toState(), but once they are done we loop around
again and perform the actions required for the new 'port_state'. */
void
protocol(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
DBG("event POWERUP\n");
toState(PTP_INITIALIZING, rtOpts, ptpClock);
DBG("Debug Initializing...\n");
for (;;)
{
/* 20110701: this main loop was rewritten to be more clear */
if (ptpClock->portState == PTP_INITIALIZING) {
if (!doInit(rtOpts, ptpClock)) {
return;
}
} else {
doState(rtOpts, ptpClock);
}
if (ptpClock->message_activity)
DBGV("activity\n");
/* Perform the heavy signal processing synchronously */
check_signals(rtOpts, ptpClock);
}
}
/* pack and send various messages */
void issueSync(PtpClock *ptpClock)
{
TimeInternal internalTime;
TimeRepresentation originTimestamp;
++ptpClock->last_sync_event_sequence_number;
ptpClock->grandmaster_sequence_number = ptpClock->last_sync_event_sequence_number;
/* try to predict outgoing time stamp */
getTime(&internalTime, ptpClock);
fromInternalTime(&internalTime, &originTimestamp, ptpClock->halfEpoch);
msgPackSync(ptpClock->msgObuf, FALSE, TRUE, &originTimestamp, ptpClock);
if(!netSendEvent(ptpClock->msgObuf, SYNC_PACKET_LENGTH,
ptpClock->delayedTiming ? &internalTime : NULL,
ptpClock))
toState(PTP_FAULTY, ptpClock);
else
{
DBGV("sent sync message\n");
if(ptpClock->delayedTiming)
{
if (internalTime.seconds || internalTime.nanoseconds) {
/* compensate with configurable latency, then tell client real time stamp */
addTime(&internalTime, &internalTime, &ptpClock->runTimeOpts.outboundLatency);
issueFollowup(&internalTime, ptpClock);
} else {
NOTIFY("WARNING: sync message without hardware time stamp, skipped followup\n");
}
}
}
}
void issueDelayReq(PtpClock *ptpClock)
{
TimeInternal internalTime;
TimeRepresentation originTimestamp;
ptpClock->sentDelayReq = TRUE;
ptpClock->sentDelayReqSequenceId = ++ptpClock->last_sync_event_sequence_number;
/* try to predict outgoing time stamp */
getTime(&internalTime, ptpClock);
fromInternalTime(&internalTime, &originTimestamp, ptpClock->halfEpoch);
msgPackDelayReq(ptpClock->msgObuf, FALSE, FALSE, &originTimestamp, ptpClock);
if(!netSendEvent(ptpClock->msgObuf, DELAY_REQ_PACKET_LENGTH,
ptpClock->delayedTiming ? &internalTime : NULL,
ptpClock))
toState(PTP_FAULTY, ptpClock);
else
{
DBGV("sent delay request message\n");
if(ptpClock->delayedTiming)
{
if (internalTime.seconds || internalTime.nanoseconds) {
/* compensate with configurable latency, then store for later use */
addTime(&internalTime, &internalTime, &ptpClock->runTimeOpts.outboundLatency);
ptpClock->delay_req_send_time = internalTime;
} else {
NOTIFY("WARNING: delay request message without hardware time stamp, will skip response\n");
ptpClock->sentDelayReq = FALSE;
}
}
}
}
/*Pack and send on event multicast ip adress a PDelayReq message*/
static void issuePDelayReq(PtpClock *ptpClock)
{
Timestamp originTimestamp;
TimeInternal internalTime;
getTime(&internalTime);
fromInternalTime(&internalTime, &originTimestamp);
msgPackPDelayReq(ptpClock, ptpClock->msgObuf, &originTimestamp);
if (!netSendPeerEvent(&ptpClock->netPath, ptpClock->msgObuf, PDELAY_REQ_LENGTH, &internalTime))
{
ERROR("issuePDelayReq: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issuePDelayReq\n");
ptpClock->sentPDelayReqSequenceId++;
/* Delay req TX timestamp is valid */
if (internalTime.seconds != 0)
{
addTime(&internalTime, &internalTime, &ptpClock->outboundLatency);
ptpClock->pdelay_t1 = internalTime;
}
}
}
/*
this function checks if wr timer has expired for a current WR state
*/
void wrTimerExpired(UInteger8 currentState, RunTimeOpts *rtOpts, PtpPortDS *ptpPortDS, Enumeration8 wrMode)
{
UInteger8 wrStateRetry;
/*WRS_IDLE state does not expire */
if(currentState == WRS_IDLE)
return;
if(timerExpired(&ptpPortDS->wrTimers[currentState]))
{
if(currentState == WRS_CALIBRATION && ptpPortDS->calRetry > 0)
wrStateRetry = ptpPortDS->calRetry;
else if(currentState == WRS_RESP_CALIB_REQ && ptpPortDS->otherNodeCalRetry > 0)
wrStateRetry = ptpPortDS->otherNodeCalRetry;
else
wrStateRetry = ptpPortDS->wrStateRetry;
if (ptpPortDS->currentWRstateCnt < wrStateRetry)
{
PTPD_TRACE(TRACE_WR_PROTO, ptpPortDS, "WR_Slave_TIMEOUT: state[= %d] timeout, repeat state\n", currentState);
toWRState(currentState, rtOpts, ptpPortDS);
}
else
{
// PTPD_TRACE(TRACE_WR_PROTO, ptpPortDS,"WR_Slave_TIMEOUT: state[=%d] timeout, repeated %d times, going to Standard PTP\n", \
currentState,ptpPortDS->currentWRstateCnt );
ptpPortDS->wrModeON = FALSE;
toWRState(WRS_IDLE, rtOpts, ptpPortDS);
if(rtOpts->disableFallbackIfWRFails)
{
PTPD_TRACE(TRACE_WR_PROTO, ptpPortDS,"WR_Slave_TIMEOUT: state[=%d] timeout, disabling port (standard PTP fallback OFF).\n", currentState);
toState(PTP_DISABLED, rtOpts, ptpPortDS);
} else if(wrMode == WR_MASTER)
toState(PTP_MASTER, rtOpts, ptpPortDS);
else toState(PTP_SLAVE, rtOpts, ptpPortDS);
/*
* RE-INITIALIZATION OF White Rabbit Data Sets
* (chapter (Re-)Initialization of wrspec
*/
initWrData(ptpPortDS, INIT); //INIT mode because we don't need to remember WR port mode and port role
}
}
}
static void handleDelayReq(PtpClock *ptpClock, TimeInternal *time, Boolean isFromSelf)
{
switch (ptpClock->portDS.delayMechanism)
{
case E2E:
DBGV("handleDelayReq: received\n");
if (ptpClock->msgIbufLength < DELAY_REQ_LENGTH)
{
ERROR("handleDelayReq: short message\n");
toState(ptpClock, PTP_FAULTY);
return;
}
switch (ptpClock->portDS.portState)
{
case PTP_INITIALIZING:
case PTP_FAULTY:
case PTP_DISABLED:
case PTP_UNCALIBRATED:
case PTP_LISTENING:
DBGV("handleDelayReq: disreguard\n");
return;
case PTP_SLAVE:
DBGV("handleDelayReq: disreguard\n");
// if (isFromSelf)
// {
// /* waitingForLoopback? */
// /* Get sending timestamp from IP stack with So_TIMESTAMP*/
// ptpClock->delay_req_send_time = *time;
// /*Add latency*/
// addTime(&ptpClock->delay_req_send_time, &ptpClock->delay_req_send_time, &rtOpts->outboundLatency);
// break;
// }
break;
case PTP_MASTER:
/* TODO: manage the value of ptpClock->logMinDelayReqInterval form logSyncInterval to logSyncInterval + 5 */
issueDelayResp(ptpClock, time, &ptpClock->msgTmpHeader);
break;
default:
DBG("handleDelayReq: unrecognized state\n");
break;
}
break;
case P2P:
ERROR("handleDelayReq: disreguard in P2P mode\n");
break;
default:
/* none */
break;
}
}
void handleDelayReq(MsgHeader *header, Octet *msgIbuf, ssize_t length, TimeInternal *time, Boolean badTime, Boolean isFromSelf, PtpClock *ptpClock)
{
if(length < DELAY_REQ_PACKET_LENGTH)
{
ERROR("short delay request message\n");
toState(PTP_FAULTY, ptpClock);
return;
}
switch(ptpClock->port_state)
{
case PTP_MASTER:
if(isFromSelf)
{
DBG("handleDelayReq: ignore from self\n");
return;
}
if( header->sourceCommunicationTechnology == ptpClock->clock_communication_technology
|| header->sourceCommunicationTechnology == PTP_DEFAULT
|| ptpClock->clock_communication_technology == PTP_DEFAULT )
{
if( badTime )
NOTIFY("avoid inaccurate DelayResp because of bad time stamp\n");
else
issueDelayResp(time, &ptpClock->msgTmpHeader, ptpClock);
}
break;
case PTP_SLAVE:
if(isFromSelf)
{
DBG("handleDelayReq: self\n");
ptpClock->delay_req_send_time.seconds = time->seconds;
ptpClock->delay_req_send_time.nanoseconds = time->nanoseconds;
addTime(&ptpClock->delay_req_send_time, &ptpClock->delay_req_send_time, &ptpClock->runTimeOpts.outboundLatency);
if(ptpClock->delay_req_receive_time.seconds)
{
updateDelay(&ptpClock->delay_req_send_time, &ptpClock->delay_req_receive_time,
&ptpClock->owd_filt, ptpClock);
ptpClock->delay_req_send_time.seconds = 0;
ptpClock->delay_req_send_time.nanoseconds = 0;
ptpClock->delay_req_receive_time.seconds = 0;
ptpClock->delay_req_receive_time.nanoseconds = 0;
}
}
break;
default:
DBGV("handleDelayReq: disreguard\n");
return;
}
}
void handleDelayResp(MsgHeader *header, Octet *msgIbuf, ssize_t length, Boolean isFromSelf, PtpClock *ptpClock)
{
MsgDelayResp *resp;
if(length < DELAY_RESP_PACKET_LENGTH)
{
ERROR("short delay request message\n");
toState(PTP_FAULTY, ptpClock);
return;
}
switch(ptpClock->port_state)
{
case PTP_SLAVE:
if(isFromSelf)
{
DBG("handleDelayResp: ignore from self\n");
return;
}
resp = &ptpClock->msgTmp.resp;
msgUnpackDelayResp(ptpClock->msgIbuf, resp);
if( ptpClock->sentDelayReq
&& resp->requestingSourceSequenceId == ptpClock->sentDelayReqSequenceId
&& resp->requestingSourceCommunicationTechnology == ptpClock->port_communication_technology
&& resp->requestingSourcePortId == ptpClock->port_id_field
&& !memcmp(resp->requestingSourceUuid, ptpClock->port_uuid_field, PTP_UUID_LENGTH)
&& header->sourceCommunicationTechnology == ptpClock->parent_communication_technology
&& header->sourcePortId == ptpClock->parent_port_id
&& !memcmp(header->sourceUuid, ptpClock->parent_uuid, PTP_UUID_LENGTH) )
{
ptpClock->sentDelayReq = FALSE;
toInternalTime(&ptpClock->delay_req_receive_time, &resp->delayReceiptTimestamp, &ptpClock->halfEpoch);
if(ptpClock->delay_req_send_time.seconds)
{
updateDelay(&ptpClock->delay_req_send_time, &ptpClock->delay_req_receive_time,
&ptpClock->owd_filt, ptpClock);
ptpClock->delay_req_send_time.seconds = 0;
ptpClock->delay_req_send_time.nanoseconds = 0;
ptpClock->delay_req_receive_time.seconds = 0;
ptpClock->delay_req_receive_time.nanoseconds = 0;
}
}
else
{
DBGV("handleDelayResp: unwanted\n");
}
break;
default:
DBGV("handleDelayResp: disreguard\n");
return;
}
}
void
handlePDelayRespFollowUp(MsgHeader *header, Octet *msgIbuf, ssize_t length,
Boolean isFromSelf, RunTimeOpts *rtOpts,
PtpClock *ptpClock){
if (ptpClock->delayMechanism == P2P) {
TimeInternal responseOriginTimestamp;
TimeInternal correctionField;
DBGV("PdelayRespfollowup message received : \n");
if(length < PDELAY_RESP_FOLLOW_UP_LENGTH) {
ERROR("short PDelayRespfollowup message\n");
toState(PTP_FAULTY, rtOpts, ptpClock);
return;
}
switch(ptpClock->portState) {
case PTP_INITIALIZING:
case PTP_FAULTY:
case PTP_DISABLED:
case PTP_UNCALIBRATED:
DBGV("HandlePdelayResp : disregard\n");
return;
case PTP_SLAVE:
case PTP_MASTER:
if ((header->sequenceId ==
ptpClock->sentPDelayReqSequenceId-1) && (header->sequenceId == ptpClock->recvPDelayRespSequenceId)) {
msgUnpackPDelayRespFollowUp(
ptpClock->msgIbuf,
&ptpClock->msgTmp.prespfollow);
toInternalTime(
&responseOriginTimestamp,
&ptpClock->msgTmp.prespfollow.responseOriginTimestamp);
ptpClock->pdelay_resp_send_time.seconds =
responseOriginTimestamp.seconds;
ptpClock->pdelay_resp_send_time.nanoseconds =
responseOriginTimestamp.nanoseconds;
integer64_to_internalTime(
ptpClock->msgTmpHeader.correctionfield,
&correctionField);
addTime(&correctionField,&correctionField,
&ptpClock->lastPdelayRespCorrectionField);
updatePeerDelay (&ptpClock->owd_filt,
rtOpts, ptpClock,
&correctionField,TRUE);
break;
}
default:
DBGV("Disregard PdelayRespFollowUp message \n");
}
} else { /* (End to End mode..) */
ERROR("Peer Delay messages are disregarded in End to End "
"mode \n");
}
}
void
handlePDelayReq(MsgHeader *header, Octet *msgIbuf, ssize_t length,
TimeInternal *time, Boolean isFromSelf,
RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
if (ptpClock->delayMechanism == P2P) {
DBGV("PdelayReq message received : \n");
if(length < PDELAY_REQ_LENGTH) {
ERROR("short PDelayReq message\n");
toState(PTP_FAULTY, rtOpts, ptpClock);
return;
}
switch (ptpClock->portState ) {
case PTP_INITIALIZING:
case PTP_FAULTY:
case PTP_DISABLED:
case PTP_UNCALIBRATED:
case PTP_LISTENING:
DBGV("HandlePdelayReq : disregard\n");
return;
case PTP_SLAVE:
case PTP_MASTER:
case PTP_PASSIVE:
if (isFromSelf) {
/*
* Get sending timestamp from IP stack
* with SO_TIMESTAMP
*/
ptpClock->pdelay_req_send_time.seconds =
time->seconds;
ptpClock->pdelay_req_send_time.nanoseconds =
time->nanoseconds;
/*Add latency*/
addTime(&ptpClock->pdelay_req_send_time,
&ptpClock->pdelay_req_send_time,
&rtOpts->outboundLatency);
break;
} else {
msgUnpackHeader(ptpClock->msgIbuf,
&ptpClock->PdelayReqHeader);
issuePDelayResp(time, header, rtOpts,
ptpClock);
break;
}
default:
DBG("do unrecognized state3\n");
break;
}
} else /* (End to End mode..) */
ERROR("Peer Delay messages are disregarded in End to End "
"mode \n");
}
void handleFollowUp(MsgHeader *header, Octet *msgIbuf, ssize_t length, Boolean isFromSelf, PtpClock *ptpClock)
{
MsgFollowUp *follow;
TimeInternal preciseOriginTimestamp;
if(length < FOLLOW_UP_PACKET_LENGTH)
{
ERROR("short folow up message\n");
toState(PTP_FAULTY, ptpClock);
return;
}
switch(ptpClock->port_state)
{
case PTP_SLAVE:
if(isFromSelf)
{
DBG("handleFollowUp: ignore from self\n");
return;
}
if(getFlag(header->flags, PTP_SYNC_BURST) && !ptpClock->burst_enabled)
return;
DBGV("handleFollowUp: looking for uuid %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
ptpClock->parent_uuid[0], ptpClock->parent_uuid[1], ptpClock->parent_uuid[2],
ptpClock->parent_uuid[3], ptpClock->parent_uuid[4], ptpClock->parent_uuid[5]);
follow = &ptpClock->msgTmp.follow;
msgUnpackFollowUp(ptpClock->msgIbuf, follow);
if( ptpClock->waitingForFollow
&& follow->associatedSequenceId == ptpClock->parent_last_sync_sequence_number
&& header->sourceCommunicationTechnology == ptpClock->parent_communication_technology
&& header->sourcePortId == ptpClock->parent_port_id
&& !memcmp(header->sourceUuid, ptpClock->parent_uuid, PTP_UUID_LENGTH) )
{
ptpClock->waitingForFollow = FALSE;
toInternalTime(&preciseOriginTimestamp, &follow->preciseOriginTimestamp, &ptpClock->halfEpoch);
updateOffset(&preciseOriginTimestamp, &ptpClock->sync_receive_time,
&ptpClock->ofm_filt, ptpClock);
updateClock(ptpClock);
}
else
{
DBGV("handleFollowUp: unwanted\n");
}
break;
default:
DBGV("handleFollowUp: disreguard\n");
return;
}
}
Boolean doInit(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
DBG("manufacturerIdentity: %s\n", MANUFACTURER_ID);
/* initialize networking */
netShutdown(&ptpClock->netPath);
if(!netInit(&ptpClock->netPath, rtOpts, ptpClock))
{
ERROR("failed to initialize network\n");
toState(PTP_FAULTY, rtOpts, ptpClock);
return FALSE;
}
/* initialize other stuff */
initData(rtOpts, ptpClock);
initTimer();
initClock(rtOpts, ptpClock);
m1(ptpClock);
msgPackHeader(ptpClock->msgObuf, ptpClock);
DBG("sync message interval: %d\n", PTP_SYNC_INTERVAL_TIMEOUT(ptpClock->sync_interval));
DBG("clock identifier: %s\n", ptpClock->clock_identifier);
DBG("256*log2(clock variance): %d\n", ptpClock->clock_variance);
DBG("clock stratum: %d\n", ptpClock->clock_stratum);
DBG("clock preferred?: %s\n", ptpClock->preferred?"yes":"no");
DBG("bound interface name: %s\n", rtOpts->ifaceName);
DBG("communication technology: %d\n", ptpClock->port_communication_technology);
DBG("uuid: %02x:%02x:%02x:%02x:%02x:%02x\n",
ptpClock->port_uuid_field[0], ptpClock->port_uuid_field[1], ptpClock->port_uuid_field[2],
ptpClock->port_uuid_field[3], ptpClock->port_uuid_field[4], ptpClock->port_uuid_field[5]);
DBG("PTP subdomain name: %s\n", ptpClock->subdomain_name);
DBG("subdomain address: %x.%x.%x.%x\n",
ptpClock->subdomain_address[0], ptpClock->subdomain_address[1],
ptpClock->subdomain_address[2], ptpClock->subdomain_address[3]);
DBG("event port address: %x %x\n",
ptpClock->event_port_address[0], ptpClock->event_port_address[1]);
DBG("general port address: %x %x\n",
ptpClock->general_port_address[0], ptpClock->general_port_address[1]);
toState(PTP_LISTENING, rtOpts, ptpClock);
return TRUE;
}
JNIEXPORT void JNICALL Java_com_husqvarnagroup_connectivity_HcpJNI_CloseState
(JNIEnv * Env, jobject Object, jlong StateHandle){
try {
if(StateHandle != 0) {
hcp_CloseState(toState(StateHandle));
free((void*)StateHandle);
}
}
catch (JavaException const& ex) {
ex.propagateToJava(*Env);
}
}
void issueDelayResp(TimeInternal *time, MsgHeader *header, PtpClock *ptpClock)
{
TimeRepresentation delayReceiptTimestamp;
++ptpClock->last_general_event_sequence_number;
fromInternalTime(time, &delayReceiptTimestamp, ptpClock->halfEpoch);
msgPackDelayResp(ptpClock->msgObuf, header, &delayReceiptTimestamp, ptpClock);
if(!netSendGeneral(ptpClock->msgObuf, DELAY_RESP_PACKET_LENGTH, ptpClock))
toState(PTP_FAULTY, ptpClock);
else
DBGV("sent delay response message\n");
}
void issueManagement(MsgHeader *header, MsgManagement *manage, PtpClock *ptpClock)
{
UInteger16 length;
++ptpClock->last_general_event_sequence_number;
if(!(length = msgPackManagementResponse(ptpClock->msgObuf, header, manage, ptpClock)))
return;
if(!netSendGeneral(ptpClock->msgObuf, length, ptpClock))
toState(PTP_FAULTY, ptpClock);
else
DBGV("sent management message\n");
}
void issueFollowup(TimeInternal *time, PtpClock *ptpClock)
{
TimeRepresentation preciseOriginTimestamp;
++ptpClock->last_general_event_sequence_number;
fromInternalTime(time, &preciseOriginTimestamp, ptpClock->halfEpoch);
msgPackFollowUp(ptpClock->msgObuf, ptpClock->last_sync_event_sequence_number, &preciseOriginTimestamp, ptpClock);
if(!netSendGeneral(ptpClock->msgObuf, FOLLOW_UP_PACKET_LENGTH, ptpClock))
toState(PTP_FAULTY, ptpClock);
else
DBGV("sent followup message\n");
}
/*Pack and send on general multicast ip adress an Announce message*/
void
issueAnnounce(RunTimeOpts *rtOpts,PtpClock *ptpClock)
{
msgPackAnnounce(ptpClock->msgObuf,ptpClock);
if (!netSendGeneral(ptpClock->msgObuf,ANNOUNCE_LENGTH,
&ptpClock->netPath, 0)) {
toState(PTP_FAULTY,rtOpts,ptpClock);
DBGV("Announce message can't be sent -> FAULTY state \n");
} else {
DBGV("Announce MSG sent ! \n");
ptpClock->sentAnnounceSequenceId++;
}
}
JNIEXPORT void JNICALL Java_com_husqvarnagroup_connectivity_HcpJNI_CloseCodec
(JNIEnv * env, jobject, jlong StateHandle, jlong CodecId)
{
try {
auto state = toState(StateHandle);
auto codec_id = static_cast<hcp_Size_t>(CodecId);
auto res = hcp_CloseCodec(state, codec_id);
if (res != HCP_NOERROR)
throw hcpException( res);
}
catch (JavaException const& ex) {
ex.propagateToJava(*env);
}
}
Boolean
doInit(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
DBG("manufacturerIdentity: %s\n", MANUFACTURER_ID);
/* initialize networking */
netShutdown(&ptpClock->netPath);
if (!netInit(&ptpClock->netPath, rtOpts, ptpClock)) {
ERROR("failed to initialize network\n");
toState(PTP_FAULTY, rtOpts, ptpClock);
return FALSE;
}
/* initialize other stuff */
initData(rtOpts, ptpClock);
initTimer();
initClock(rtOpts, ptpClock);
m1(rtOpts, ptpClock );
msgPackHeader(ptpClock->msgObuf, ptpClock);
toState(PTP_LISTENING, rtOpts, ptpClock);
return TRUE;
}
/*Pack and send on general multicast ip adress an Announce message*/
static void issueAnnounce(PtpClock *ptpClock)
{
msgPackAnnounce(ptpClock, ptpClock->msgObuf);
if (!netSendGeneral(&ptpClock->netPath, ptpClock->msgObuf, ANNOUNCE_LENGTH))
{
ERROR("issueAnnounce: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issueAnnounce\n");
ptpClock->sentAnnounceSequenceId++;
}
}
/*Pack and send on general multicast ip adress a FollowUp message*/
void
issueFollowup(TimeInternal *time,RunTimeOpts *rtOpts,PtpClock *ptpClock)
{
Timestamp preciseOriginTimestamp;
fromInternalTime(time,&preciseOriginTimestamp);
msgPackFollowUp(ptpClock->msgObuf,&preciseOriginTimestamp,ptpClock);
if (!netSendGeneral(ptpClock->msgObuf,FOLLOW_UP_LENGTH,
&ptpClock->netPath, 0)) {
toState(PTP_FAULTY,rtOpts,ptpClock);
DBGV("FollowUp message can't be sent -> FAULTY state \n");
} else {
DBGV("FollowUp MSG sent ! \n");
}
}
/*Pack and send on event multicast ip adress a DelayResp message*/
static void issueDelayResp(PtpClock *ptpClock, const TimeInternal *time, const MsgHeader * delayReqHeader)
{
Timestamp requestReceiptTimestamp;
fromInternalTime(time, &requestReceiptTimestamp);
msgPackDelayResp(ptpClock, ptpClock->msgObuf, delayReqHeader, &requestReceiptTimestamp);
if (!netSendGeneral(&ptpClock->netPath, ptpClock->msgObuf, PDELAY_RESP_LENGTH))
{
ERROR("issueDelayResp: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issueDelayResp\n");
}
}
static void issuePDelayRespFollowUp(PtpClock *ptpClock, const TimeInternal *time, const MsgHeader * pDelayReqHeader)
{
Timestamp responseOriginTimestamp;
fromInternalTime(time, &responseOriginTimestamp);
msgPackPDelayRespFollowUp(ptpClock->msgObuf, pDelayReqHeader, &responseOriginTimestamp);
if (!netSendPeerGeneral(&ptpClock->netPath, ptpClock->msgObuf, PDELAY_RESP_FOLLOW_UP_LENGTH))
{
ERROR("issuePDelayRespFollowUp: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issuePDelayRespFollowUp\n");
}
}
/*Pack and send on event multicast ip adress a PDelayResp message*/
void
issuePDelayResp(TimeInternal *time,MsgHeader *header,RunTimeOpts *rtOpts,
PtpClock *ptpClock)
{
Timestamp requestReceiptTimestamp;
fromInternalTime(time,&requestReceiptTimestamp);
msgPackPDelayResp(ptpClock->msgObuf,header,
&requestReceiptTimestamp,ptpClock);
if (!netSendPeerEvent(ptpClock->msgObuf,PDELAY_RESP_LENGTH,
&ptpClock->netPath)) {
toState(PTP_FAULTY,rtOpts,ptpClock);
DBGV("PdelayResp message can't be sent -> FAULTY state \n");
} else {
DBGV("PDelayResp MSG sent ! \n");
}
}
void issueDelayReq(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
TimeInternal internalTime;
TimeRepresentation originTimestamp;
ptpClock->sentDelayReq = TRUE;
ptpClock->sentDelayReqSequenceId = ++ptpClock->last_sync_event_sequence_number;
getTime(&internalTime);
fromInternalTime(&internalTime, &originTimestamp, ptpClock->halfEpoch);
msgPackDelayReq(ptpClock->msgObuf, FALSE, &originTimestamp, ptpClock);
if(!netSendEvent(ptpClock->msgObuf, DELAY_REQ_PACKET_LENGTH, &ptpClock->netPath))
toState(PTP_FAULTY, rtOpts, ptpClock);
else
DBGV("sent delay request message\n");
}
/* pack and send various messages */
void issueSync(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
TimeInternal internalTime;
TimeRepresentation originTimestamp;
++ptpClock->last_sync_event_sequence_number;
ptpClock->grandmaster_sequence_number = ptpClock->last_sync_event_sequence_number;
getTime(&internalTime);
fromInternalTime(&internalTime, &originTimestamp, ptpClock->halfEpoch);
msgPackSync(ptpClock->msgObuf, FALSE, &originTimestamp, ptpClock);
if(!netSendEvent(ptpClock->msgObuf, SYNC_PACKET_LENGTH, &ptpClock->netPath))
toState(PTP_FAULTY, rtOpts, ptpClock);
else
DBGV("sent sync message\n");
}
/*Pack and send on general multicast ip adress a FollowUp message*/
static void issueFollowup(PtpClock *ptpClock, const TimeInternal *time)
{
Timestamp preciseOriginTimestamp;
fromInternalTime(time, &preciseOriginTimestamp);
msgPackFollowUp(ptpClock, ptpClock->msgObuf, &preciseOriginTimestamp);
if (!netSendGeneral(&ptpClock->netPath, ptpClock->msgObuf, FOLLOW_UP_LENGTH))
{
ERROR("issueFollowup: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issueFollowup\n");
}
}
/*Pack and send on event multicast ip adress a Sync message*/
void
issueSync(RunTimeOpts *rtOpts,PtpClock *ptpClock)
{
Timestamp originTimestamp;
TimeInternal internalTime;
getTime(&internalTime);
fromInternalTime(&internalTime,&originTimestamp);
msgPackSync(ptpClock->msgObuf,&originTimestamp,ptpClock);
if (!netSendEvent(ptpClock->msgObuf,SYNC_LENGTH,&ptpClock->netPath, 0)) {
toState(PTP_FAULTY,rtOpts,ptpClock);
DBGV("Sync message can't be sent -> FAULTY state \n");
} else {
DBGV("Sync MSG sent ! \n");
ptpClock->sentSyncSequenceId++;
}
}
/* first time in a non-rtos system, call this function */
void protocol_first(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
DBG("event POWERUP\n");
toState(PTP_INITIALIZING, rtOpts, ptpClock);
if(ptpClock->port_state != PTP_INITIALIZING)
doState(rtOpts, ptpClock);
else if(!doInit(rtOpts, ptpClock))
return;
if(ptpClock->message_activity)
DBGV("activity\n");
#if 0
else
DBGV("no activity\n");
#endif
}
