void setup() {
for (uint8_t pin=bit0_pin; pin < bit15_pin; ++pin) {
pinMode(pin, OUTPUT);
digitalWrite(pin, HIGH);
}
delay(500);
for (uint8_t pin=bit0_pin; pin < bit15_pin; ++pin) {
digitalWrite(pin, LOW);
}
pinMode(dcf77_sample_pin, INPUT);
digitalWrite(dcf77_sample_pin, HIGH);
pinMode(filtered_dcf77_pin, OUTPUT);
MsTimer2::set(1, low_pass_filter);
MsTimer2::start();
DCF.Start();
setSyncInterval(30);
setSyncProvider(getDCFTime);
Serial.begin(9600);;
diagnosis();
}
void setup_ntp(){
// setup NTP sync service
Udp.begin(ntp_port);
Serial.println(F("Waiting for NTP sync"));
setSyncInterval(600); // initial one 10 minutes to take care of most of the drift
setSyncProvider(getNtpTime);
}
void setup() {
Serial.begin(9600);
Serial.println("$CLS#Setup()");
pinMode(RED, OUTPUT);
pinMode(GREEN, OUTPUT);
pinMode(BLUE, OUTPUT);
LcdInit();
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) {
PulseLed(RED, 2, 10, 10);
PulseLed(BLUE, 2, 10, 10);
PulseLed(GREEN, 2, 10, 10);
Serial.print(".");
LcdPrint(".");
}
Udp.begin(localPort);
setSyncInterval(300);
setSyncProvider(getNtpTime);
// Turn on the backlight.
LcdClear();
LcdnoBacklight();
delay(2000);
LcdBacklight();
}
void Clock::boot(void) {
settings.TZ = -6;
settings.IS_DST = true;
setSyncProvider(RTC.get); // the function to get the time from the RTC
setSyncInterval(SECS_PER_MIN);
}
void seissol::writer::ReceiverWriter::init( std::string const& fileNamePrefix,
double samplingInterval,
double syncPointInterval)
{
m_fileNamePrefix = fileNamePrefix;
m_samplingInterval = samplingInterval;
setSyncInterval(syncPointInterval);
Modules::registerHook(*this, SYNCHRONIZATION_POINT);
}
void Sched::actTime(STATE& st){
Serial.println(unix);
Serial.println(LLLL);
Serial.println(zone);
time_t datetime = unix + zone*60*60;
Serial.println(datetime);
setTime(datetime);
setSyncInterval(4000000);
Serial.println(hour());
NEW_MAIL=0;
//Alarm.alarmOnce(hour(), minute()+1,0,abdd);
}
inline void page_modifyTime() {
static int timeScaleIndex = 0;
if (pre_page != MODIFY_TIME)
{
PTLS("Page Mod Time");
pre_page = MODIFY_TIME;
lcd.cursor();
}
lcd.setCursor(0,1);
String str_time = getTimeString();
lcd.print(str_time);
if (timeScaleIndex == 0) lcd.setCursor(0,1);
else if (timeScaleIndex == 1) lcd.setCursor(0,4);
else if (timeScaleIndex == 2) lcd.setCursor(0,7);
if (button_input == PLUS_UP || button_input == PLUS_HOLD)
{
long adjust = timeScale[timeScaleIndex];
adjustTime(adjust);
setSyncInterval(SCALE_HOUR);
}
else if (button_input == MINUS_UP || button_input == MINUS_HOLD)
{
long adjust = -timeScale[timeScaleIndex];
adjustTime(adjust);
setSyncInterval(SCALE_HOUR);
}
else if (button_input == SET_UP)
{
setSyncInterval( 3600 );
switchPage(HOME);
}
else if (button_input == MODE_UP)
{
timeScaleIndex++;
timeScaleIndex = timeScaleIndex % 3;
PTS("Changed focus: "); PTL(timeScaleIndex);
}
}
void loop() {
frontpanel_set_led( IDLE_LED, 1 );
frontpanel_set_led( COMM_LED, 1 );
Ethernet.maintain();
now(); // see if its time to sync
// if( !client.connected() ){
// Serial.println(F("Client disconnected, attempting reconnect..."));
// client.stop();
// setup_data_stream();
// }
frontpanel_set_led( COMM_LED, 0 );
// if we havent extended the time period yet,
// and if there is a non-zero drift correction
// then make the period longer
if( (!longerSyncPeriod) & getDriftCorrection() ){
Serial.println("syncing to network time.");
setSyncInterval(72000); // every 2 hours
longerSyncPeriod=1;
}
uint8_t newTrig = 1;
if( millis() > nextTrig ){
newTrig = 0;
nextTrig = millis() + 200;
}
//uint8_t newTrig = digitalRead(trigpin); // TODO: replace with frontpanel function
if( lastTrig && !newTrig ){ // trig on low to high trigger
//if( !lastTrig && newTrig ){ // trig on high to low trigger
frontpanel_set_led( IDLE_LED, 0 );
//Send string back to client
if(addReadings() == AMC7812_TIMEOUT_ERR){
frontpanel_set_led( ERR1_LED, 1 );
frontpanel_set_led( ERR2_LED, 1 ); // keep on so I know it entered this state
setup_DAQ();
frontpanel_set_led( ERR1_LED, 0 );
}
}
lastTrig = newTrig;
// check for incoming packet, do stuff if we need to
uint8_t len = client.available();
if( len ){
Serial.println("incoming packet");
frontpanel_set_led( COMM_LED, 1 );
len = ZMQPush.read(); // process header and get get actual mesg length
frontpanel_set_led( COMM_LED, 0 );
}
//Serial.println("loop");
}
void setup() {
#ifdef DEBUG
Serial.begin(9600);
#endif
pinMode(RELAY_SW_OUT, OUTPUT);
pinMode(CMD_MAN_IN, INPUT_PULLUP);
// Setup watchdog timeout to 8 s (mode 9)
setupWatchdog(WD_TICK_TIME);
// Watchdog interrupt count before reading light value
// example: wd count * wd interval == 4 * 8 s = 32 s
// Start with "enable" time tick and then check the current time
wdMatch = (uint16_t) WD_WAIT_EN_TIME / WD_TICK_TIME;
// Setup Pin change interrupt on PCINT1
GIMSK |= _BV(PCIE);
PCMSK |= _BV(PCINT1);
// Set the internal registers to reduce power consumes
ACSR = (1 << ACD); // Shut down the analog comparator
MCUCR |= (1 << BODS); // BOD disabled
// I2C begin() is called BEFORE sensors library "begin" methods:
// it is called just once for all the sensors.
bus.begin();
// Sensors initialization
// Light sensor
BH1750.powerOn();
BH1750.setMode(BH1750_CONTINUOUS_HIGH_RES_MODE_2);
BH1750.setMtreg(200); // Set measurement time register to high value
delay(100);
BH1750.sleep(); // Send light sensor to sleep
// Real time clock
setSyncProvider(timeProvider); // Pointer to function to get the time from the RTC
setSyncInterval(WD_WAIT_DIS_TIME); // Set system time at every sensor read
// Update drift info from RTC
di = RTC.read_DriftInfo();
di.DriftDays = 1000; // RTC drift in seconds/day. 18 s per day is 18000/1000
di.DriftSeconds = 27857;
RTC.write_DriftInfo(di);
setDriftInfo(di);
}
void setup() {
Serial.begin(9600);
setupEthernet();
setSyncInterval(NTP_TIME_SYNC_INTERVAL);
setSyncProvider(getNtpTime);
if(timeStatus()== timeNotSet)
{
Serial.println("Sync failed during start");
}
else
{
Serial.println("Sync successfully during start");
}
}
void setAquariaTime() {
// first check to see if the RTC is already set
if (RTC.get == 0) {
// it's not so initialize the RTC with info
// from the compiler
getDate(__DATE__) && getTime(__TIME__);
RTC.write(tm);
}
// it is so lets...
setSyncProvider(RTC.get); // ...set the system time
// and check to see if it worked
if (timeStatus() != timeSet)
Serial.println("Unable to sync with the RTC");
else
Serial.println("RTC has set the system time");
setSyncInterval(60000); // sync system time with RTC every hour
}
void setup()
{
fsmState = EDIT_TIME_MODE;
// initialize thermometer
sensor.begin();
sensor.setWaitForConversion(true);
sensor.getAddress(devAddr, 0);
sensor.requestTemperatures();
tempInCelsius = (int) (sensor.getTempC(devAddr)*10);
// initialize buttons
buttonA.setClickTicks(250);
buttonA.setPressTicks(600);
buttonA.attachLongPressStart(longPressA);
buttonA.attachClick(singleClickA);
buttonA.attachDoubleClick(doubleClickA);
buttonB.setClickTicks(250);
buttonB.setPressTicks(600);
buttonB.attachClick(singleClickB);
buttonB.attachDoubleClick(doubleClickB);
buttonB.attachLongPressStart(longPressB);
// initialize serial
Serial.begin(115200);
// initialize rtc
setSyncProvider(RTC.get);
setSyncInterval(1);
if(timeStatus()!= timeSet)
{
Serial.println("Unable to sync with the RTC");
fsmState = ERROR_MODE;
} else
{
Serial.println("RTC has set the system time");
}
// default alarm settings, 08:30, disabled
pinMode(ALARM_PIN, INPUT_PULLUP);
}
// ======================
// Setup Function
// ======================
void do_setup() {
/* Clear WDT reset flag. */
MCUSR &= ~(1<<WDRF);
DEBUG_BEGIN(9600);
DEBUG_PRINTLN("started.");
os.begin(); // OpenSprinkler init
os.options_setup(); // Setup options
pd.init(); // ProgramData init
setSyncInterval(RTC_SYNC_INTERVAL); // RTC sync interval
// if rtc exists, sets it as time sync source
setSyncProvider(RTC.get);
os.lcd_print_time(os.now_tz()); // display time to LCD
// enable WDT
/* In order to change WDE or the prescaler, we need to
* set WDCE (This will allow updates for 4 clock cycles).
*/
WDTCSR |= (1<<WDCE) | (1<<WDE);
/* set new watchdog timeout prescaler value */
WDTCSR = 1<<WDP3 | 1<<WDP0; // 8.0 seconds
/* Enable the WD interrupt (note no reset). */
WDTCSR |= _BV(WDIE);
if (os.start_network()) { // initialize network
os.status.network_fails = 0;
} else {
os.status.network_fails = 1;
}
os.status.req_network = 0;
os.status.req_ntpsync = 1;
os.apply_all_station_bits(); // reset station bits
os.button_timeout = LCD_BACKLIGHT_TIMEOUT;
}
void setup() {
memset(voltsChr,0,sizeof(voltsChr));
memset(amps0Chr,0,sizeof(amps0Chr));
memset(amps1Chr,0,sizeof(amps1Chr));
memset(tmpChr,0,sizeof(tmpChr));
// if the program crashed, skip things that might make it crash
String rebootMsg = ESP.getResetReason();
if (rebootMsg=="Exception") safeMode=true;
else if (rebootMsg=="Hardware Watchdog") safeMode=true;
else if (rebootMsg=="Unknown") safeMode=true;
else if (rebootMsg=="Software Watchdog") safeMode=true;
if (sw1>=0) {
pinMode(sw1, OUTPUT);
}
if (sw2>=0) {
pinMode(sw2, OUTPUT);
}
if (sw3>=0) {
pinMode(sw3, OUTPUT);
}
if (sw4>=0) {
pinMode(sw4, OUTPUT);
}
// "mount" the filesystem
bool success = SPIFFS.begin();
if (!success) SPIFFS.format();
if (!safeMode) fsConfig(); // read node config from FS
#ifdef _TRAILER
wifiMulti.addAP("DXtrailer", "2317239216");
#else
wifiMulti.addAP("Tell my WiFi I love her", "2317239216");
#endif
int wifiConnect = 240;
while ((wifiMulti.run() != WL_CONNECTED) && (wifiConnect-- > 0)) { // spend 2 minutes trying to connect to wifi
// connecting to wifi
delay(1000);
}
if (wifiMulti.run() != WL_CONNECTED ) { // still not connected? reboot!
ESP.reset();
delay(5000);
}
if (hasHostname) { // valid config found on FS, set network name
WiFi.hostname(String(nodename)); // set network hostname
ArduinoOTA.setHostname(nodename); // OTA hostname defaults to esp8266-[ChipID]
MDNS.begin(nodename); // set mDNS hostname
}
WiFi.macAddress(mac); // get esp mac address, store it in memory, build fw update url
sprintf(macStr,"%x%x%x%x%x%x", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
sprintf(theURL,"/iotfw?mac=%s", macStr);
// request latest config from web api
if (!safeMode) getConfig();
// check web api for new firmware
if (!safeMode) httpUpdater();
// start UDP for ntp client
udp.begin(localPort);
updateNTP();
setSyncProvider(getNtptime); // use NTP to get current time
setSyncInterval(600); // refresh clock every 10 min
#ifndef _MINI
// start the webserver
httpd.onNotFound(handleNotFound);
httpd.begin();
// Add service to MDNS-SD
MDNS.addService("http", "tcp", 80);
#endif
// start websockets server
webSocket.begin();
webSocket.onEvent(webSocketEvent);
// setup other things
setupOTA();
setupMQTT();
// setup i2c if configured, basic sanity checking on configuration
if (hasI2C && iotSDA>=0 && iotSCL>=0 && iotSDA!=iotSCL) {
sprintf(str,"I2C enabled, using SDA=%u SCL=%u", iotSDA, iotSCL);
mqtt.publish(mqttpub, str);
Wire.begin(iotSDA, iotSCL); // from api config file
//Wire.begin(12, 14); // from api config file
i2c_scan();
printConfig();
if (hasRGB) setupRGB();
if (hasIout) setupADS();
if (hasSpeed) setupSpeed();
}
// OWDAT = 4;
if (OWDAT>0) { // setup onewire if data line is using pin 1 or greater
sprintf(str,"Onewire Data OWDAT=%u", OWDAT);
mqtt.publish(mqttpub, str);
oneWire.begin(OWDAT);
if (hasTout) {
ds18b20 = DallasTemperature(&oneWire);
ds18b20.begin(); // start one wire temp probe
}
if (hasTpwr>0) {
pinMode(hasTpwr, OUTPUT); // onewire power pin as output
digitalWrite(hasTpwr, LOW); // ow off
}
}
if (useMQTT) {
String rebootReason = String("Last reboot cause was ") + rebootMsg;
rebootReason.toCharArray(str, rebootReason.length()+1);
mqtt.publish(mqttpub, str);
}
}
/**
* \brief Disables NTP synchronization.
*
* Disables the NTP synchronization and leaves current time untouched.
*/
void Aquaduino::disableNTP() {
m_NTP = 0;
setSyncInterval(m_NTPSyncInterval * 60);
setSyncProvider(NULL);
}
/**
* \brief Enables NTP synchronization.
*
* Enables the NTP flag and directly performs a NTP synchronization request.
* The NTP synchronization interval is set to the value set by
* setNtpSyncInterval.
*/
void Aquaduino::enableNTP() {
m_NTP = 1;
setSyncInterval(m_NTPSyncInterval * 60);
setSyncProvider(&::NTPSync);
}
bool EtherPort::_processEvent( Event e )
{
bool ret;
switch (e) {
case POWERUP:
case INITIALIZE:
if (!automotive_profile) {
if ( getPortState() != PTP_SLAVE &&
getPortState() != PTP_MASTER )
{
GPTP_LOG_STATUS("Starting PDelay");
startPDelay();
}
}
else {
startPDelay();
}
port_ready_condition->wait_prelock();
if( !linkWatch(watchNetLinkWrapper, (void *)this) )
{
GPTP_LOG_ERROR("Error creating port link thread");
ret = false;
break;
}
if( !linkOpen(openPortWrapper, (void *)this) )
{
GPTP_LOG_ERROR("Error creating port thread");
ret = false;
break;
}
port_ready_condition->wait();
if (automotive_profile) {
setStationState(STATION_STATE_ETHERNET_READY);
if (getTestMode())
{
APMessageTestStatus *testStatusMsg = new APMessageTestStatus(this);
if (testStatusMsg) {
testStatusMsg->sendPort(this);
delete testStatusMsg;
}
}
if (!isGM) {
// Send an initial signalling message
PTPMessageSignalling *sigMsg = new PTPMessageSignalling(this);
if (sigMsg) {
sigMsg->setintervals(PTPMessageSignalling::sigMsgInterval_NoSend, getSyncInterval(), PTPMessageSignalling::sigMsgInterval_NoSend);
sigMsg->sendPort(this, NULL);
delete sigMsg;
}
startSyncReceiptTimer((unsigned long long)
(SYNC_RECEIPT_TIMEOUT_MULTIPLIER *
((double) pow((double)2, getSyncInterval()) *
1000000000.0)));
}
}
ret = true;
break;
case STATE_CHANGE_EVENT:
// If the automotive profile is enabled, handle the event by
// doing nothing and returning true, preventing the default
// action from executing
if( automotive_profile )
ret = true;
else
ret = false;
break;
case LINKUP:
haltPdelay(false);
startPDelay();
if (automotive_profile) {
GPTP_LOG_EXCEPTION("LINKUP");
}
else {
GPTP_LOG_STATUS("LINKUP");
}
if( clock->getPriority1() == 255 || getPortState() == PTP_SLAVE ) {
becomeSlave( true );
} else if( getPortState() == PTP_MASTER ) {
becomeMaster( true );
} else {
startAnnounce();
}
if (automotive_profile) {
setAsCapable( true );
setStationState(STATION_STATE_ETHERNET_READY);
if (getTestMode())
{
APMessageTestStatus *testStatusMsg = new APMessageTestStatus(this);
if (testStatusMsg) {
testStatusMsg->sendPort(this);
delete testStatusMsg;
}
}
resetInitSyncInterval();
setAnnounceInterval( 0 );
log_min_mean_pdelay_req_interval = initialLogPdelayReqInterval;
if (!isGM) {
// Send an initial signaling message
PTPMessageSignalling *sigMsg = new PTPMessageSignalling(this);
if (sigMsg) {
sigMsg->setintervals(PTPMessageSignalling::sigMsgInterval_NoSend, getSyncInterval(), PTPMessageSignalling::sigMsgInterval_NoSend);
sigMsg->sendPort(this, NULL);
delete sigMsg;
}
startSyncReceiptTimer((unsigned long long)
(SYNC_RECEIPT_TIMEOUT_MULTIPLIER *
((double) pow((double)2, getSyncInterval()) *
1000000000.0)));
}
// Reset Sync count and pdelay count
setPdelayCount(0);
setSyncCount(0);
// Start AVB SYNC at 2. It will decrement after each sync. When it reaches 0 the Test Status message
// can be sent
if (isGM) {
avbSyncState = 1;
}
else {
avbSyncState = 2;
}
if (getTestMode())
{
linkUpCount++;
}
}
this->timestamper_reset();
ret = true;
break;
case LINKDOWN:
stopPDelay();
if (automotive_profile) {
GPTP_LOG_EXCEPTION("LINK DOWN");
}
else {
setAsCapable(false);
GPTP_LOG_STATUS("LINK DOWN");
}
if (getTestMode())
{
linkDownCount++;
}
ret = true;
break;
case ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES:
case SYNC_RECEIPT_TIMEOUT_EXPIRES:
if( !automotive_profile )
{
ret = false;
break;
}
// Automotive Profile specific action
if (e == SYNC_RECEIPT_TIMEOUT_EXPIRES) {
GPTP_LOG_EXCEPTION("SYNC receipt timeout");
startSyncReceiptTimer((unsigned long long)
(SYNC_RECEIPT_TIMEOUT_MULTIPLIER *
((double) pow((double)2, getSyncInterval()) *
1000000000.0)));
}
ret = true;
break;
case PDELAY_INTERVAL_TIMEOUT_EXPIRES:
GPTP_LOG_DEBUG("PDELAY_INTERVAL_TIMEOUT_EXPIRES occured");
{
Timestamp req_timestamp;
PTPMessagePathDelayReq *pdelay_req =
new PTPMessagePathDelayReq(this);
PortIdentity dest_id;
getPortIdentity(dest_id);
pdelay_req->setPortIdentity(&dest_id);
{
Timestamp pending =
PDELAY_PENDING_TIMESTAMP;
pdelay_req->setTimestamp(pending);
}
if (last_pdelay_req != NULL) {
delete last_pdelay_req;
}
setLastPDelayReq(pdelay_req);
getTxLock();
pdelay_req->sendPort(this, NULL);
GPTP_LOG_DEBUG("*** Sent PDelay Request message");
putTxLock();
{
long long timeout;
long long interval;
timeout = PDELAY_RESP_RECEIPT_TIMEOUT_MULTIPLIER *
((long long)
(pow((double)2,getPDelayInterval())*1000000000.0));
timeout = timeout > EVENT_TIMER_GRANULARITY ?
timeout : EVENT_TIMER_GRANULARITY;
clock->addEventTimerLocked
(this, PDELAY_RESP_RECEIPT_TIMEOUT_EXPIRES, timeout );
GPTP_LOG_DEBUG("Schedule PDELAY_RESP_RECEIPT_TIMEOUT_EXPIRES, "
"PDelay interval %d, timeout %lld",
getPDelayInterval(), timeout);
interval =
((long long)
(pow((double)2,getPDelayInterval())*1000000000.0));
interval = interval > EVENT_TIMER_GRANULARITY ?
interval : EVENT_TIMER_GRANULARITY;
startPDelayIntervalTimer(interval);
}
}
break;
case SYNC_INTERVAL_TIMEOUT_EXPIRES:
{
/* Set offset from master to zero, update device vs
system time offset */
// Send a sync message and then a followup to broadcast
PTPMessageSync *sync = new PTPMessageSync(this);
PortIdentity dest_id;
bool tx_succeed;
getPortIdentity(dest_id);
sync->setPortIdentity(&dest_id);
getTxLock();
tx_succeed = sync->sendPort(this, NULL);
GPTP_LOG_DEBUG("Sent SYNC message");
if ( automotive_profile &&
getPortState() == PTP_MASTER )
{
if (avbSyncState > 0) {
avbSyncState--;
if (avbSyncState == 0) {
// Send Avnu Automotive Profile status message
setStationState(STATION_STATE_AVB_SYNC);
if (getTestMode()) {
APMessageTestStatus *testStatusMsg = new APMessageTestStatus(this);
if (testStatusMsg) {
testStatusMsg->sendPort(this);
delete testStatusMsg;
}
}
}
}
}
putTxLock();
if ( tx_succeed )
{
Timestamp sync_timestamp = sync->getTimestamp();
GPTP_LOG_VERBOSE("Successful Sync timestamp");
GPTP_LOG_VERBOSE("Seconds: %u",
sync_timestamp.seconds_ls);
GPTP_LOG_VERBOSE("Nanoseconds: %u",
sync_timestamp.nanoseconds);
PTPMessageFollowUp *follow_up = new PTPMessageFollowUp(this);
PortIdentity dest_id;
getPortIdentity(dest_id);
follow_up->setClockSourceTime(getClock()->getFUPInfo());
follow_up->setPortIdentity(&dest_id);
follow_up->setSequenceId(sync->getSequenceId());
follow_up->setPreciseOriginTimestamp
(sync_timestamp);
follow_up->sendPort(this, NULL);
delete follow_up;
} else {
GPTP_LOG_ERROR
("*** Unsuccessful Sync timestamp");
}
delete sync;
}
break;
case FAULT_DETECTED:
GPTP_LOG_ERROR("Received FAULT_DETECTED event");
if (!automotive_profile) {
setAsCapable(false);
}
break;
case PDELAY_DEFERRED_PROCESSING:
GPTP_LOG_DEBUG("PDELAY_DEFERRED_PROCESSING occured");
pdelay_rx_lock->lock();
if (last_pdelay_resp_fwup == NULL) {
GPTP_LOG_ERROR("PDelay Response Followup is NULL!");
abort();
}
last_pdelay_resp_fwup->processMessage(this);
if (last_pdelay_resp_fwup->garbage()) {
delete last_pdelay_resp_fwup;
this->setLastPDelayRespFollowUp(NULL);
}
pdelay_rx_lock->unlock();
break;
case PDELAY_RESP_RECEIPT_TIMEOUT_EXPIRES:
if (!automotive_profile) {
GPTP_LOG_EXCEPTION("PDelay Response Receipt Timeout");
setAsCapable(false);
}
setPdelayCount( 0 );
break;
case PDELAY_RESP_PEER_MISBEHAVING_TIMEOUT_EXPIRES:
GPTP_LOG_EXCEPTION("PDelay Resp Peer Misbehaving timeout expired! Restarting PDelay");
haltPdelay(false);
if( getPortState() != PTP_SLAVE &&
getPortState() != PTP_MASTER )
{
GPTP_LOG_STATUS("Starting PDelay" );
startPDelay();
}
break;
case SYNC_RATE_INTERVAL_TIMEOUT_EXPIRED:
{
GPTP_LOG_INFO("SYNC_RATE_INTERVAL_TIMEOUT_EXPIRED occured");
sync_rate_interval_timer_started = false;
bool sendSignalMessage = false;
if ( getSyncInterval() != operLogSyncInterval )
{
setSyncInterval( operLogSyncInterval );
sendSignalMessage = true;
}
if (log_min_mean_pdelay_req_interval != operLogPdelayReqInterval) {
log_min_mean_pdelay_req_interval = operLogPdelayReqInterval;
sendSignalMessage = true;
}
if (sendSignalMessage) {
if (!isGM) {
// Send operational signalling message
PTPMessageSignalling *sigMsg = new PTPMessageSignalling(this);
if (sigMsg) {
if (automotive_profile)
sigMsg->setintervals(PTPMessageSignalling::sigMsgInterval_NoChange, getSyncInterval(), PTPMessageSignalling::sigMsgInterval_NoChange);
else
sigMsg->setintervals(log_min_mean_pdelay_req_interval, getSyncInterval(), PTPMessageSignalling::sigMsgInterval_NoChange);
sigMsg->sendPort(this, NULL);
delete sigMsg;
}
startSyncReceiptTimer((unsigned long long)
(SYNC_RECEIPT_TIMEOUT_MULTIPLIER *
((double) pow((double)2, getSyncInterval()) *
1000000000.0)));
}
}
}
break;
default:
GPTP_LOG_ERROR
( "Unhandled event type in "
"EtherPort::processEvent(), %d", e );
ret = false;
break;
}
return ret;
}