flexPTP

https://epagris.github.io/flexPTP/
Admin
flexPTP is an IEEE 1588 PTP implementation designed for accurate time synchronization on...
Tokens:229,858
Snippets:2,802
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Network Stack Driver: LWIP Example

Source: https://epagris.github.io/flexPTP/dir_63787e4854c15d02efa38abd18cd4625.html

Example implementation of a network stack driver using LWIP.

```c
file | nsd_lwip.c [code]
```

--------------------------------

### Network Stack Driver: Linux Example

Source: https://epagris.github.io/flexPTP/dir_63787e4854c15d02efa38abd18cd4625.html

Example implementation of a network stack driver for Linux.

```c
file | nsd_linux.c [code]
```

```c
file | nsd_linux.h [code]
```

--------------------------------

### Network Stack Driver: Etherlib Example

Source: https://epagris.github.io/flexPTP/dir_63787e4854c15d02efa38abd18cd4625.html

Example implementation of a network stack driver using Etherlib.

```c
file | nsd_etherlib.c [code]
```

--------------------------------

### PTP Master Clock Mode Example

Source: https://epagris.github.io/flexPTP/monitoring.html

Example output showing slave recognition states and Mean Path Delay values in PTP master mode.

```text
1750245425 776292333 1750245425 331768083 0 -27 -4 4260879975 57.835724 3414 1000057519
1750245426 776299212 1750245426 456768081 0 3 0 4260879881 -22.133024 3395 1000006879
1750245427 776371852 1750245427 581767839 0 45 7 4260879708 -40.697857 3381 1000072640
1750245428 776412971 1750245428 706767677 0 -19 -3 4260879921 50.216988 3380 1000041119
1750245429 776659935 1750245428 706767677 0 21 3 4260879779 -33.560795 3380 1000246964
1750245430 776686174 1750245429 831767675 0 -16 -2 4260879907 30.222692 3412 1000026239
1750245431 776744493 1750245430 956767513 0 8 1 4260879826 -19.040367 3385 1000058319
1750245432 776754491 1750245432 081767431 0 14 2 4260879794 -7.616276 3391 1000009998
1750245433 776922094 1750245433 206767028 0 39 6 4260879679 -27.130424 3369 1000167603
1750245434 776946172 1750245434 331767266 0 -92 -15 4260880170 115.426010 3436 1000024078
1750245435 776998572 1750245435 456767104 0 75 12 4260879586 -137.089859 3359 1000052400
1750245436 777026330 1750245436 581767582 0 -32 -5 4260879943 84.012680 3412 1000027758
1750245437 777052969 1750245437 706766780 0 69 11 4260879566 -88.535973 3338 1000026639
```

--------------------------------

### Example FlexPTP Transmission Logs

Source: https://epagris.github.io/flexPTP/monitoring.html

Illustrates the concrete output of the transmission logging formats.

```text
[ 89] 15 (0) --->
```

```text
[ 89]---> 15
```

```text
[ 89] 15 AUTOFREE
```

```text
[ 89] 16 (0) --->
```

```text
[ 89]---> 16
```

```text
[ 89] 16 AUTOFREE
```

--------------------------------

### linux_nsd_preinit()

Source: https://epagris.github.io/flexPTP/nsd__linux_8h.html

Preinitializes the Linux network stack driver. This function prepares the driver for operation by performing necessary setup tasks.

```APIDOC
## linux_nsd_preinit()

### Description
Preinitialize the Linux network stack driver.

### Signature
bool linux_nsd_preinit(const char * _ifn_)

### Parameters
#### Path Parameters
- **_ifn_** (const char *) - The name of the targeted network interface (e.g. eth0).

### Returns
- initialization successful (bool)

### Definition
File: nsd_linux.c, Line: 76
```

--------------------------------

### Example Options Header Files

Source: https://epagris.github.io/flexPTP/dir_8c44ce90b2f8de88e9f4fdb12f83dadf.html

These header files define configuration options for flexPTP on various microcontroller platforms. They are essential for porting and customizing the library.

```c
#ifndef FLEXPTP_OPTIONS_CH32F207_ETHERLIB_H
#define FLEXPTP_OPTIONS_CH32F207_ETHERLIB_H

#include "flexptp_options_common.h"

// CH32F207 with Etherlib

#endif /* FLEXPTP_OPTIONS_CH32F207_ETHERLIB_H */
```

```c
#ifndef FLEXPTP_OPTIONS_MK64F_H
#define FLEXPTP_OPTIONS_MK64F_H

#include "flexptp_options_common.h"

// MK64F

#endif /* FLEXPTP_OPTIONS_MK64F_H */
```

```c
#ifndef FLEXPTP_OPTIONS_STM32F407_ETHERLIB_H
#define FLEXPTP_OPTIONS_STM32F407_ETHERLIB_H

#include "flexptp_options_common.h"

// STM32F407 with Etherlib

#endif /* FLEXPTP_OPTIONS_STM32F407_ETHERLIB_H */
```

```c
#ifndef FLEXPTP_OPTIONS_STM32H743_H
#define FLEXPTP_OPTIONS_STM32H743_H

#include "flexptp_options_common.h"

// STM32H743

#endif /* FLEXPTP_OPTIONS_STM32H743_H */
```

```c
#ifndef FLEXPTP_OPTIONS_STM32H743_ETHERLIB_H
#define FLEXPTP_OPTIONS_STM32H743_ETHERLIB_H

#include "flexptp_options_common.h"

// STM32H743 with Etherlib

#endif /* FLEXPTP_OPTIONS_STM32H743_ETHERLIB_H */
```

```c
#ifndef FLEXPTP_OPTIONS_TM4C1294_H
#define FLEXPTP_OPTIONS_TM4C1294_H

#include "flexptp_options_common.h"

// TM4C1294

#endif /* FLEXPTP_OPTIONS_TM4C1294_H */
```

--------------------------------

### Correction Fields Logging Example

Source: https://epagris.github.io/flexPTP/monitoring.html

Example of correction fields logged for PTP messages.

```text
C [Follow_Up]: 000238277
```

--------------------------------

### Example CLI Commands for flexPTP

Source: https://epagris.github.io/flexPTP/cli.html

Lists common flexPTP CLI commands for managing PTP settings and state. These commands allow for resetting, setting offsets, controlling logging, managing master clocks, and configuring PTP domains, addends, tuning, transport, delay mechanisms, profiles, TLVs, flags, periods, priorities, and coarse correction thresholds.

```bash
ptp reset
```

```bash
ptp servo offset [offset_ns]
```

```bash
ptp log {def|corr|ts|info|locked|bmca} {on|off}
```

```bash
ptp master [[un]prefer] [clockid]
```

```bash
ptp info
```

```bash
ptp domain [domain]
```

```bash
ptp addend [addend]
```

```bash
ptp tuning [tuning]
```

```bash
ptp transport [{ipv4|802.3}]
```

```bash
ptp delmech [{e2e|p2p}]
```

```bash
ptp transpec [{def|gPTP}]
```

```bash
ptp profile [preset [<name>]]
```

```bash
ptp tlv [preset [name]|unload]
```

```bash
ptp pflags [<flags>]
```

```bash
ptp period <delreq|sync|ann> [<lp>|matched]
```

```bash
ptp priority [<p1> <p2>]
```

```bash
ptp coarse [threshold]
```

```bash
time [ns]
```

--------------------------------

### Info Notification Example

Source: https://epagris.github.io/flexPTP/monitoring.html

Example notification for significant time difference requiring coarse correction.

```text
Time difference has exceeded the coarse correction threshold [-1652684253ns], executing coarse correction!
```

--------------------------------

### Example FlexPTP CMake Configuration

Source: https://epagris.github.io/flexPTP/building.html

Sets FlexPTP to use the bundled STM32F407 hardware port with lwIP bindings, the bundled lwIP network stack driver, and the bundled PID controller as the clock servo.

```cmake
set(FLEXPTP_HWPORT "F407_LWIP")
set(FLEXPTP_NSD "LWIP")
set(FLEXPTP_SERVO "PID")
```

--------------------------------

### Start Heartbeat Timer

Source: https://epagris.github.io/flexPTP/task__ptp_8c_source.html

Starts the heartbeat timer. The timer is configured to run periodically based on PTP_HEARTBEAT_TICKRATE_MS. This function is platform-specific.

```c
void ptp_start_heartbeat_tmr() {
#ifdef FLEXPTP_FREERTOS
 xTimerStart(sHeartBeatTmr, 0);
#elif defined(FLEXPTP_CMSIS_OS2)
 osTimerStart(sHeartBeatTmr, (PTP_HEARTBEAT_TICKRATE_MS * 1000) / osKernelGetTickFreq());
#elif defined(FLEXPTP_LINUX)
 struct itimerspec its = {
 .it_interval = {
 .tv_sec = PTP_HEARTBEAT_TICKRATE_MS / 1000, .tv_nsec = (PTP_HEARTBEAT_TICKRATE_MS % 1000) * 1000000},
 .it_value = {.tv_sec = 1, .tv_nsec = 0} // just some non-zero value
 };
 timer_settime(sHeartBeatTmr, 0, &its, NULL);
#endif
}
```

--------------------------------

### Start PTP Heartbeat Timer

Source: https://epagris.github.io/flexPTP/task__ptp_8h_source.html

Starts the heartbeat timer for the PTP task. This function should be called to initiate periodic PTP task activities.

```c
void ptp_start_heartbeat_tmr();
```

--------------------------------

### Register PTP Task and Initialize

Source: https://epagris.github.io/flexPTP/task__ptp_8c_source.html

Registers the PTP task by initializing message queues, creating a heartbeat timer, initializing the PTP subsystem and network stack driver, and finally creating the PTP task itself. Includes conditional loading of configuration and setting a user event callback.

```c
// register PTP task and initialize
bool reg_task_ptp() {
 // initialize message queues and buffers
 if (!ptp_create_message_queues()) {
 ptp_destroy_message_queues();
 return false;
 }

 // set user event callback
#ifdef PTP_USER_EVENT_CALLBACK
 ptp_set_user_event_callback(PTP_USER_EVENT_CALLBACK);
#endif

 // create heartbeat timer
 if (!ptp_create_heartbeat_tmr()) {
 ptp_destroy_message_queues();
 return false;
 }

 // initialize PTP subsystem
 ptp_init();

 // load config if provided
#ifdef PTP_CONFIG_PTR
 MSG("Loading the PTP-configuration!\n");
 ptp_load_config_from_dump(PTP_CONFIG_PTR());

 // print profile summary
 MSG("\n\n----\n");
 ptp_print_profile();
 MSG("----\n\n");
#endif

 // initialize network stack driver
 ptp_nsd_init(ptp_get_transport_type(), ptp_get_delay_mechanism());

 // create task
#ifdef FLEXPTP_FREERTOS
 sTH = NULL;
 BaseType_t result = xTaskCreate(task_ptp, "ptp", FLEXPTP_TASK_STACK_SIZE / sizeof(BaseType_t), NULL, FLEXPTP_TASK_PRIORITY, &sTH);
 if (result != pdPASS) {
 MSG("Failed to create the PTP task! (errcode: %d)\n", result);
 unreg_task_ptp(); // this will also destroy message queues and the timer

```

--------------------------------

### Initialize Ethernet Interface

Source: https://epagris.github.io/flexPTP/_h743_ethernetif_modifications.html

Configures the Ethernet peripheral, MAC address, and network interface properties. Sets up DMA descriptors and initializes the RX buffer pool. Creates a task for handling Ethernet input.

```c
static void low_level_init(struct netif *netif)
{
uint32_t idx, duplex, speed = 0;
int32_t PHYLinkState;
ETH_MACConfigTypeDef MACConf;
uint8_t macaddress[6]= {ETH_MAC_ADDR0, ETH_MAC_ADDR1, ETH_MAC_ADDR2, ETH_MAC_ADDR3, ETH_MAC_ADDR4, ETH_MAC_ADDR5};
EthHandle.Instance = ETH; 
EthHandle.Init.MACAddr = macaddress;
EthHandle.Init.MediaInterface = HAL_ETH_RMII_MODE;
EthHandle.Init.RxDesc = DMARxDscrTab;
EthHandle.Init.TxDesc = DMATxDscrTab;
EthHandle.Init.RxBuffLen = ETH_RX_BUFFER_SIZE;
/* configure ethernet peripheral (GPIOs, clocks, MAC, DMA) */
HAL_ETH_Init(&EthHandle);
/* set MAC hardware address length */
netif->hwaddr_len = ETH_HWADDR_LEN;
/* set MAC hardware address */
netif->hwaddr[0] = ETH_MAC_ADDR0;
netif->hwaddr[1] = ETH_MAC_ADDR1;
netif->hwaddr[2] = ETH_MAC_ADDR2;
netif->hwaddr[3] = ETH_MAC_ADDR3;
netif->hwaddr[4] = ETH_MAC_ADDR4;
netif->hwaddr[5] = ETH_MAC_ADDR5;
/* maximum transfer unit */
netif->mtu = ETH_MAX_PAYLOAD;
/* device capabilities */
/* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;
for(idx = 0; idx < ETH_RX_DESC_CNT; idx ++)
{
HAL_ETH_DescAssignMemory(&EthHandle, idx, Rx_Buff[idx], NULL);
}
/* Initialize the RX POOL */
LWIP_MEMPOOL_INIT(RX_POOL);
memset(&TxConfig, 0 , sizeof(ETH_TxPacketConfig)); 
TxConfig.Attributes = ETH_TX_PACKETS_FEATURES_CSUM | ETH_TX_PACKETS_FEATURES_CRCPAD;
TxConfig.ChecksumCtrl = ETH_CHECKSUM_IPHDR_PAYLOAD_INSERT_PHDR_CALC;
TxConfig.CRCPadCtrl = ETH_CRC_PAD_INSERT;
/* create a binary semaphore used for informing ethernetif of frame reception */
RxPktSemaphore = xSemaphoreCreateBinary();
/* create the task that handles the ETH_MAC */
osThreadDef(EthIf, ethernetif_input, osPriorityRealtime, 0, INTERFACE_THREAD_STACK_SIZE);
osThreadCreate (osThread(EthIf), netif);
/* Set PHY IO functions */
LAN8742_RegisterBusIO(&LAN8742, &LAN8742_IOCtx);
/* Initialize the LAN8742 ETH PHY */
LAN8742_Init(&LAN8742);
PHYLinkState = LAN8742_GetLinkState(&LAN8742);
/* Get link state */
if(PHYLinkState <= LAN8742_STATUS_LINK_DOWN)
{
netif_set_link_down(netif);
netif_set_down(netif);
}
else
{
switch (PHYLinkState)
{
case LAN8742_STATUS_100MBITS_FULLDUPLEX:
duplex = ETH_FULLDUPLEX_MODE;
speed = ETH_SPEED_100M;
break;
case LAN8742_STATUS_100MBITS_HALFDUPLEX:
duplex = ETH_HALFDUPLEX_MODE;
speed = ETH_SPEED_100M;
break;
case LAN8742_STATUS_10MBITS_FULLDUPLEX:
duplex = ETH_FULLDUPLEX_MODE;
speed = ETH_SPEED_10M;
break;
case LAN8742_STATUS_10MBITS_HALFDUPLEX:
duplex = ETH_HALFDUPLEX_MODE;
speed = ETH_SPEED_10M;
break;
default:
duplex = ETH_FULLDUPLEX_MODE;
speed = ETH_SPEED_100M;
break; 
}
/* Get MAC Config MAC */
HAL_ETH_GetMACConfig(&EthHandle, &MACConf); 
MACConf.DuplexMode = duplex;
MACConf.Speed = speed;
HAL_ETH_SetMACConfig(&EthHandle, &MACConf);
HAL_ETH_Start_IT(&EthHandle);
netif_set_up(netif);
netif_set_link_up(netif);
}
}
```

--------------------------------

### Get PTP Hardware Time

Source: https://epagris.github.io/flexPTP/ptp__port__stm32f407__etherlib_8h.html

Retrieves the current PTP time from the hardware. This function is used to get the precise time maintained by the PTP hardware.

```APIDOC
## ptphw_gettime

### Description
Retrieves the current PTP time from the hardware.

### Parameters
* **pTime** (TimestampU *) - Required - Pointer to a TimestampU structure where the current time will be stored.

### Returns
None
```

--------------------------------

### Initialize Network Stack Driver (Etherlib)

Source: https://epagris.github.io/flexPTP/nsd__etherlib_8c_source.html

Initializes the network stack driver using Etherlib components. Sets up connection blocks and stores transport and delay mechanism settings.

```c
#include "../../network_stack_driver.h"

#include "../../ptp_defs.h"
#include "../../ptp_types.h"
#include "../../task_ptp.h"

#include "etherlib/cbd_table.h"
#include "etherlib/connection_block.h"
#include "etherlib/eth_interface.h"
#include "etherlib/global_state.h"
#include "etherlib/prefab/conn_blocks/custom_ethertype_connblock.h"
#include "etherlib/prefab/conn_blocks/igmp_connblock.h"
#include "etherlib/prefab/packet_parsers/ethernet_frame.h"
#include "etherlib/prefab/packet_parsers/ipv4_types.h"
#include "etherlib/timestamping.h"

#include <stdbool.h>
#include <string.h>

// initialize connection blocks to invalid states
static cbd PTP_L4_EVENT = 0;
static cbd PTP_L4_GENERAL = 0;
static cbd PTP_L2 = 0;

// store current settings
static PtpTransportType TP = -1;
static PtpDelayMechanism DM = -1;

```

--------------------------------

### Include Headers for STM32F407 Etherlib Configuration

Source: https://epagris.github.io/flexPTP/flexptp__options__stm32f407__etherlib_8h.html

Includes necessary headers for Etherlib, standard output, CLI utilities, MAC driver, standard library, and PID controller for PTP configuration on STM32F407.

```c
#include <etherlib/etherlib.h>
#include "standard_output/standard_output.h"
#include "cliutils/cli.h"
#include "Drivers/EthDrv/mac_drv.h"
#include <stdlib.h>
#include <flexptp/servo/pid_controller.h>
```

--------------------------------

### Get PTP Hardware Time

Source: https://epagris.github.io/flexPTP/ptp__port__stm32h743__etherlib_8h_source.html

Retrieves the current PTP time from the hardware port. This function is used to get the timestamp for PTP events on the STM32H743 with Etherlib.

```c
void ptphw_gettime(TimestampU * pTime);

#ifdef __cplusplus
}
#endif

```

--------------------------------

### Network to Host Byte Order Conversions (C)

Source: https://epagris.github.io/flexPTP/ptp__defs_8h_source.html

Macros for converting between network byte order and host byte order for 32-bit and 16-bit integers. These are statically computable.

```c
#define FLEXPTP_htonl(a) \
 ((((a) >> 24) & 0x000000ff) | \
 (((a) >> 8) & 0x0000ff00) | \
 (((a) << 8) & 0x00ff0000) | \
 (((a) << 24) & 0xff000000))
```

```c
#define FLEXPTP_ntohl(a) FLEXPTP_htonl((a))
```

```c
#define FLEXPTP_htons(a) \
 ((((a) >> 8) & 0x00ff) | \
 (((a) << 8) & 0xff00))
```

```c
#define FLEXPTP_ntohs(a) FLEXPTP_htons((a))
```

--------------------------------

### Get PTP Hardware Timestamp

Source: https://epagris.github.io/flexPTP/ptp__port__stm32f407__lwip_8c.html

Retrieves the current PTP hardware timestamp. This function is used to get time from the PTP hardware clock on the STM32F407 with LWIP.

```c
void ptphw_gettime (TimestampU *pTime)
```

--------------------------------

### Example Class Definitions for Graph Generation

Source: https://epagris.github.io/flexPTP/graph_legend.html

These C++ class definitions are used to illustrate how Doxygen generates inheritance and relationship graphs. They include examples of documented, undocumented, inherited, and templated classes.

```cpp
/*! Invisible class because of truncation */
class Invisible { };
/*! Truncated class, inheritance relation is hidden */
class Truncated : public Invisible { };
/* Class not documented with doxygen comments */
class Undocumented { };
/*! Class that is inherited using public inheritance */
class PublicBase : public Truncated { };
/*! A template class */
template<class T> class Templ { };
/*! Class that is inherited using protected inheritance */
class ProtectedBase { };
/*! Class that is inherited using private inheritance */
class PrivateBase { };
/*! Class that is used by the Inherited class */
class Used { };
/*! Super class that inherits a number of other classes */
class Inherited : public PublicBase,
protected ProtectedBase,
private PrivateBase,
public Undocumented,
public Templ<int>
{
private:
Used *m_usedClass;
};
```

--------------------------------

### Initialize PTP Hardware and PPS

Source: https://epagris.github.io/flexPTP/ptp__port__stm32f407__etherlib_8c_source.html

Initializes the PTP hardware, enables timestamping, sets time, fine correction, addend, and sub-second increment. Also configures the PPS output pin and registers CLI commands.

```c
void ptphw_init(uint32_t increment, uint32_t addend) {
90 //MSG("Turning PTP on!");
91
92 // enable PTP timestamping
93 ETHHW_EnablePTPTimeStamping(ETH);
94
95 osDelay(10);
96
97 //ETH_EnablePTPTimeStamping(&EthHandle);
98
99 // initialize PTP time
100 ETHHW_InitPTPTime(ETH, 0, 0);
101
102 // enable fine correction
103 ETHHW_EnablePTPFineCorr(ETH, true);
104
105 // set addend register value
106 ETHHW_SetPTPAddend(ETH, addend);
107
108 // set increment register value
109 ETHHW_SetPTPSubsecondIncrement(ETH, increment);
110
111 //ETH_StartPTPPPSPulseTrain(&EthHandle, 500E+06, 1E+09);
112 ETHHW_SetPTPPPSFreq(ETH, ETHHW_PTP_PPS_1Hz);
113 sFreq = 1;
114
115 __HAL_RCC_GPIOG_CLK_ENABLE();
116
117 // setup PPS-pin
118 GPIO_InitTypeDef GPIO_InitStructure;
119 GPIO_InitStructure.Pin = GPIO_PIN_8;
120 GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
121 GPIO_InitStructure.Alternate = GPIO_AF11_ETH;
122 GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
123 GPIO_InitStructure.Pull = GPIO_NOPULL;
124 HAL_GPIO_Init(GPIOG, &GPIO_InitStructure);
125
126#ifdef CLI_REG_CMD
127 // register cli commands
128 ptphw_register_cli_commands();
129#endif // CLI_REG_CMD
130}
```

--------------------------------

### Get PTP Profile Preset Name by Index

Source: https://epagris.github.io/flexPTP/ptp__profile__presets_8h_source.html

Retrieves the name of a PTP profile preset using its index. This allows users to get the identifier string for a preset based on its position in the list.

```APIDOC
## ptp_profile_preset_get_name

### Description
Retrieves the name of a PTP profile preset using its index.

### Prototype
const char * ptp_profile_preset_get_name(size_t i);

### Parameters
* **i** (size_t) - The index of the PTP profile preset.
```

--------------------------------

### PTP Hardware Initialization Macro

Source: https://epagris.github.io/flexPTP/flexptp__options__mk64f_8h.html

Macro to initialize the PTP hardware, using the default network interface.

```c
#define PTP_HW_INIT() ethernetif_ptp_init(PTP_CONFIG_LEADING_PARAMS)
```

--------------------------------

### Start PTP PPS Pulse Train

Source: https://epagris.github.io/flexPTP/ptp__port__stm32f407__lwip_8c_source.html

Starts the PTP PPS (Pulse Per Second) signal generation with specified high pulse duration and period. Includes a warning if the frequency is not an integer divisor of 1E+09.

```c
// parse frequency [Hz] (integer only!)
46 uint32_t freq_Hz = atoi(ppArgs[0]);
47
48 if (freq_Hz == 0) {
49 // stop pulse train generation
50 ETH_StopPTPPPSPulseTrain(&EthHandle);
51 } else {
52 // compute period [ns]
53 uint32_t period_ns = NANO_PREFIX / freq_Hz;
54
55 // display warning if frequency is not integer divisor of 1E+09
56 if ((NANO_PREFIX % freq_Hz) != 0) {
57 MSG("Warning! PPS frequency is not totally accurate, "
58 "choose frequency values corresponding to periods "
59 "being integer divisors of 1E+09!\n");
60 }
61
62 // set duty cycle (try 50%) by specifying positive pulse length
63 uint32_t high_ns = period_ns / 2;
64
65 // start pulse train generation
66 ETH_StartPTPPPSPulseTrain(&EthHandle, high_ns, period_ns);
67 }
```

--------------------------------

### nsd_lwip.c Header Includes

Source: https://epagris.github.io/flexPTP/nsd__lwip_8c_source.html

Includes necessary headers for network stack drivers, PTP definitions, task management, LWIP core functions, and string manipulation.

```c
#include "../../network_stack_driver.h"
#include "../../ptp_defs.h"
#include "../../task_ptp.h"

#include "lwip/err.h"
#include "lwip/igmp.h"
#include "lwip/ip4_addr.h"
#include "lwip/ip_addr.h"
#include "lwip/netif.h"
#include "lwip/udp.h"
#include "netif/ethernet.h"

#include <string.h>
```

--------------------------------

### ptp_start_heartbeat_tmr

Source: https://epagris.github.io/flexPTP/task__ptp_8h.html

Starts the heartbeat timer for the PTP task.

```APIDOC
## ptp_start_heartbeat_tmr()

### Description
Starts the heartbeat timer for the PTP task.

### Function Signature
`void ptp_start_heartbeat_tmr()`
```

--------------------------------

### Initialize PTP Hardware

Source: https://epagris.github.io/flexPTP/ptp__port__stm32h743__etherlib_8c_source.html

Initializes the PTP hardware, enabling timestamping, setting time, fine correction, and configuring GPIO for the PPS pin.

```c
void ptphw_init(uint32_t increment, uint32_t addend) {
MSG("Turning PTP on!");

// enable PTP timestamping
ETHHW_EnablePTPTimeStamping(ETH);

vTaskDelay(pdMS_TO_TICKS(10));

// initialize PTP time
ETHHW_InitPTPTime(ETH, 0, 0);

// enable fine correction
ETHHW_EnablePTPFineCorr(ETH, true);

// set addend register value
ETHHW_SetPTPAddend(ETH, addend);

// set increment register value
ETHHW_SetPTPSubsecondIncrement(ETH, increment);

// ETH_StartPTPPPSPulseTrain(&EthHandle, 500E+06, 1E+09);
ptphw_set_pps_freq(1.0);

__HAL_RCC_GPIOG_CLK_ENABLE();

// setup PPS-pin
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.Pin = GPIO_PIN_8;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Alternate = GPIO_AF11_ETH;
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
GPIO_InitStructure.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOG, &GPIO_InitStructure);

#ifdef CLI_REG_CMD
// register cli commands
ptphw_register_cli_commands();
#endif // CLI_REG_CMD
}
```

--------------------------------

### Addend Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Functions to set and get the addend value.

```APIDOC
## ptp_set_addend

### Description
Sets the addend value.

### Method
`void ptp_set_addend(uint32_t addend)`

### Parameters
- **addend** (uint32_t) - The addend value.

## ptp_get_addend

### Description
Retrieves the current addend value.

### Method
`uint32_t ptp_get_addend()`

### Returns
- The current addend value.
```

--------------------------------

### Domain Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Functions to set and get the PTP domain.

```APIDOC
## ptp_set_domain

### Description
Sets the PTP domain.

### Method
`void ptp_set_domain(uint8_t domain)`

### Parameters
- **domain** (uint8_t) - The PTP domain number.

## ptp_get_domain

### Description
Retrieves the current PTP domain.

### Method
`uint8_t ptp_get_domain()`

### Returns
- The current PTP domain number.
```

--------------------------------

### Get PTP Time

Source: https://epagris.github.io/flexPTP/ptp__port__stm32f407__etherlib_8c.html

Retrieves the current PTP time from the hardware.

```APIDOC
## ptphw_gettime

### Description
Retrieves the current PTP time from the hardware timer and stores it in the provided TimestampU structure.

### Parameters
- **pTime** (TimestampU *) - Pointer to a TimestampU structure where the current PTP time will be stored.

### Returns
void
```

--------------------------------

### Standard Library and FreeRTOS Includes

Source: https://epagris.github.io/flexPTP/ptp__defs_8h.html

Includes necessary standard C libraries and FreeRTOS components for PTP operations.

```c
#include <stdint.h>
#include <flexptp_options.h>
#include "FreeRTOS.h"
#include "queue.h"
#include "task.h"
#include "timers.h"
```

--------------------------------

### FIFO Get Level

Source: https://epagris.github.io/flexPTP/fifo_8h.html

Retrieves the current number of items in the FIFO.

```APIDOC
## Functions
---

uint32_t | fifo_get_level (const Fifo *f)
```

--------------------------------

### Initialize PTP Module

Source: https://epagris.github.io/flexPTP/ptp__core_8c_source.html

Initializes the PTP module, including registering CLI commands if enabled, clearing timers, and initializing common, SBMC, slave, and master components. Dispatches an INIT_DONE event upon completion.

```c
void ptp_init(void) {
#ifdef CLI_REG_CMD
 // register cli commands
 ptp_register_cli_commands();
#endif // CLI_REG_CMD

 // clear the timer
 S.ticks = 0;

 /* ---- COMMON ----- */
 ptp_common_init();

 /* ----- SBMC ------ */
 ptp_bmca_init();

 /* ----- SLAVE ----- */
 ptp_slave_init();

 /* ---- MASTER ---
 */
 ptp_master_init();

 // ---------------------

 ptp_reset(); // reset all PTP systems

 // dispatch INIT_DONE event
 PTP_IUEV(PTP_UEV_INIT_DONE);
}
```

--------------------------------

### PTP Timestamp Logging in P2P Mode

Source: https://epagris.github.io/flexPTP/monitoring.html

Example of six timestamps logged per synchronization cycle in PTP Peer-to-Peer (P2P) mode.

```text
T1: 1750244937.371576883 <- Sync TX (master)
T2: 1750244937.371583093 <- Sync RX (slave)
t1: 1750244936.716173459 <- PDel_Req TX (our clock)
t2: 1750244936.716174083 <- PDel_Req RX (their clock)
t3: 1750244936.716270563 <- PDel_Resp TX (their clock)
t4: 1750244936.716276743 <- PDel_Resp RX (our clock)
```

--------------------------------

### PTP Domain Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8c_source.html

Functions to set and get the PTP domain number.

```APIDOC
## ptp_set_domain

### Description
Sets the PTP domain number for the system.

### Function Signature
```c
void ptp_set_domain(uint8_t domain)
```

### Parameters
* **domain** (uint8_t) - The PTP domain number.

## ptp_get_domain

### Description
Retrieves the current PTP domain number.

### Function Signature
```c
uint8_t ptp_get_domain()
```

### Returns
The current PTP domain number.
```

--------------------------------

### ptp_nsd_init

Source: https://epagris.github.io/flexPTP/nsd__linux_8c.html

Initializes or reinitializes the Network Stack Driver.

```APIDOC
## ptp_nsd_init()

### Description
Initialize or reinitialize the Network Stack Driver.

### Parameters
- **_tp_** (PtpTransportType) - PTP transport type
- **_dm_** (PtpDelayMechanism) - PTP delay mechanism

### Definition
`void ptp_nsd_init(PtpTransportType _tp_, PtpDelayMechanism _dm_);`
```

--------------------------------

### PTP_SERVO_INIT

Source: https://epagris.github.io/flexPTP/flexptp__options__stm32h743__etherlib_8h.html

Initializes the PTP servo controller.

```APIDOC
## PTP_SERVO_INIT

### Description
Initializes the PTP servo controller.

### Macro Signature
`PTP_SERVO_INIT()`
```

--------------------------------

### Delay Mechanism Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Functions to set and get the PTP delay mechanism.

```APIDOC
## ptp_set_delay_mechanism

### Description
Sets the PTP delay mechanism.

### Method
`void ptp_set_delay_mechanism(PtpDelayMechanism dm)`

### Parameters
- **dm** (PtpDelayMechanism) - The PTP delay mechanism to set.

## ptp_get_delay_mechanism

### Description
Retrieves the current PTP delay mechanism.

### Method
`PtpDelayMechanism ptp_get_delay_mechanism()`

### Returns
- The current PTP delay mechanism.
```

--------------------------------

### Clock Offset Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Functions to set and get the clock offset in nanoseconds.

```APIDOC
## ptp_set_clock_offset

### Description
Sets the clock offset in nanoseconds.

### Method
`void ptp_set_clock_offset(int32_t offset)`

### Parameters
- **offset** (int32_t) - The clock offset in nanoseconds.

## ptp_get_clock_offset

### Description
Retrieves the current clock offset in nanoseconds.

### Method
`int32_t ptp_get_clock_offset()`

### Returns
- The current clock offset in nanoseconds.
```

--------------------------------

### Ethernet Interface Initialization

Source: https://epagris.github.io/flexPTP/_h743_ethernetif_modifications.html

Initializes the Ethernet network interface. Sets up interface name, output functions, and calls low-level hardware initialization. Assumes LWIP_NETIF_HOSTNAME is enabled for hostname configuration.

```c
err_t ethernetif_init(struct netif *netif)
{
LWIP_ASSERT("netif != NULL", (netif != NULL));
#if LWIP_NETIF_HOSTNAME 
/* Initialize interface hostname */
netif->hostname = "lwip";
#endif /* LWIP_NETIF_HOSTNAME */
/*
Initialize the snmp variables and counters inside the struct netif.
The last argument should be replaced with your link speed, in units
of bits per second.
*/
MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS);
netif->name[0] = IFNAME0;
netif->name[1] = IFNAME1;
/* We directly use etharp_output() here to save a function call.
You can instead declare your own function an call etharp_output()
from it if you have to do some checks before sending (e.g. if link
is available...) */
netif->output = etharp_output;
netif->linkoutput = low_level_output;
/* initialize the hardware */
low_level_init(netif);
return ERR_OK;
}
```

--------------------------------

### Include Directives for CH32F207 Etherlib Configuration

Source: https://epagris.github.io/flexPTP/flexptp__options__ch32f207__etherlib_8h.html

Includes essential headers for flexPTP PTP implementation, standard output, CLI utilities, MAC driver, standard library, and PID controller when targeting the CH32F207 with Etherlib.

```c
#include <etherlib/etherlib.h>
#include "standard_output/standard_output.h"
#include "cliutils/cli.h"
#include "EthDrv/mac_drv.h"
#include <stdlib.h>
#include <flexptp/servo/pid_controller.h>
```

--------------------------------

### Get Delay Mechanism

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Retrieves the currently configured PTP delay mechanism.

```c
PtpDelayMechanism ptp_get_delay_mechanism();
```

--------------------------------

### Initialize PTP

Source: https://epagris.github.io/flexPTP/task__ptp_8c_source.html

Initializes the PTP (Precision Time Protocol) engine. This function should be called once during system startup.

```c
void ptp_init(void)
**Definition:** ptp_core.c:71
```

--------------------------------

### Get Own Clock Identity

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Retrieves the 64-bit identity of the local PTP clock.

```c
#include <stdint.h>

uint64_t ptp_get_own_clock_identity();
```

--------------------------------

### PTP_HW_INIT

Source: https://epagris.github.io/flexPTP/flexptp__options__stm32h743__etherlib_8h.html

Initializes the PTP hardware with a given increment and addend value.

```APIDOC
## PTP_HW_INIT

### Description
Initializes the PTP hardware with a given increment and addend value.

### Macro Signature
`PTP_HW_INIT(increment, addend)`

### Parameters
* `increment`: The increment value for PTP.
* `addend`: The addend value for PTP.
```

--------------------------------

### fifo_get_level

Source: https://epagris.github.io/flexPTP/fifo_8c.html

Gets the current utilization level of the FIFO. This indicates how full the FIFO is.

```APIDOC
## fifo_get_level()

### Description
Get the FIFO utilization level.

### Parameters
* **f** (const Fifo *) - Pointer to a FIFO object.

### Returns
* **uint32_t** - The utilization level of the FIFO.
```

--------------------------------

### STM32F407 Etherlib PTP Options

Source: https://epagris.github.io/flexPTP/flexptp__options__stm32f407__etherlib_8h_source.html

Defines essential configuration macros for flexPTP, including the announce collection window and network stack integration. Ensure Etherlib headers are included and printing/logging functions are provided.

```c
#ifndef FLEXPTP_OPTIONS_STM32F407_H_
#define FLEXPTP_OPTIONS_STM32F407_H_

#define ETHLIB
#define PTP_ADDEND_INTERFACE

// -------------------------------------------
// ------ DEFINES FOR FLEXPTP SETTINGS -------
// -------------------------------------------

#define ANNOUNCE_COLLECTION_WINDOW (2)

// -------------------------------------------
// --- DEFINES FOR PORTING IMPLEMENTATION ----
// -------------------------------------------

// Include LwIP/EtherLib headers here

#include <etherlib/etherlib.h>

// Give a printf-like printing implementation MSG(...)
// Give a maskable printing implementation CLILOG(en,...)
// Provide an SPRINTF-implementation SPRINTF(str,n,fmt,...)

#include "standard_output/standard_output.h"

```

--------------------------------

### Initialize PTP Hardware and Time

Source: https://epagris.github.io/flexPTP/ptp__port__stm32f407__lwip_8c_source.html

Initializes the PTP hardware, enables timestamping, sets the PTP time, and configures fine correction and sub-second increment registers.

```c
92 // enable PTP timestamping
93 ETHHW_EnablePTPTimeStamping(ETH);
94
95 osDelay(10);
96
97 //ETH_EnablePTPTimeStamping(&EthHandle);
98
99 // initialize PTP time
100 ETHHW_InitPTPTime(ETH, 0, 0);
101
102 // enable fine correction
103 ETHHW_EnablePTPFineCorr(ETH, true);
104
105 // set addend register value
106 ETHHW_SetPTPAddend(ETH, addend);
107
108 // set increment register value
109 ETHHW_SetPTPSubsecondIncrement(ETH, increment);
110
111 //ETH_StartPTPPPSPulseTrain(&EthHandle, 500E+06, 1E+09);
112 ETHHW_SetPTPPPSFreq(ETH, ETHHW_PTP_PPS_1Hz);
113 sFreq = 1;
```

--------------------------------

### Clock Offset Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8c_source.html

Functions to set and get the PTP clock offset in nanoseconds.

```APIDOC
## ptp_set_clock_offset

### Description
Sets the PTP clock offset in nanoseconds.

### Function Signature
```c
void ptp_set_clock_offset(int32_t offset)
```

### Parameters
* **offset** (int32_t) - The clock offset in nanoseconds.

## ptp_get_clock_offset

### Description
Retrieves the current PTP clock offset in nanoseconds.

### Function Signature
```c
int32_t ptp_get_clock_offset()
```

### Returns
The current clock offset in nanoseconds.
```

--------------------------------

### Transport Specific Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Functions to set and get the PTP transport specific field.

```APIDOC
## ptp_set_transport_specific

### Description
Sets the PTP transport specific field.

### Method
`void ptp_set_transport_specific(PtpTransportSpecific tspec)`

### Parameters
- **tspec** (PtpTransportSpecific) - The PTP transport specific value to set.

## ptp_get_transport_specific

### Description
Retrieves the PTP transport specific field.

### Method
`PtpTransportSpecific ptp_get_transport_specific()`

### Returns
- The PTP transport specific value.
```

--------------------------------

### Initialize BMCA Module

Source: https://epagris.github.io/flexPTP/bmca_8h.html

Initializes the SBMC module. Call this function during system startup.

```c
#include "ptp_types.h"

void ptp_bmca_init ();
```

--------------------------------

### Get Transport Specific Field

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Retrieves the current value of the transport specific field.

```c
PtpTransportSpecific ptp_get_transport_specific();
```

--------------------------------

### Registering a CLI Command with flexPTP

Source: https://epagris.github.io/flexPTP/cli.html

Demonstrates the `CLI_REG_CMD` macro for registering commands with flexPTP. This macro requires the command hint line, command word count, minimum argument count, and a callback function.

```c
#define CLI_REG_CMD(cmd_hintline, n_cmd, n_min_arg, cb)
```

--------------------------------

### Get PTP Domain

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Retrieves the current PTP domain number of the local clock.

```c
#include <stdint.h>

uint8_t ptp_get_domain();
```

--------------------------------

### Get PTP Tick Count

Source: https://epagris.github.io/flexPTP/ptp__core_8c_source.html

Returns the current tick count of the PTP system.

```c
uint32_t ptp_get_tick() {
 return S.ticks;
}
```

--------------------------------

### ptp_master_init

Source: https://epagris.github.io/flexPTP/master_8h.html

Initializes the PTP Master module.

```APIDOC
## ptp_master_init()

### Description
Initialize the Master module.

### Signature
void ptp_master_init(void)
```

--------------------------------

### Create PTP Message Queues (OS-less)

Source: https://epagris.github.io/flexPTP/task__ptp_8c_source.html

Initializes FIFO queues for packet reception, transmission, events, notifications, and transmission callbacks using a custom fifo_init function for an OS-less environment. Each FIFO is initialized with specific lengths, data sizes, memory pools, and locking mechanisms.

```c
#elif defined(FLEXPTP_OSLESS)
fifo_init(&sRxPacketFIFO, RX_PACKET_FIFO_LENGTH, sizeof(uint32_t), sRxPacketFIFOPool, FLEXPTP_OSLESS_LOCK);
fifo_init(&sTxPacketFIFO, TX_PACKET_FIFO_LENGTH, sizeof(uint32_t), sTxPacketFIFOPool, FLEXPTP_OSLESS_LOCK);
fifo_init(&sEventFIFO, EVENT_FIFO_LENGTH, sizeof(uint32_t), sEventFIFOPool, FLEXPTP_OSLESS_LOCK);
fifo_init(&sNotificationFIFO, NOTIFICATION_FIFO_LENGTH, sizeof(ProcThreadNotification), sNotificationFIFOPool, FLEXPTP_OSLESS_LOCK);
fifo_init(&sTxCbFIFO, TX_CALLBACK_FIFO_LENGTH, sizeof(TxTs), sTxCbFIFOPool, FLEXPTP_OSLESS_LOCK);
#endif
```

--------------------------------

### Tuning Configuration

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Functions to set and get the tuning value in parts per billion (ppb).

```APIDOC
## ptp_set_tuning

### Description
Sets the tuning value in parts per billion (ppb).

### Method
`void ptp_set_tuning(float tuning_ppb)`

### Parameters
- **tuning_ppb** (float) - The tuning value in ppb.

## ptp_get_tuning

### Description
Retrieves the current tuning value in parts per billion (ppb).

### Method
`float ptp_get_tuning()`

### Returns
- The current tuning value in ppb.
```

--------------------------------

### Get Tuning Parameter

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Retrieves the current tuning parameter in parts per billion (ppb).

```c
float ptp_get_tuning();
```

--------------------------------

### Kalman Filter Servo Initialization and Usage

Source: https://epagris.github.io/flexPTP/servo.html

Defines macros for initializing, de-initializing, resetting, and running the Kalman-filter servo. Include this header to use the Kalman-filter servo.

```c
#include <flexptp/servo/kalman_filter.h>
#define PTP_SERVO_INIT() kalman_filter_init()
#define PTP_SERVO_DEINIT() kalman_filter_deinit()
#define PTP_SERVO_RESET() kalman_filter_reset()
#define PTP_SERVO_RUN(d, pscd) kalman_filter_run(d, pscd)
```

--------------------------------

### Get Addend

Source: https://epagris.github.io/flexPTP/settings__interface_8h_source.html

Retrieves the current addend value used in PTP time scale calculations.

```c
#include <stdint.h>

uint32_t ptp_get_addend();
```

--------------------------------

### PTP Hardware Initialization and Control

Source: https://epagris.github.io/flexPTP/flexptp__options__tm4c1294_8h_source.html

Macros for initializing PTP hardware, updating the system clock, and setting the addend register.

```c
#define PTP_HW_INIT(increment, addend) ptphw_init(increment, addend)
#define PTP_UPDATE_CLOCK(s,ns) EMACTimestampSysTimeUpdate(EMAC0_BASE, labs(s), abs(ns), (s * NANO_PREFIX + ns) < 0)
#define PTP_SET_ADDEND(addend) EMACTimestampAddendSet(EMAC0_BASE, addend)
#define PTP_HW_GET_TIME(pt) ptphw_gettime(pt)
```

--------------------------------

### Initialize PTP Hardware Timestamping

Source: https://epagris.github.io/flexPTP/ptp__port__tiva__tm4c1294_8c_source.html

Initializes the Ethernet MAC for PTP timestamping. Configure timestamping options, set the addend for time correction, and enable timestamping. Also initializes PPS output.

```c
void ptphw_init(uint32_t increment, uint32_t addend) {
    EMACTimestampConfig(EMAC0_BASE, EMAC_TS_DIGITAL_ROLLOVER | EMAC_TS_PROCESS_IPV4_UDP | EMAC_TS_ALL | EMAC_TS_PTP_VERSION_2 | EMAC_TS_UPDATE_FINE, increment);
    EMACTimestampAddendSet(EMAC0_BASE, addend);
    EMACTimestampEnable(EMAC0_BASE);

    // init PPS output
    GPIOPinTypePWM(GPIO_PORTG_AHB_BASE, GPIO_PIN_0);
    GPIOPinConfigure(GPIO_PG0_EN0PPS);
    EMACTimestampPPSSimpleModeSet(EMAC0_BASE, EMAC_PPS_1HZ);
}
```

--------------------------------

### Get PTP Profile Count

Source: https://epagris.github.io/flexPTP/ptp__profile__presets_8c_source.html

Returns the total number of predefined PTP profiles available.

```c
size_t ptp_profile_preset_cnt() {
 return PTP_PROFILE_N;
}
```

--------------------------------

### Initialize PTP Master

Source: https://epagris.github.io/flexPTP/master_8h_source.html

Initializes the PTP master module. This function should be called before any other master functions.

```c
#ifndef FLEXPTP_MASTER
#define FLEXPTP_MASTER

#include "ptp_types.h"

#ifdef __cplusplus
extern "C" {
#endif

void ptp_master_init();

void ptp_master_destroy();

void ptp_master_reset();

void ptp_master_tick();

void ptp_master_enable();

void ptp_master_disable();


// -------------

void ptp_master_process_message(RawPtpMessage *pRawMsg, PtpHeader *pHeader);

void ptp_construct_binary_sync(void * pData, const PtpHeader * pHeader); // create Sync message

#ifdef __cplusplus
}
#endif

#endif /* FLEXPTP_MASTER */
```

--------------------------------

### Get Default Interface MAC Address

Source: https://epagris.github.io/flexPTP/nsd__etherlib_8c_source.html

Retrieves the MAC address of the default network interface.

```c
void ptp_nsd_get_interface_address(uint8_t * hwa) {
 memcpy(hwa, get_default_interface()->mac, ETH_HW_ADDR_LEN);
}
```

--------------------------------

### Get PTP Hardware Time Macro

Source: https://epagris.github.io/flexPTP/flexptp__options__mk64f_8h.html

Macro to retrieve the current PTP hardware time.

```c
#define PTP_HW_GET_TIME(pt) ptphw_gettime(pt)
```

--------------------------------

### LWIP Enable Macro

Source: https://epagris.github.io/flexPTP/flexptp__options__mk64f_8h.html

Enables the LWIP (Lightweight IP) stack.

```c
#define LWIP
```

--------------------------------

### Get FIFO Level Function

Source: https://epagris.github.io/flexPTP/fifo_8c_source.html

Returns the current number of elements stored in the FIFO queue.

```c
uint32_t fifo_get_level(const Fifo *f)

```

--------------------------------

### Define PTP_SERVO_INIT Macro

Source: https://epagris.github.io/flexPTP/flexptp__options__stm32h743_8h.html

Initializes the PTP servo controller. Calls the pd_ctrl_init function.

```c
#define PTP_SERVO_INIT() pd_ctrl_init()
```

--------------------------------

### Initialize PTP Hardware Clock (ADDEND Interface)

Source: https://epagris.github.io/flexPTP/porting.html

Initializes the PTP hardware clock using the ADDEND interface. Requires defining the increment and addend values.

```c
#define PTP_HW_INIT(increment, addend) ...
```

--------------------------------

### Clock Lock State Notifications

Source: https://epagris.github.io/flexPTP/monitoring.html

Example notifications indicating the PTP clock's lock status.

```text
PTP LOCKED!
PTP DIVERGED!
```
Tokens:
Raw