Last Updated: November 17, 2026
Quick Summary
P2 timing is the time a diagnostic tool waits for an ECU to start responding to a UDS request. To calculate it, subtract the timestamp of the last request frame from the timestamp of the first response frame, then repeat across several requests and compare the worst case to the specified limit.
- Record at least 10 samples, because a single measurement can be misleading due to bus load.
- Use the worst-case observed value when you check it against the specified limit.
- Treat NRC 0x78 Response Pending as a sign the ECU is working, not as a failure.
- P2 applies after NRC 0x78 and sets the extended timeout window.
- Record which diagnostic session was active, since timing can differ between sessions.
Table of Contents
- What P2 Timing Means in UDS Diagnostics
- Where the P2 Timer Starts and Stops
- Step-by-Step: Calculating P2 Timing From a Request
- UDS Response Time Measurement with a CAN Trace
- UDS P2 Timeout Calculation Example
- How NRC 0x78 Response Pending Extends the Window
- Setting Up UDS Diagnostic Session Control Before Timing Tests
- Frequently Asked Questions
What P2 Timing Means in UDS Diagnostics
P2 timing is the time a diagnostic tool, called the client, waits for an electronic control unit (ECU), called the server, to answer a request. In UDS (Unified Diagnostic Services, defined in ISO 14229), this wait is set by timing parameters that control how long each side keeps listening before it gives up.
Knowing your P2 timing helps you tell a slow ECU from a broken one. It also helps you set your tester's timeout so that you do not mark a healthy response as a failure.
P2 versus P2* at a glance
The two parameters are related but not the same. P2 is the normal response window. P2* is the extended window used after the server sends a Negative Response Code 0x78 (Response Pending), which tells the tester that the request is still being processed.
| Parameter | What it measures | When it applies | Typical use |
|---|---|---|---|
| P2 (P2Client / P2Server) | Time from request to first response | Every request | Sets the normal timeout |
| P2* (P2Star) | Extended time after response pending | After NRC 0x78 | Sets the extended timeout |
Use the values published in the ECU's diagnostic specification or your vehicle manufacturer's documentation. Do not assume a fixed number across different ECUs.
Where the P2 Timer Starts and Stops
The P2 timer starts when the tester finishes sending the last frame of a diagnostic request. It stops when the tester receives the first frame of the response. On a CAN network, this means the timer covers the time the request spends on the bus, the server's processing time, and the time the response takes to come back.
Step-by-Step: Calculating P2 Timing From a Request
Follow these steps to calculate the observed P2 time for one request:
- Capture the request frame. Note the timestamp of the last transmitted frame.
- Capture the first response frame. Note its timestamp.
- Subtract the request timestamp from the response timestamp. The result is the observed P2 time.
- Compare the result to the specified P2 value. If it is larger, the ECU is responding late.
- Repeat across several requests. Single measurements can be misleading because of bus load.
A simple formula:
P2 observed = t(first response frame) − t(last request frame)
Record at least 10 samples. Use the worst-case value when you check against a limit.
UDS Response Time Measurement with a CAN Trace
A CAN trace is the most direct way to measure P2 timing. An engineer connects a diagnostic adapter to the vehicle and records the bus while sending a service request. The trace shows each frame with its timestamp.

When you read the trace, look for these points:
- The request frame ID (usually the tester address) and the response frame ID (usually the ECU address)
- Multi-frame transfers, where the first frame and flow control frames affect timing
- Gaps caused by the server's processing time
Filter the trace to one ECU address pair. Mixing traffic from several ECUs makes the timing hard to read.
UDS P2 Timeout Calculation Example
Suppose a tester sends a ReadDataByIdentifier request (service 0x22) to an ECU. The last request frame is logged at 12.300 ms. The first response frame is logged at 12.345 ms.
Observed P2 = 12.345 ms − 12.300 ms = 0.045 ms (45 microseconds)
If the ECU's specified P2 is 50 ms, this response is well within the limit. Now suppose the same request shows a response at 62.300 ms. The observed P2 is 50 ms, which is at the limit, and any further delay would produce a timeout.
Set your tester's timeout slightly above the specified P2 value to allow for bus jitter, but do not set it so high that real faults go unnoticed.
How NRC 0x78 Response Pending Extends the Window
Some ECUs need more time than P2 allows. Instead of waiting silently, they send NRC 0x78 (Response Pending). This tells the tester to keep waiting under the extended P2* limit.
The flow works like this:
- The tester sends a request.
- The ECU sends a negative response with NRC 0x78 before P2 expires.
- The tester resets its timer to P2*.
- The ECU sends the final positive or negative response.
Do not treat NRC 0x78 as a failure. Count it as a sign that the ECU is working. Only count a timeout if no response arrives within P2*, or if the ECU keeps sending 0x78 beyond a reasonable limit set by the manufacturer.
Setting Up UDS Diagnostic Session Control Before Timing Tests
Many ECUs use different timing behavior in different sessions. Before you measure P2 timing, send a Diagnostic Session Control request (service 0x10) to put the ECU in the session you need.
Common session types include:
- 0x01 Default session: Basic operation, usually the shortest timing limits
- 0x02 Programming session: Used for reprogramming, often with longer timing
- 0x03 Extended diagnostic session: Gives access to more services
Record which session was active during each measurement. A P2 value measured in the default session does not apply to a programming session.
For the full set of timing parameters and their allowed ranges, see the source specification referenced by your ECU documentation.
Frequently Asked Questions
What is P2 timing in UDS diagnostics?
P2 timing is the time a tester waits for a positive or negative response from an ECU after sending a diagnostic request. The P2 server timer defines how long the ECU has to begin responding. If no response arrives within that window, the tester treats the request as timed out. Engineers commonly check P2 values against the ECU's documented parameters in ISO 14229-based specifications, and measure actual response times on a CAN trace to confirm the ECU stays within them.
What is the difference between P2 and P2* timing?
P2 is the initial response time window the ECU has after a request. P2* is the extended window that applies after the ECU sends a negative response with NRC 0x78 (Response Pending), telling the tester the ECU needs more time. The tester then waits up to the P2* limit for the final response. Both values are normally reported in the ECU's diagnostic specification, and the exact numbers vary by manufacturer and project.
How does a Response Pending message affect P2 timing?
When an ECU cannot complete a request quickly, it can send NRC 0x78 to signal that processing continues. Each Response Pending message allows the tester to extend its wait to the P2* window. The tester should not send a new request while waiting, and should keep listening for the final positive or negative response. Repeated NRC 0x78 messages are a common sign of long-running ECU operations and are worth logging during debugging.
How do you measure UDS response time in a CAN trace?
Capture the request frame and the first response frame on the CAN bus with a logging tool, then subtract the timestamp of the request from the timestamp of the response. Make sure you are filtering by the correct request and response CAN IDs and that ISO-TP segmentation is accounted for in multi-frame responses. Compare the measured interval against the documented P2 or P2* value to determine whether the ECU met its timing requirement.


