<?xml version="1.0" encoding="UTF-8"?>
            <rss version="2.0">
              <channel>
                <title>DBC Utility Blog</title>
                <link>https://dbcutility.com/blog/</link>
                <description>Simple CAN bus guides with practical examples for J1939, DBC files, Python, C++, XCP, diagnostics, and UDS.</description>
                <language>en-us</language>
                <lastBuildDate>Wed, 18 Nov 2026 00:00:00 GMT</lastBuildDate>
                <item>
  <title>ISO/SAE 21434, UN R155 and R156 explained for CAN and ECU engineers</title>
  <link>https://dbcutility.com/blog/iso-21434-un-r155-r156/</link>
  <guid>https://dbcutility.com/blog/iso-21434-un-r155-r156/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>What the vehicle cybersecurity regulations UN R155 and R156 require, how ISO/SAE 21434 and ISO 24089 support them, how a TARA works step by step with a CAN example, and what changes in daily work on messages, diagnostics and software updates.</description>
</item><item>
  <title>ISO 26262 for CAN and test engineers: what functional safety means for messages</title>
  <link>https://dbcutility.com/blog/iso-26262-for-can-engineers/</link>
  <guid>https://dbcutility.com/blog/iso-26262-for-can-engineers/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>What ISO 26262 asks of in-vehicle communication, in practical terms. ASIL determination from severity, exposure and controllability, how safety goals become requirements on CAN messages, E2E protection, timeouts and safe states, hardware metrics, tool qualification, and how SOTIF differs.</description>
</item><item>
  <title>SecOC explained: authenticated CAN messages with MACs and freshness values</title>
  <link>https://dbcutility.com/blog/secoc-explained/</link>
  <guid>https://dbcutility.com/blog/secoc-explained/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How AUTOSAR Secure Onboard Communication protects CAN and CAN FD messages against manipulation and replay. The authenticator, freshness values, truncation, Profile 1 (24-bit CMAC, 8-bit freshness), the payload cost, and a tested Python sender and receiver.</description>
</item><item>
  <title>AUTOSAR E2E protection on CAN: counters, CRCs and Data IDs explained</title>
  <link>https://dbcutility.com/blog/autosar-e2e-protection-can/</link>
  <guid>https://dbcutility.com/blog/autosar-e2e-protection-can/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How AUTOSAR end-to-end protection works on CAN messages. Profiles 1, 2, 11 and 22 bit by bit, the Data ID modes, what the receiver checks, and the larger profiles for CAN FD and Ethernet. Python code that reproduces the example values in the AUTOSAR specification.</description>
</item><item>
  <title>CAN fault injection: what to inject and how to check the ECU&#x27;s reaction</title>
  <link>https://dbcutility.com/blog/can-fault-injection-testing/</link>
  <guid>https://dbcutility.com/blog/can-fault-injection-testing/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to test an ECU&#x27;s reaction to communication faults: missing messages, frozen counters, wrong CRCs, invalid values, wrong lengths, slow senders, error frames and wiring faults. With a tested Python fault injector and a check that each injected fault is detected.</description>
</item><item>
  <title>Automated CAN signal checks against a DBC: cycle time, range, counters and CRCs</title>
  <link>https://dbcutility.com/blog/automated-can-signal-checks-dbc/</link>
  <guid>https://dbcutility.com/blog/automated-can-signal-checks-dbc/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Turn a CAN recording and a DBC into automatic test results. Check cycle times and timeouts, frame lengths, signal ranges, alive counters, CRCs and unknown IDs with a tested Python checker, then run it as a pytest test in CI.</description>
</item><item>
  <title>Restbus simulation from a DBC with python-can and cantools</title>
  <link>https://dbcutility.com/blog/restbus-simulation-python-dbc/</link>
  <guid>https://dbcutility.com/blog/restbus-simulation-python-dbc/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to simulate every other ECU on a CAN bus from a DBC file: cycle times from GenMsgCycleTime, signal values you can change during a test, live counters and CRCs, and silencing one ECU to test timeouts. A tested Python restbus in about 60 lines.</description>
</item><item>
  <title>CAPL for Python and C engineers: the patterns, side by side with python-can</title>
  <link>https://dbcutility.com/blog/capl-for-python-c-engineers/</link>
  <guid>https://dbcutility.com/blog/capl-for-python-c-engineers/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical introduction to CAPL, the event-driven language of Vector CANoe and CANalyzer, for engineers who know Python or C. Message handlers, timers, sending frames, DBC signals and test cases, each next to its python-can and cantools equivalent.</description>
</item><item>
  <title>HIL, SIL, MIL and PIL testing explained for ECU and CAN engineers</title>
  <link>https://dbcutility.com/blog/hil-sil-mil-pil-testing/</link>
  <guid>https://dbcutility.com/blog/hil-sil-mil-pil-testing/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>What model-in-the-loop, software-in-the-loop, processor-in-the-loop and hardware-in-the-loop testing each check, what a HIL bench is made of, where CAN and the DBC come in, and how the levels fit together in a test strategy.</description>
</item><item>
  <title>Automated CAN reverse engineering: what the research shows</title>
  <link>https://dbcutility.com/blog/automated-can-reverse-engineering-research/</link>
  <guid>https://dbcutility.com/blog/automated-can-reverse-engineering-research/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical review of published methods that recover CAN signals automatically, from bit-flip statistics (READ, TANG) to complete DBC pipelines (CAN-D), reference matching (LibreCAN), frame reuse (CANMatch), byte-level clustering (ByCAN) and LLM agents, with what each one contributes and how to use the ideas.</description>
</item><item>
  <title>OBD-II port pinout, buses and secure gateways: what you can reach</title>
  <link>https://dbcutility.com/blog/obd2-port-pinout-buses-secure-gateway/</link>
  <guid>https://dbcutility.com/blog/obd2-port-pinout-buses-secure-gateway/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Which pins of the OBD-II connector carry CAN, K-line, J1850 and DoIP Ethernet, why many cars show no traffic on the port, how secure gateways limit aftermarket tools, and how to tell a live bus from a filtered diagnostic port. With a tested Python check.</description>
</item><item>
  <title>Which ECU sends which CAN ID? Five ways to map a CAN bus</title>
  <link>https://dbcutility.com/blog/map-can-ids-to-ecus/</link>
  <guid>https://dbcutility.com/blog/map-can-ids-to-ecus/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to find out which ECU transmits each CAN message when you have no DBC: disconnecting ECUs, start-up order, diagnostic identification, and fingerprinting senders by their clock drift. With a tested Python script that groups CAN IDs by sender.</description>
</item><item>
  <title>Reverse engineering J1939 proprietary messages (PGN 0xEF00 and 0xFF00–0xFFFF)</title>
  <link>https://dbcutility.com/blog/reverse-engineer-j1939-proprietary-pgns/</link>
  <guid>https://dbcutility.com/blog/reverse-engineer-j1939-proprietary-pgns/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to find and decode manufacturer-specific J1939 data on trucks, buses and off-highway machines. Proprietary A and B PGNs, grouping by source address, transport protocol, and using standard PGNs such as EEC1 engine speed as a built-in reference. With tested Python code.</description>
</item><item>
  <title>Reverse engineering LIN bus traffic and building an LDF</title>
  <link>https://dbcutility.com/blog/reverse-engineer-lin-bus-build-ldf/</link>
  <guid>https://dbcutility.com/blog/reverse-engineer-lin-bus-build-ldf/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to sniff a LIN bus safely, check protected IDs and checksums, tell classic from enhanced checksums, recover the schedule and frame lengths, and write a starting LDF. With tested Python code and an LDF that parses in ldfparser.</description>
</item><item>
  <title>Reverse engineering automotive Ethernet: from capture to SOME/IP signals</title>
  <link>https://dbcutility.com/blog/reverse-engineer-automotive-ethernet-some-ip/</link>
  <guid>https://dbcutility.com/blog/reverse-engineer-automotive-ethernet-some-ip/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to tap into an automotive Ethernet link, list every SOME/IP service from service discovery, and find signals in SOME/IP payloads without ARXML. Includes a standard-library Python pcap reader, a service lister and a payload survey, tested on a generated capture.</description>
</item><item>
  <title>SOME/IP and SOME/IP-SD explained with real packet bytes</title>
  <link>https://dbcutility.com/blog/some-ip-sd-explained/</link>
  <guid>https://dbcutility.com/blog/some-ip-sd-explained/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How SOME/IP messages and SOME/IP Service Discovery work on automotive Ethernet. The 16-byte header field by field, message types, return codes, methods versus events, and the SD entries and options, with byte-level packets and a tested Python encoder and parser.</description>
</item><item>
  <title>DoIP explained: UDS diagnostics over automotive Ethernet</title>
  <link>https://dbcutility.com/blog/doip-explained-uds-over-ethernet/</link>
  <guid>https://dbcutility.com/blog/doip-explained-uds-over-ethernet/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How Diagnostics over IP (ISO 13400-2) works: the 8-byte header, vehicle discovery over UDP, routing activation, logical addresses and UDS messages over TCP port 13400. With byte-level examples and a standard-library Python client tested against a simulated vehicle.</description>
</item><item>
  <title>How ECU flashing works over UDS: the reprogramming sequence step by step</title>
  <link>https://dbcutility.com/blog/uds-ecu-flashing-sequence/</link>
  <guid>https://dbcutility.com/blog/uds-ecu-flashing-sequence/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>The UDS services an ECU reprogramming sequence uses, in order: sessions, security access, erase, RequestDownload, TransferData, RequestTransferExit and the dependency check. With the exact request bytes, block sequence counter rules, transfer time estimates and a tested Python download loop.</description>
</item><item>
  <title>UDS DTCs explained: service 0x19 and the DTC status byte</title>
  <link>https://dbcutility.com/blog/uds-dtc-0x19-status-byte/</link>
  <guid>https://dbcutility.com/blog/uds-dtc-0x19-status-byte/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to read diagnostic trouble codes with UDS ReadDTCInformation (0x19), what each of the 8 status bits means, which status mask to use, how to read 3-byte DTCs, and how to clear them with 0x14. With raw frames and a tested Python parser.</description>
</item><item>
  <title>CAN acceptance filters and mailboxes: how to calculate the mask</title>
  <link>https://dbcutility.com/blog/can-acceptance-filters-mailboxes/</link>
  <guid>https://dbcutility.com/blog/can-acceptance-filters-mailboxes/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How CAN ID filters work, how to calculate a filter and mask for a set of IDs, how many unwanted IDs a mask lets through, and how mailboxes and receive FIFOs lose frames. With a Python calculator, SocketCAN and candump filters.</description>
</item><item>
  <title>CAN bit stuffing, CRC and arbitration, bit by bit</title>
  <link>https://dbcutility.com/blog/can-bit-stuffing-crc-arbitration/</link>
  <guid>https://dbcutility.com/blog/can-bit-stuffing-crc-arbitration/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>What a CAN frame looks like on the wire. Build one frame bit by bit in Python, calculate its CRC-15, insert the stuff bits, and watch three IDs arbitrate. Covers the CAN FD differences: CRC-17, CRC-21 and the stuff count.</description>
</item><item>
  <title>CAN bit timing and sample point: how to calculate them</title>
  <link>https://dbcutility.com/blog/can-bit-timing-sample-point/</link>
  <guid>https://dbcutility.com/blog/can-bit-timing-sample-point/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to work out the CAN prescaler, time segments, SJW and sample point for any clock and bitrate. Worked examples for 8 to 80 MHz, a Python calculator, oscillator tolerance, SocketCAN settings and CAN FD.</description>
</item><item>
  <title>OBD-II PIDs explained: supported-PID bitmaps, formulas, trouble codes and VIN</title>
  <link>https://dbcutility.com/blog/obd2-pid-bitmaps-formulas-modes/</link>
  <guid>https://dbcutility.com/blog/obd2-pid-bitmaps-formulas-modes/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to find out which OBD-II PIDs a car supports, decode the common ones, read trouble codes with service 03 and the VIN with service 09. Real frame layouts, a formula table and a tested Python scanner.</description>
</item><item>
  <title>Finding OEM data with UDS: how to scan DIDs with service 0x22</title>
  <link>https://dbcutility.com/blog/uds-did-scanning-oem-data/</link>
  <guid>https://dbcutility.com/blog/uds-did-scanning-oem-data/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How to find manufacturer-specific data in an ECU when you have no documentation. Find the ECUs, scan data identifiers with ReadDataByIdentifier, read the negative responses, and work out what the bytes mean. Includes a tested Python scanner.</description>
</item><item>
  <title>How to find counters, checksums and CRCs in CAN frames</title>
  <link>https://dbcutility.com/blog/can-counters-checksums-crc-reverse-engineering/</link>
  <guid>https://dbcutility.com/blog/can-counters-checksums-crc-reverse-engineering/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Identify alive counters, simple checksums and CRC-8 bytes in CAN messages from a log alone. Covers sum, XOR and nibble checksums, CRC-8 SAE J1850 and CRC-8H2F, hidden Data IDs as used by AUTOSAR E2E, and a tested Python search.</description>
</item><item>
  <title>Reverse engineering CAN signals with AI: a pipeline you can test</title>
  <link>https://dbcutility.com/blog/ai-llm-can-reverse-engineering-pipeline/</link>
  <guid>https://dbcutility.com/blog/ai-llm-can-reverse-engineering-pipeline/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How automated CAN reverse engineering works, from bit-flip statistics to correlation with an OBD-II reference, and where an LLM agent fits. Includes a standard-library Python pipeline, a synthetic log with a known DBC, and measured results.</description>
</item><item>
  <title>How to reverse engineer vehicle data: CAN, LIN, Ethernet and OBD-II</title>
  <link>https://dbcutility.com/blog/reverse-engineer-vehicle-data-can-lin-ethernet-obd/</link>
  <guid>https://dbcutility.com/blog/reverse-engineer-vehicle-data-can-lin-ethernet-obd/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Where the data you want lives in a vehicle, which method finds it, and which tools to use on each bus. A map of CAN, CAN FD, LIN, FlexRay, Automotive Ethernet, OBD-II and UDS for reverse engineering, with links to step-by-step guides.</description>
</item><item>
  <title>What Is CAN Bus? A Simple Guide for Engineers</title>
  <link>https://dbcutility.com/blog/can-explained/</link>
  <guid>https://dbcutility.com/blog/can-explained/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>Learn what CAN bus is, how CAN messages work, why vehicles use it, and what you need to start reading CAN data.</description>
</item><item>
  <title>CAN Frame Types Explained: Data, Remote, Error, and Overload</title>
  <link>https://dbcutility.com/blog/can-frame-types/</link>
  <guid>https://dbcutility.com/blog/can-frame-types/</guid>
  <pubDate>Sat, 17 Oct 2026 00:00:00 GMT</pubDate>
  <description>Understand CAN data, remote, error, and overload frames. Learn to identify each in CAN logs, read RTR and FD flags, and check examples with candump and Python.</description>
</item><item>
  <title>What Is J1939? A Simple CAN Bus Guide</title>
  <link>https://dbcutility.com/blog/can-j1939-explained/</link>
  <guid>https://dbcutility.com/blog/can-j1939-explained/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Learn what SAE J1939 is, where it is used, and how PGNs, SPNs, source addresses, and 29-bit CAN IDs fit together.</description>
</item><item>
  <title>Common J1939 PGNs and SPNs: engine speed, vehicle speed, temperatures, fuel, and more</title>
  <link>https://dbcutility.com/blog/common-j1939-pgns-spns/</link>
  <guid>https://dbcutility.com/blog/common-j1939-pgns-spns/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical reference for the J1939 PGNs and SPNs engineers use most, with byte positions, scaling, and offsets for engine speed, vehicle speed, coolant temperature, oil pressure, fuel rate, engine hours, and diagnostics.</description>
</item><item>
  <title>How to decode J1939 data with a DBC file (and why half your frames don&#x27;t decode)</title>
  <link>https://dbcutility.com/blog/decode-j1939-with-dbc/</link>
  <guid>https://dbcutility.com/blog/decode-j1939-with-dbc/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>J1939 DBC files store one 29-bit ID per message, but real buses send each PGN from many source addresses. Learn how J1939 DBCs work, why exact-ID decoding misses frames, and how to decode by PGN with Python and cantools.</description>
</item><item>
  <title>J1939 address claiming and the NAME field explained</title>
  <link>https://dbcutility.com/blog/j1939-address-claiming-name/</link>
  <guid>https://dbcutility.com/blog/j1939-address-claiming-name/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How J1939 ECUs get their source address. Learn the Address Claimed message (PGN 60928), the 64-bit NAME and its fields, how conflicts are resolved, and how to decode a NAME in Python or test claiming on Linux.</description>
</item><item>
  <title>How to read J1939 fault codes: DM1, SPN, FMI, and lamp status explained</title>
  <link>https://dbcutility.com/blog/j1939-dm1-fault-codes-spn-fmi/</link>
  <guid>https://dbcutility.com/blog/j1939-dm1-fault-codes-spn-fmi/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Decode J1939 DM1 active fault messages byte by byte. Learn how lamp status, SPN, FMI, and occurrence count are packed, how multi-fault DM1 uses the transport protocol, and how to decode it in Python.</description>
</item><item>
  <title>What Is a PGN in J1939? PGNs and SPNs Explained</title>
  <link>https://dbcutility.com/blog/j1939-pgn-spn-practical-guide/</link>
  <guid>https://dbcutility.com/blog/j1939-pgn-spn-practical-guide/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Learn what a J1939 PGN is, how to extract it from a 29-bit CAN ID, and how PGNs and SPNs are used to decode heavy-vehicle data.</description>
</item><item>
  <title>J1939 transport protocol explained: BAM and RTS/CTS with examples</title>
  <link>https://dbcutility.com/blog/j1939-transport-protocol-bam-cmdt/</link>
  <guid>https://dbcutility.com/blog/j1939-transport-protocol-bam-cmdt/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>How J1939 sends messages longer than 8 bytes. A walk through TP.CM and TP.DT frames, BAM broadcasts, RTS/CTS connections, the control bytes, real frame examples, and a Python reassembler.</description>
</item><item>
  <title>How CAN works in AUTOSAR: the CAN stack from COM to the CAN driver</title>
  <link>https://dbcutility.com/blog/autosar-can-stack/</link>
  <guid>https://dbcutility.com/blog/autosar-can-stack/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Follow a CAN signal through the AUTOSAR Classic communication stack. Learn what COM, PduR, CanIf, CanTp, CanSM, CanNm, and the CAN driver each do, how I-PDUs become CAN frames, how ARXML maps to DBC, and where J1939 fits.</description>
</item><item>
  <title>What is AUTOSAR? Classic and Adaptive explained for CAN engineers</title>
  <link>https://dbcutility.com/blog/what-is-autosar/</link>
  <guid>https://dbcutility.com/blog/what-is-autosar/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A plain-language introduction to AUTOSAR. Learn the layered Classic Platform (application, RTE, basic software, MCAL), how the Adaptive Platform differs, what ARXML files hold, and where CAN fits in.</description>
</item><item>
  <title>What Is a DBC Viewer? How to Read CAN Database Files</title>
  <link>https://dbcutility.com/blog/what-is-dbc-viewer/</link>
  <guid>https://dbcutility.com/blog/what-is-dbc-viewer/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Learn what a DBC viewer does, what information a DBC file contains, and how to inspect CAN messages and signals step by step.</description>
</item><item>
  <title>What Is CANalyzer? CANalyzer vs DBC Viewer</title>
  <link>https://dbcutility.com/blog/what-is-canalyzer/</link>
  <guid>https://dbcutility.com/blog/what-is-canalyzer/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Learn what Vector CANalyzer is used for and how a CAN bus analyzer differs from a focused DBC viewer.</description>
</item><item>
  <title>What Is Canmatrix? Canmatrix vs DBC Viewer</title>
  <link>https://dbcutility.com/blog/what-is-canmatrix/</link>
  <guid>https://dbcutility.com/blog/what-is-canmatrix/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Learn what the Python canmatrix library does, how to convert CAN database files, and when to use canmatrix instead of a visual DBC viewer.</description>
</item><item>
  <title>How to Use CAN Bus: A Simple Step-by-Step Guide</title>
  <link>https://dbcutility.com/blog/how-to-use-can-bus/</link>
  <guid>https://dbcutility.com/blog/how-to-use-can-bus/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Learn how to connect to a CAN bus, set the bitrate, record frames, send a test frame, and decode data with a DBC file.</description>
</item><item>
  <title>How to Enable CAN Bus in Embedded C Code</title>
  <link>https://dbcutility.com/blog/enable-can-embedded-c/</link>
  <guid>https://dbcutility.com/blog/enable-can-embedded-c/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Learn the steps to initialize a CAN peripheral, configure bit timing and filters, start CAN, and send a frame from embedded C code.</description>
</item><item>
  <title>CAN Bus Python Example: Send and Receive Messages</title>
  <link>https://dbcutility.com/blog/can-bus-python-example/</link>
  <guid>https://dbcutility.com/blog/can-bus-python-example/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Use python-can with SocketCAN to send, receive, filter, and test CAN messages in a small working Python example.</description>
</item><item>
  <title>CAN Bus C++ Example: Send and Receive with SocketCAN</title>
  <link>https://dbcutility.com/blog/can-bus-cpp-example/</link>
  <guid>https://dbcutility.com/blog/can-bus-cpp-example/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Build a small C++ SocketCAN program that opens can0, sends a CAN frame, waits for a frame, and prints the ID and data.</description>
</item><item>
  <title>What Is XCP? ECU Measurement and Calibration Explained</title>
  <link>https://dbcutility.com/blog/what-is-xcp/</link>
  <guid>https://dbcutility.com/blog/what-is-xcp/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>Learn what the XCP protocol is, how it connects calibration tools to ECUs, and how XCP, A2L files, CAN, Ethernet, and UDS differ.</description>
</item><item>
  <title>XCP Python Example: Connect to an ECU with pyXCP</title>
  <link>https://dbcutility.com/blog/xcp-python-example/</link>
  <guid>https://dbcutility.com/blog/xcp-python-example/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Use pyXCP in a simple Python example to connect to an XCP slave over CAN, read the ECU identifier, and inspect connection properties.</description>
</item><item>
  <title>XCP C++ Example: Connect to an ECU over CAN</title>
  <link>https://dbcutility.com/blog/xcp-cpp-example/</link>
  <guid>https://dbcutility.com/blog/xcp-cpp-example/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Build a small Linux C++ SocketCAN example that sends an XCP CONNECT command, waits for the ECU response, and checks the response packet.</description>
</item><item>
  <title>CAN Bus Diagnostics Example: Read Engine RPM with OBD-II</title>
  <link>https://dbcutility.com/blog/can-diagnostics-example/</link>
  <guid>https://dbcutility.com/blog/can-diagnostics-example/</guid>
  <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
  <description>Send a simple read-only OBD-II request over CAN with Python and decode the engine RPM response step by step.</description>
</item><item>
  <title>What Is UDS? Unified Diagnostic Services Explained</title>
  <link>https://dbcutility.com/blog/what-is-uds/</link>
  <guid>https://dbcutility.com/blog/what-is-uds/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>Learn what UDS diagnostics is, how UDS requests and responses work, and what sessions, DIDs, DTCs, security access, and ISO-TP mean.</description>
</item><item>
  <title>Python UDS Tutorial: Read a VIN with udsoncan</title>
  <link>https://dbcutility.com/blog/how-to-implement-uds-over-can/</link>
  <guid>https://dbcutility.com/blog/how-to-implement-uds-over-can/</guid>
  <pubDate>Sun, 06 Sep 2026 00:00:00 GMT</pubDate>
  <description>Learn Python UDS over CAN with udsoncan. Read a VIN, try a local ECU simulator, understand ISO-TP frames, and troubleshoot common errors.</description>
</item><item>
  <title>How to validate a DBC file before release</title>
  <link>https://dbcutility.com/blog/dbc-validation-release-checklist/</link>
  <guid>https://dbcutility.com/blog/dbc-validation-release-checklist/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical DBC validation checklist for CAN and CAN FD teams covering message IDs, signal layouts, scaling, multiplexing, comments, log replay, and release review.</description>
</item><item>
  <title>Multiplexed DBC signals explained without the usual confusion</title>
  <link>https://dbcutility.com/blog/multiplexed-dbc-signals-explained/</link>
  <guid>https://dbcutility.com/blog/multiplexed-dbc-signals-explained/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical guide to multiplexed DBC messages, mux selector signals, conditional signals, payload reuse, common mistakes, and how to decode mux-heavy CAN data.</description>
</item><item>
  <title>CAN error frames and bus-off debugging with SocketCAN</title>
  <link>https://dbcutility.com/blog/can-error-frames-bus-off-debugging/</link>
  <guid>https://dbcutility.com/blog/can-error-frames-bus-off-debugging/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical CAN bus troubleshooting guide covering error frames, error counters, error-active, error-passive, bus-off, bitrate mistakes, termination, SocketCAN diagnostics, and recovery.</description>
</item><item>
  <title>Decode CAN logs with python-can and cantools</title>
  <link>https://dbcutility.com/blog/python-can-cantools-decode-can-logs/</link>
  <guid>https://dbcutility.com/blog/python-can-cantools-decode-can-logs/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical Python workflow for decoding CAN and CAN FD logs with python-can, cantools, DBC files, unknown-ID handling, timestamps, CSV export, and signal validation.</description>
</item><item>
  <title>CAN log file formats: candump, ASC, BLF, MF4, and CSV</title>
  <link>https://dbcutility.com/blog/can-log-formats-asc-blf-mf4-candump/</link>
  <guid>https://dbcutility.com/blog/can-log-formats-asc-blf-mf4-candump/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical comparison of CAN log formats including candump logs, Vector ASC, Vector BLF, MF4/MDF, and CSV for replay, storage, DBC decoding, and engineering analysis.</description>
</item><item>
  <title>How to create a DBC file from reverse-engineered CAN logs</title>
  <link>https://dbcutility.com/blog/reverse-engineer-can-signals-build-dbc/</link>
  <guid>https://dbcutility.com/blog/reverse-engineer-can-signals-build-dbc/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A careful workflow for reverse engineering CAN signals from raw logs, using stimulus notes, bit-change analysis, candidate signals, scale and offset checks, DBC drafting, and validation.</description>
</item><item>
  <title>How to use candump and can-utils for practical CAN bus debugging</title>
  <link>https://dbcutility.com/blog/can-utils-candump-guide/</link>
  <guid>https://dbcutility.com/blog/can-utils-candump-guide/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A hands-on SocketCAN and can-utils guide for engineers who need to bring up CAN interfaces, capture traffic with candump, send test frames, filter IDs, and prepare logs for DBC decoding.</description>
</item><item>
  <title>How to record CAN bus data without creating useless logs</title>
  <link>https://dbcutility.com/blog/record-can-bus-data-workflow/</link>
  <guid>https://dbcutility.com/blog/record-can-bus-data-workflow/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A field-tested workflow for recording CAN and CAN FD traffic with SocketCAN, candump, timestamps, filters, replay, and DBC decode checks.</description>
</item><item>
  <title>How DBC signal encoding and decoding works</title>
  <link>https://dbcutility.com/blog/dbc-signal-encoding-decoding/</link>
  <guid>https://dbcutility.com/blog/dbc-signal-encoding-decoding/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical explanation of CAN DBC signal start bits, byte order, signedness, scale, offset, multiplexing, and how to encode or decode messages with Python and cantools.</description>
</item><item>
  <title>LIN bus for CAN engineers: where it fits and how to think about it</title>
  <link>https://dbcutility.com/blog/lin-bus-for-can-engineers/</link>
  <guid>https://dbcutility.com/blog/lin-bus-for-can-engineers/</guid>
  <pubDate>Fri, 22 May 2026 00:00:00 GMT</pubDate>
  <description>A practical LIN bus guide for engineers who already know CAN, covering master-slave scheduling, LDF files, signals, gateways, diagnostics, and why LIN still appears beside CAN and Ethernet.</description>
</item><item>
  <title>Automotive Ethernet for CAN engineers</title>
  <link>https://dbcutility.com/blog/automotive-ethernet-for-can-engineers/</link>
  <guid>https://dbcutility.com/blog/automotive-ethernet-for-can-engineers/</guid>
  <pubDate>Fri, 22 May 2026 00:00:00 GMT</pubDate>
  <description>A practical guide to Automotive Ethernet for engineers coming from CAN and CAN FD, covering 100BASE-T1, 1000BASE-T1, gateways, tcpdump, SOME/IP-style thinking, and why Ethernet does not replace every CAN bus.</description>
</item><item>
  <title>Best tools to open BLF, ASC, and MF4 CAN log files</title>
  <link>https://dbcutility.com/blog/best-can-log-file-tools/</link>
  <guid>https://dbcutility.com/blog/best-can-log-file-tools/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Someone sent you a CAN log and you do not have the tool that recorded it. Here is which free and paid tools open BLF, ASC, MF4, TRC, and candump files, decode them with a DBC, and convert between formats.</description>
</item><item>
  <title>Best CAN bus analyzer software in 2026: free and paid tools compared</title>
  <link>https://dbcutility.com/blog/best-can-bus-analyzer-software/</link>
  <guid>https://dbcutility.com/blog/best-can-bus-analyzer-software/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Which CAN bus analyzer software should you use? We compare Vector CANalyzer, PEAK PCAN-View and PCAN-Explorer 7, Kvaser CanKing 7, Intrepid Vehicle Spy, TOSUN TSMaster, SavvyCAN, BUSMASTER, and can-utils, and explain why your CAN interface usually decides for you.</description>
</item><item>
  <title>Best DBC editors in 2026: free and paid tools compared</title>
  <link>https://dbcutility.com/blog/best-dbc-editors/</link>
  <guid>https://dbcutility.com/blog/best-dbc-editors/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>Which DBC editor should you use? We compare Vector CANdb++ Editor, Kvaser DBC Editor 7, the CSS Electronics online editor, DBC Utility, SavvyCAN, and the cantools and canmatrix Python libraries, with the best pick for each job.</description>
</item><item>
  <title>What&#x27;s new in DBC Utility 2.0: log analysis, translation, and safer saves</title>
  <link>https://dbcutility.com/blog/whats-new-in-dbc-utility-2/</link>
  <guid>https://dbcutility.com/blog/whats-new-in-dbc-utility-2/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>Everything that changed in DBC Utility 2.0 through 2.0.5, explained by what you can now do, including the ASC/BLF log analyser, German–English translation, value tables, float signals, the Problems list, and file-safe saving.</description>
</item><item>
  <title>How to choose a DBC tool in 2026: editors, analysers, and libraries compared</title>
  <link>https://dbcutility.com/blog/automotive-dbc-tool-alternatives/</link>
  <guid>https://dbcutility.com/blog/automotive-dbc-tool-alternatives/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A plain-language guide to choosing a CAN DBC tool. Compare focused DBC editors, analysis suites, hardware-vendor tools, browser editors, and Python libraries, then test your shortlist with a one-week pilot on your own files.</description>
</item><item>
  <title>What is a DBC file? Format, syntax, and how engineers use it</title>
  <link>https://dbcutility.com/blog/what-are-dbc-files-and-where-used/</link>
  <guid>https://dbcutility.com/blog/what-are-dbc-files-and-where-used/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical guide to CAN DBC files covering the file structure, BO_ and SG_ syntax, byte order, scaling, value tables, attributes, multiplexing, CAN FD, common mistakes, and how teams maintain DBC files.</description>
</item><item>
  <title>ARXML, DBC, and XDD files: which automotive network format to use when</title>
  <link>https://dbcutility.com/blog/arxml-xcd-and-dbc-workflows/</link>
  <guid>https://dbcutility.com/blog/arxml-xcd-and-dbc-workflows/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>A practical guide to ARXML, DBC, XDD/XDC, LDF, A2L, and ODX files, what each one describes, how they hand off to each other, and what to check after converting ARXML to DBC.</description>
</item><item>
  <title>How to review DBC changes safely: a compare workflow for engineering teams</title>
  <link>https://dbcutility.com/blog/dbc-compare-workflow-guide/</link>
  <guid>https://dbcutility.com/blog/dbc-compare-workflow-guide/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>A step-by-step routine for reviewing supplier DBC drops, regenerated databases, and your own edits, using text and structured comparison, multiplexer checks, log validation, and Git-friendly saves.</description>
</item><item>
  <title>Why CAN still matters and where it is better than other vehicle buses</title>
  <link>https://dbcutility.com/blog/why-can-still-matters/</link>
  <guid>https://dbcutility.com/blog/why-can-still-matters/</guid>
  <pubDate>Sat, 14 Mar 2026 00:00:00 GMT</pubDate>
  <description>CAN is not newer than Automotive Ethernet, but newer does not always mean better. This guide compares CAN with LIN, FlexRay, and Ethernet in the contexts where engineers actually make architecture decisions.</description>
</item><item>
  <title>CAN FD explained: why classical CAN had to evolve</title>
  <link>https://dbcutility.com/blog/can-fd-explained/</link>
  <guid>https://dbcutility.com/blog/can-fd-explained/</guid>
  <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
  <description>CAN FD extends classical CAN without abandoning the familiar ecosystem. Learn what changed in the frame, why payload and bitrate mattered, and when CAN FD is the better choice.</description>
</item><item>
  <title>Automotive Ethernet, ECUs, gateways, and the rest of the vehicle network stack</title>
  <link>https://dbcutility.com/blog/automotive-ethernet-and-vehicle-networks/</link>
  <guid>https://dbcutility.com/blog/automotive-ethernet-and-vehicle-networks/</guid>
  <pubDate>Sat, 14 Mar 2026 00:00:00 GMT</pubDate>
  <description>CAN does not live alone. This guide explains how ECUs, gateways, LIN, FlexRay, and Automotive Ethernet coexist inside modern vehicles and why zonal architectures are reshaping the map.</description>
</item><item>
  <title>DBC Utility vs CANdb++, BUSMASTER, SavvyCAN and other DBC tools</title>
  <link>https://dbcutility.com/blog/ecu-dbc-and-tool-selection/</link>
  <guid>https://dbcutility.com/blog/ecu-dbc-and-tool-selection/</guid>
  <pubDate>Wed, 18 Nov 2026 00:00:00 GMT</pubDate>
  <description>An honest comparison of DBC Utility with Vector CANdb++ Editor, BUSMASTER, Kvaser DBC Editor 7, the CSS Electronics DBC editor, and SavvyCAN, including when each one is the better choice.</description>
</item>
              </channel>
            </rss>
