bslathi19/cocotbext-eth
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases 2 Wiki Activity

Rename PTP clock timestamp signals to tod and rel

Browse Source 
Signed-off-by: Alex Forencich <alex@alexforencich.com>
This commit is contained in:
Alex Forencich
2023-11-07 01:28:04 -08:00
parent 357dd26aae
commit c44f928bea
7 changed files with 288 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
tests/ptp_clock/test_ptp_clock.py
View File

@@ -46,8 +46,8 @@ class TB:
cocotb.start_soon(Clock(dut.clk, 6.4, units="ns").start())
self.ptp_clock = PtpClock(
ts_96=dut.ts_96,
ts_64=dut.ts_64,
ts_tod=dut.ts_tod,
ts_rel=dut.ts_rel,
ts_step=dut.ts_step,
pps=dut.pps,
clock=dut.clk,
@@ -76,30 +76,31 @@ async def run_default_rate(dut):
await RisingEdge(dut.clk)
start_time = get_sim_time('sec')
start_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_64 = dut.ts_64.value.integer/2**16*1e-9
start_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
await ClockCycles(dut.clk, 10000)
stop_time = get_sim_time('sec')
stop_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_64 = dut.ts_64.value.integer/2**16*1e-9
stop_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
time_delta = stop_time-start_time
ts_96_delta = stop_ts_96-start_ts_96
ts_64_delta = stop_ts_64-start_ts_64
ts_tod_delta = stop_ts_tod-start_ts_tod
ts_rel_delta = stop_ts_rel-start_ts_rel
ts_96_diff = time_delta - ts_96_delta
ts_64_diff = time_delta - ts_64_delta
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("ToD ts delta : %g s", ts_tod_delta)
tb.log.info("rel ts delta : %g s", ts_rel_delta)
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("96 bit ts delta : %g s", ts_96_delta)
tb.log.info("64 bit ts delta : %g s", ts_64_delta)
tb.log.info("96 bit ts diff : %g s", ts_96_diff)
tb.log.info("64 bit ts diff : %g s", ts_64_diff)
ts_tod_diff = time_delta - ts_tod_delta
ts_rel_diff = time_delta - ts_rel_delta
assert abs(ts_96_diff) < 1e-12
assert abs(ts_64_diff) < 1e-12
tb.log.info("ToD ts diff : %g s", ts_tod_diff)
tb.log.info("rel ts diff : %g s", ts_rel_diff)
assert abs(ts_tod_diff) < 1e-12
assert abs(ts_rel_diff) < 1e-12
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
@@ -112,40 +113,41 @@ async def run_load_timestamps(dut):
await tb.reset()
tb.ptp_clock.set_ts_96(12345678)
tb.ptp_clock.set_ts_64(12345678)
tb.ptp_clock.set_ts_tod_ns(12345678)
tb.ptp_clock.set_ts_rel_ns(12345678)
await RisingEdge(dut.clk)
assert dut.ts_96.value.integer == 12345678+((tb.ptp_clock.period_ns << 16) + tb.ptp_clock.period_fns)
assert dut.ts_64.value.integer == 12345678+((tb.ptp_clock.period_ns << 16) + tb.ptp_clock.period_fns)
assert dut.ts_tod.value.integer == 12345678*2**16 + (tb.ptp_clock.period_ns << 16) + tb.ptp_clock.period_fns
assert dut.ts_rel.value.integer == 12345678*2**16 + (tb.ptp_clock.period_ns << 16) + tb.ptp_clock.period_fns
assert dut.ts_step.value.integer == 1
start_time = get_sim_time('sec')
start_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_64 = dut.ts_64.value.integer/2**16*1e-9
start_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
await ClockCycles(dut.clk, 2000)
stop_time = get_sim_time('sec')
stop_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_64 = dut.ts_64.value.integer/2**16*1e-9
stop_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
time_delta = stop_time-start_time
ts_96_delta = stop_ts_96-start_ts_96
ts_64_delta = stop_ts_64-start_ts_64
ts_tod_delta = stop_ts_tod-start_ts_tod
ts_rel_delta = stop_ts_rel-start_ts_rel
ts_96_diff = time_delta - ts_96_delta
ts_64_diff = time_delta - ts_64_delta
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("ToD ts delta : %g s", ts_tod_delta)
tb.log.info("rel ts delta : %g s", ts_rel_delta)
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("96 bit ts delta : %g s", ts_96_delta)
tb.log.info("64 bit ts delta : %g s", ts_64_delta)
tb.log.info("96 bit ts diff : %g s", ts_96_diff)
tb.log.info("64 bit ts diff : %g s", ts_64_diff)
ts_tod_diff = time_delta - ts_tod_delta
ts_rel_diff = time_delta - ts_rel_delta
assert abs(ts_96_diff) < 1e-12
assert abs(ts_64_diff) < 1e-12
tb.log.info("ToD ts diff : %g s", ts_tod_diff)
tb.log.info("rel ts diff : %g s", ts_rel_diff)
assert abs(ts_tod_diff) < 1e-12
assert abs(ts_rel_diff) < 1e-12
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
@@ -158,15 +160,15 @@ async def run_seconds_increment(dut):
await tb.reset()
tb.ptp_clock.set_ts_96(999990000*2**16)
tb.ptp_clock.set_ts_64(999990000*2**16)
tb.ptp_clock.set_ts_tod_ns(999990000)
tb.ptp_clock.set_ts_rel_ns(999990000)
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
start_time = get_sim_time('sec')
start_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_64 = dut.ts_64.value.integer/2**16*1e-9
start_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
saw_pps = False
@@ -175,30 +177,31 @@ async def run_seconds_increment(dut):
if dut.pps.value.integer:
saw_pps = True
assert dut.ts_96.value.integer >> 48 == 1
assert dut.ts_96.value.integer & 0xffffffffffff < 10*2**16
assert dut.ts_tod.value.integer >> 48 == 1
assert dut.ts_tod.value.integer & 0xffffffffffff < 10*2**16
assert saw_pps
stop_time = get_sim_time('sec')
stop_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_64 = dut.ts_64.value.integer/2**16*1e-9
stop_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
time_delta = stop_time-start_time
ts_96_delta = stop_ts_96-start_ts_96
ts_64_delta = stop_ts_64-start_ts_64
ts_tod_delta = stop_ts_tod-start_ts_tod
ts_rel_delta = stop_ts_rel-start_ts_rel
ts_96_diff = time_delta - ts_96_delta
ts_64_diff = time_delta - ts_64_delta
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("ToD ts delta : %g s", ts_tod_delta)
tb.log.info("rel ts delta : %g s", ts_rel_delta)
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("96 bit ts delta : %g s", ts_96_delta)
tb.log.info("64 bit ts delta : %g s", ts_64_delta)
tb.log.info("96 bit ts diff : %g s", ts_96_diff)
tb.log.info("64 bit ts diff : %g s", ts_64_diff)
ts_tod_diff = time_delta - ts_tod_delta
ts_rel_diff = time_delta - ts_rel_delta
assert abs(ts_96_diff) < 1e-12
assert abs(ts_64_diff) < 1e-12
tb.log.info("ToD ts diff : %g s", ts_tod_diff)
tb.log.info("rel ts diff : %g s", ts_rel_diff)
assert abs(ts_tod_diff) < 1e-12
assert abs(ts_rel_diff) < 1e-12
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
@@ -216,30 +219,31 @@ async def run_frequency_adjustment(dut):
await RisingEdge(dut.clk)
start_time = get_sim_time('sec')
start_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_64 = dut.ts_64.value.integer/2**16*1e-9
start_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
await ClockCycles(dut.clk, 10000)
stop_time = get_sim_time('sec')
stop_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_64 = dut.ts_64.value.integer/2**16*1e-9
stop_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
time_delta = stop_time-start_time
ts_96_delta = stop_ts_96-start_ts_96
ts_64_delta = stop_ts_64-start_ts_64
ts_tod_delta = stop_ts_tod-start_ts_tod
ts_rel_delta = stop_ts_rel-start_ts_rel
ts_96_diff = time_delta - ts_96_delta * 6.4/(6+(0x6624+2/5)/2**16)
ts_64_diff = time_delta - ts_64_delta * 6.4/(6+(0x6624+2/5)/2**16)
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("ToD ts delta : %g s", ts_tod_delta)
tb.log.info("rel ts delta : %g s", ts_rel_delta)
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("96 bit ts delta : %g s", ts_96_delta)
tb.log.info("64 bit ts delta : %g s", ts_64_delta)
tb.log.info("96 bit ts diff : %g s", ts_96_diff)
tb.log.info("64 bit ts diff : %g s", ts_64_diff)
ts_tod_diff = time_delta - ts_tod_delta * 6.4/(6+(0x6624+2/5)/2**16)
ts_rel_diff = time_delta - ts_rel_delta * 6.4/(6+(0x6624+2/5)/2**16)
assert abs(ts_96_diff) < 1e-12
assert abs(ts_64_diff) < 1e-12
tb.log.info("ToD ts diff : %g s", ts_tod_diff)
tb.log.info("rel ts diff : %g s", ts_rel_diff)
assert abs(ts_tod_diff) < 1e-12
assert abs(ts_rel_diff) < 1e-12
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
@@ -257,30 +261,31 @@ async def run_drift_adjustment(dut):
await RisingEdge(dut.clk)
start_time = get_sim_time('sec')
start_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_64 = dut.ts_64.value.integer/2**16*1e-9
start_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
start_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
await ClockCycles(dut.clk, 10000)
stop_time = get_sim_time('sec')
stop_ts_96 = (dut.ts_96.value.integer >> 48) + ((dut.ts_96.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_64 = dut.ts_64.value.integer/2**16*1e-9
stop_ts_tod = (dut.ts_tod.value.integer >> 48) + ((dut.ts_tod.value.integer & 0xffffffffffff)/2**16*1e-9)
stop_ts_rel = dut.ts_rel.value.integer/2**16*1e-9
time_delta = stop_time-start_time
ts_96_delta = stop_ts_96-start_ts_96
ts_64_delta = stop_ts_64-start_ts_64
ts_tod_delta = stop_ts_tod-start_ts_tod
ts_rel_delta = stop_ts_rel-start_ts_rel
ts_96_diff = time_delta - ts_96_delta * 6.4/(6+(0x6666+20/5)/2**16)
ts_64_diff = time_delta - ts_64_delta * 6.4/(6+(0x6666+20/5)/2**16)
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("ToD ts delta : %g s", ts_tod_delta)
tb.log.info("rel ts delta : %g s", ts_rel_delta)
tb.log.info("sim time delta : %g s", time_delta)
tb.log.info("96 bit ts delta : %g s", ts_96_delta)
tb.log.info("64 bit ts delta : %g s", ts_64_delta)
tb.log.info("96 bit ts diff : %g s", ts_96_diff)
tb.log.info("64 bit ts diff : %g s", ts_64_diff)
ts_tod_diff = time_delta - ts_tod_delta * 6.4/(6+(0x6666+20/5)/2**16)
ts_rel_diff = time_delta - ts_rel_delta * 6.4/(6+(0x6666+20/5)/2**16)
assert abs(ts_96_diff) < 1e-12
assert abs(ts_64_diff) < 1e-12
tb.log.info("ToD ts diff : %g s", ts_tod_diff)
tb.log.info("rel ts diff : %g s", ts_rel_diff)
assert abs(ts_tod_diff) < 1e-12
assert abs(ts_rel_diff) < 1e-12
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)