Method, system and vehicle for real-time exposure of vehicle fault codes

Abstract

A fault code real-time exposure method for a vehicle, comprising: a fault data acquisition step (S100): an ECU controller acquires fault data of the vehicle; a fault data uploading step (S200): the ECU controller maps the fault data into a fault code message, and uploads the fault code message to a central gateway in a multiplexing manner; a fault code message receiving step (S300): the central gateway receives and locally stores the fault code message; a fault message uploading step (S400): the central gateway packages the locally stored fault code message into a fault message, and sends the fault message to a remote communication module, the remote communication module receives the fault message and uploads the received fault message to a cloud server; and a fault message analyzing step (S500): the cloud server receives and stores the fault message, and analyzes data of the fault message according to a mapping rule, reads and displays the fault code. The application also discloses a fault code real-time exposure system for a vehicle and a vehicle.

Description

Technical Field

[0001] This invention relates to the field of vehicle fault diagnosis, and more specifically, to a method for real-time exposure of vehicle fault codes, a system employing the method, and a vehicle using the system. Background Technology

[0002] As the requirements for automotive functions and configurations become increasingly sophisticated, the number of controllers used in vehicles is also growing, making the need for rapid and efficient vehicle fault diagnosis increasingly urgent. Currently, vehicle fault diagnosis generally utilizes a software module with a unified diagnostic service built into the ECU (Electronic Control Unit) controller. Faults are detected through internal and external sensors of the ECU controller, and the ECU controller stores the detected fault as a fault code. There are currently two main methods for retrieving fault codes: one is to send a diagnostic service to retrieve the fault code via the vehicle's OBD (On-Board Diagnostics) interface; the other is to send a diagnostic service to retrieve the fault code via an onboard remote diagnostic module.

[0003] However, both of these methods require separate hardware devices or integrated corresponding software, and necessitate sending commands to read the data. These methods also have the following drawbacks: First, they impact driving safety: sending diagnostic commands via an external device connected to the OBD interface to read DTC (Diagnostic Trouble Code) information from various ECUs during driving can distract the driver and compromise driving safety. Second, the remote diagnostic module requires certain conditions to trigger before sending diagnostic commands, resulting in poor timeliness. Third, they increase manpower and material costs: the reading operation requires expensive hardware and manpower. Furthermore, when multiple faults occur, uploading fault codes is inefficient and cannot quickly pinpoint the vehicle's fault. Summary of the Invention

[0004] The purpose of this invention is to provide a method for real-time exposure of vehicle fault codes, which can autonomously report a large number of fault codes to a cloud server at one time.

[0005] Another objective of this invention is to provide a real-time fault code exposure system for vehicles, capable of autonomously reporting numerous fault codes to a cloud server at once.

[0006] Another object of the present invention is to provide a vehicle that employs the above-described fault code real-time exposure system for vehicles.

[0007] This invention provides a method for real-time exposure of fault codes in vehicles. The vehicle includes an ECU controller, a central gateway, and a remote communication module, which are communicatively connected to a cloud server. The method includes steps for acquiring fault data, uploading fault data to the central gateway, receiving fault code messages at the central gateway, uploading fault messages to the cloud server, and parsing fault messages.

[0008] In the fault data acquisition step, the ECU controller acquires the vehicle's fault data. In the fault data upload step, the ECU controller maps the fault data into fault code messages and uploads these messages to the central gateway using multiplexing. In the fault code message receiving step, the central gateway receives and stores the fault code messages locally. In the fault message upload step, the central gateway packages the locally stored fault code messages into a single fault message and sends it to the remote communication module. The remote communication module receives the fault message and uploads it to the cloud server. In the fault message parsing step, the cloud server receives and stores the fault message. The cloud server's background monitoring system parses the fault message data according to the mapping rules, reads the fault codes, and displays them.

[0009] According to the fault code real-time exposure method provided by the present invention, the ECU controller can carry a large number of fault codes in a single message through multiplexing, thereby greatly improving the efficiency of the ECU controller in reporting fault codes and thus enabling rapid location of vehicle faults.

[0010] In an illustrative embodiment of the real-time fault code exposure method, the fault data uploading step includes a fault code message generation step and a fault code message sending step. In the fault code message generation step, the ECU controller generates a corresponding fault code based on the fault data, maps the fault code to the data field of the application message, and uses the application message as the fault code message. A fault code message frame includes a multiplexing switch signal and fault code information. The multiplexing switch signal is the multiplexing group number n. The multiplexing group number n occupies four bits, 0 ≤ n ≤ 15. In the fault code message sending step, the ECU controller periodically sends fault code messages to the central gateway according to the multiplexing group number n, starting from 0 and incrementing by 1 sequentially. This achieves the uploading of fault code messages to the central gateway via multiplexing of the fault code messages.

[0011] In one illustrative embodiment of the real-time fault code exposure method, the mapping rule for fault codes in a fault code message includes: in the data field of a fault code message frame, fault code information represents one fault code with every two bits and the fault codes are arranged sequentially. This allows a maximum of 30 fault codes to be carried in the data field of a fault code message frame, thereby improving the efficiency of fault code reporting.

[0012] In another illustrative embodiment of the real-time fault code exposure method, the mapping rule of fault codes in the fault code message further includes: the relationship between the fault code sequence number K and the multiplexing group sequence number n is: K = DTC(n*30+m), where 1≤m≤30. This establishes the relationship between the fault code sequence number K and the multiplexing group sequence number n.

[0013] This invention also provides a real-time fault code exposure system for vehicles. The system includes an ECU controller, a central gateway, a remote communication module, and a cloud server. The ECU controller acquires vehicle fault data and maps the fault data into fault code messages, then uploads the fault code messages to the central gateway using a multiplexed method. The central gateway receives and stores the fault code messages locally, and packages the locally stored fault code messages into a single fault message, which is then sent to the vehicle's remote communication module. The remote communication module receives the fault messages and uploads them to the cloud server. The cloud server receives and stores the fault messages, and its background monitoring system parses the data in the fault messages according to mapping rules, reads the fault codes, and displays them.

[0014] According to the fault code real-time exposure system of the present invention, by means of multiplexing, a single message can carry a large number of fault codes, thereby greatly improving the efficiency of reporting fault codes and enabling rapid location of vehicle faults.

[0015] In one illustrative implementation of a real-time fault code exposure system, the ECU controller maps fault data to fault code messages. This includes: the ECU controller generating a corresponding fault code based on the fault data, mapping the fault code to the data field of an application message, and using the application message as the fault code message. A fault code message frame includes a multiplexing switch signal and fault code information. The multiplexing switch signal is the multiplexing group number n. The multiplexing group number n occupies four bits, 0 ≤ n ≤ 15. The ECU controller uploads fault code messages to the central gateway in a multiplexed manner. This includes: the ECU controller periodically and cyclically sending fault code messages to the central gateway according to the multiplexing group number n, starting from 0 and incrementing by 1 sequentially. This achieves the transmission of fault code messages to the central gateway via multiplexing.

[0016] In one illustrative implementation of a real-time fault code exposure system, the mapping rule for fault codes in a fault code message includes: in the data field of a fault code message frame, fault code information represents one fault code with every two bits, and the fault codes are arranged sequentially. This allows a maximum of 30 fault codes to be carried in the data field of a single fault code message frame, thereby improving the efficiency of fault code reporting.

[0017] In another illustrative implementation of the real-time fault code exposure system, the mapping rule for fault codes in the fault code message further includes: the relationship between the fault code sequence number K and the multiplexing group sequence number n is: K = DTC(n*30+m), where 1≤m≤30. This establishes the relationship between the fault code sequence number K and the multiplexing group sequence number n.

[0018] The present invention further provides a vehicle that uses the above-mentioned real-time fault code exposure system for vehicles, which can autonomously report a large number of fault codes to a cloud server at one time.

[0019] The real-time fault code exposure method provided by this invention employs a message multiplexing scheme, mapping the state of a fault code to every two bits in the message data field. This allows a single message frame to carry a maximum of 30 fault codes, and consequently, a single message can carry a maximum of 480 fault codes, significantly improving the efficiency of fault code reporting by the ECU controller. Furthermore, this real-time fault code exposure method eliminates the need for interaction between external commands and the ECU controller, greatly reducing unpredictable ECU controller malfunctions caused by such interaction and improving vehicle safety. Attached Figure Description

[0020] The following figures are for illustrative purposes only and do not limit the scope of the invention.

[0021] Figure 1 This is a schematic flowchart of a method for real-time exposure of fault codes for vehicles according to the present invention.

[0022] Figure 2 This is a schematic flowchart illustrating the steps of uploading fault data in an illustrative embodiment of the fault code real-time exposure method for vehicles according to the present invention.

[0023] Figure 3 This is a schematic block diagram of a real-time fault code exposure system for vehicles according to the present invention.

[0024] Label Explanation

[0025] S100: Steps to obtain fault data

[0026] S200: Steps for uploading fault data to the central gateway

[0027] S300: Steps for the Central Gateway to Receive Fault Code Messages

[0028] S400: Steps to upload fault messages to the cloud server

[0029] S500: Steps for parsing fault messages

[0030] 100 Fault Code Real-time Exposure System

[0031] 110ECU controller

[0032] 120 Central Gateway

[0033] 121 Local Memory

[0034] 123 Data upload cache

[0035] 130 Remote Communication Module

[0036] 140 cloud servers Detailed Implementation

[0037] To provide a clearer understanding of the technical features, objectives, and effects of the invention, specific embodiments of the invention are now described with reference to the accompanying drawings. In the drawings, the same reference numerals indicate components with the same or similar structures but the same function.

[0038] In this document, “illustrative” means “serving as an example, illustration or description”, and any illustration or implementation described herein as “illustrative” should not be construed as a more preferred or advantageous technical solution.

[0039] To keep the drawings simple, each drawing only schematically shows the parts related to the present invention, and they do not represent the actual structure of the product.

[0040] Figure 1 This is a schematic flowchart of a real-time fault code exposure method for vehicles according to the present invention. Figure 1 As shown, the real-time fault code exposure method for vehicles provided by the present invention includes a fault data acquisition step S100, a fault data upload step S200, a fault code message reception step S300, a fault message upload step S400, and a fault message parsing step S500.

[0041] In step S100, the ECU controller acquires fault data of the vehicle. During vehicle operation, various sensors monitor the vehicle's performance in real time and send the data to the ECU controller, which processes this data in real time and identifies potential faults.

[0042] In step S200 of uploading fault data, the ECU controller maps the fault data into fault code messages and uploads the fault code messages to the central gateway in a multiplexed manner.

[0043] Figure 2 This is a schematic flowchart illustrating the steps of uploading fault data in an illustrative embodiment of the fault code real-time exposure method for vehicles according to the present invention. Figure 2As shown, in one illustrative embodiment of the fault code real-time exposure method, the step S200 of uploading fault data includes the step S210 of generating a fault code message and the step S220 of sending a fault code message.

[0044] In step S210 of generating a fault code message, the ECU controller generates a corresponding fault code based on the fault data, maps the fault code to the data field of the application message, and uses the application message as the fault code message. A fault code message frame includes a multiplexing switch signal and fault code information. The multiplexing switch signal is the multiplexing group number n. The multiplexing group number n occupies four bits, with a value of 0 ≤ n ≤ 15.

[0045] Table 1: CAN Message Data Field

[0046] Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0 Bit15 Bit14 Bit13 Bit12 Bit11 Bit10 Bit9 Bit8 Bit23 Bit22 Bit21 Bit20 Bit19 Bit18 Bit17 Bit16 Bit31 Bit30 Bit29 Bit28 Bit27 Bit26 Bit25 Bit24 Bit39 Bit38 Bit37 Bit36 Bit35 Bit34 Bit33 Bit32 Bit47 Bit46 Bit45 Bit44 Bit43 Bit42 Bit41 Bit40 Bit55 Bit54 Bit53 Bit52 Bit51 Bit50 Bit49 Bit48 Bit63 Bit62 Bit61 Bit60 Bit59 Bit58 Bit57 Bit56

[0047] Table 2: Mapping rules of fault codes in fault code messages

[0048]

[0049] Table 1 shows a schematic of the data field of a CAN message frame. Table 2 shows a schematic of the mapping rules for fault codes in fault code messages. As shown in Table 1, the data field of a CAN message frame consists of sixty-four bits. As shown in Table 2, for example, four bits are used to represent the multiplexing switch signal, with values ​​ranging from 0 to 15, for example, using hexadecimal values ​​from 0X1 to 0XF, but not limited to these. This allows for a total of sixteen CAN message data frames. For example, bits 7 to 4 are used to represent the multiplexing group number, but any other four bits can be selected to represent the multiplexing group number, but not limited to these, and other bit lengths can also be selected to represent the multiplexing switch signal.

[0050] In one illustrative implementation of the real-time fault code exposure method, the 60 bits in the CAN message data field, excluding those used for multiplexing group sequence numbers, are used for fault codes. In the data field of a fault code message frame, fault code information is represented by two bits per fault code, arranged sequentially. For example, there are four fault code states: No fault, Current fault, History fault, and Reserved. For instance, hexadecimal values ​​0x0 represent No fault, 0x1 represent Current fault, 0x3 represent History fault, and 0x4 represent Reserved. Other number systems, such as binary or octal, can also be used to represent different fault code states using two bits. However, this is not a limitation; other bit lengths can also be used to represent fault codes.

[0051] The relationship between the fault code number K and the multiplexing group number n is: K = DTC(n*30+m), where 1≤m≤30. This establishes the relationship between the fault code number K and the multiplexing group number n. For example, as shown in Table 2, when the multiplexing group number n is 0 and 1≤m≤30, the value of K ranges from 1 to 30; when the multiplexing group number n is 1 and 1≤m≤30, the value of K ranges from 31 to 60; when the multiplexing group number n is 2 and 1≤m≤30, the value of K ranges from 61 to 90; ...; when the multiplexing group number n is 15 and 1≤m≤30, the value of K ranges from 451 to 480. That is, a fault code message in a frame corresponding to a multiplexing group can carry a maximum of 30 fault codes in its data field. After multiplexing 16 frames (i.e. 16 groups) of fault code messages, a fault code message corresponding to a message ID can carry a maximum of 480 fault codes.

[0052] In step S220 of sending fault code messages, the ECU controller periodically sends fault code messages to the central gateway according to the multiplexing group number n, starting from 0 and incrementing by 1 sequentially. For example, with a period of 500ms, it first sends a fault code message frame with multiplexing group number n=0, then sends a fault code message frame with multiplexing group number n=1, and so on. After sending a fault code message frame with multiplexing group number n=15, it sends a fault code message frame with multiplexing group number n=0 again, and so on, in a periodic cycle. This allows a maximum of 30 fault codes to be carried in the data field of a single fault code message frame, and a maximum of 480 fault codes to be carried in a single message ID. Thus, by using multiplexing of fault code messages to cyclically send fault code messages to the central gateway, the efficiency of fault code reporting is improved, greatly enhancing the efficiency of the ECU controller in reporting fault codes.

[0053] In step S300 of receiving fault code messages, the central gateway receives and stores the fault code messages locally. The central gateway collects fault code messages sent by each ECU controller of the vehicle in real time, and also collects important information from other application messages sent by each ECU controller, such as vehicle speed, time, engine operating status, vehicle status, and BMS (Battery Management System) high-voltage bus voltage and current. In one illustrative embodiment, for example, the central gateway can be configured with 4G or 8G of local storage to store the above information, for example, storing it in timestamp order, maintaining data in the event of poor or interrupted network transmission, and allowing secure access to retrieve the central gateway's local data, for example, by reading the central gateway's local data through an OBD diagnostic device or remote commands.

[0054] In step S400, when uploading the fault message, the central gateway packages the locally stored fault code messages into a fault message and sends it to the remote communication module. The remote communication module receives the fault message and uploads it to the cloud server. In addition to fault code information, the fault message also includes other application message information such as vehicle speed, time, engine operating status, and overall vehicle status. For example, when the vehicle is connected to a 4G or 5G external network, the central gateway stores the collected information in its local storage, packages the stored information into small data blocks, sends them to the remote communication module, and then uploads them to the cloud server. Alternatively, when the vehicle is not connected to a 4G or 5G external network, the central gateway first stores the collected information in its local storage, and then, after the vehicle connects to a 4G or 5G external network, sends the fault message to the remote communication module, thereby uploading it to the cloud server. For example, the central gateway packages the collected information messages (including fault code messages and other application messages) into fault messages in 10M units and in the order of timestamps. For example, the central gateway sets the data upload cache to 10M and sends fault messages to the remote communication module.

[0055] In step S500, which involves parsing fault messages, the cloud server receives and stores the fault messages. The cloud server's background monitoring system parses the data in the fault messages according to mapping rules, reads and displays the fault codes, and automatically extracts vehicle-wide message data within a preset time period before and after the fault occurs for fault analysis when a fault code indicates a vehicle malfunction. For example, the preset time period can be set by the manufacturer before the vehicle leaves the factory, and can be modified by the user as needed after the vehicle leaves the factory.

[0056] According to the fault code real-time exposure method provided by the present invention, the ECU controller can carry a large number of fault codes in a single message through multiplexing, thereby greatly improving the efficiency of the ECU controller in reporting fault codes and thus enabling rapid location of vehicle faults.

[0057] Figure 3 This is a schematic block diagram of a real-time fault code exposure system for vehicles according to the present invention. Figure 3As shown, the present invention also provides a real-time fault code exposure system 100 for vehicles, including an ECU controller 110, a central gateway 120, a remote communication module 130, and a cloud server 140. The ECU controller 110 may include one or more, and each ECU controller 110 is connected to the central gateway 120 via a CAN bus. The central gateway 120 is connected to the remote communication module 130 via an in-vehicle Ethernet network. The remote communication module 130 communicates with the cloud server 140 via a municipal 4G or 5G communication network. However, this is not a limitation; communication between each ECU controller 110 and the central gateway 120, between the central gateway 120 and the remote communication module 130, and between the remote communication module 130 and the cloud server 140 can be achieved through any other suitable communication method.

[0058] The ECU controller 100 acquires vehicle fault data and maps the fault data into fault code messages, which are then uploaded to the central gateway 120 in a multiplexed manner.

[0059] The central gateway 120 receives and stores fault code messages locally; for example, the central gateway 120 has a local memory 121. The central gateway 120 stores the received fault code messages and other application message data in the local memory 121. The central gateway 120 packages the fault code messages stored in the local memory 121 into a fault message and sends the fault message to the remote communication module 130. In addition to fault code information, the fault message also includes other application message information such as vehicle speed, time, engine operating status, and overall vehicle status. For example, when the vehicle is connected to a 4G or 5G external network, the central gateway stores the collected information in its local memory, packages the stored information into small data blocks, and sends them to the remote communication module, which then uploads them to the cloud server. Alternatively, when the vehicle is not connected to a 4G or 5G external network, the central gateway first stores the collected information in its local memory, and then, after the vehicle connects to a 4G or 5G external network, sends a fault message to the remote communication module, thereby uploading it to the cloud server. For example, the central gateway 120 also has a data upload cache 123. For example, if the data upload cache 123 is set to 10M, the central gateway 120 will package the collected information packets into fault messages in 10M units according to the timestamp order, and send the fault messages to the remote communication module. The remote communication module 130 receives the fault messages and uploads the received fault messages to the cloud server 140.

[0060] The cloud server 140 receives and stores fault messages. Its background monitoring system parses the data of the fault messages according to the mapping rules, reads the fault codes and displays the fault codes. When the fault code indicates that the vehicle has a fault, it automatically extracts the whole vehicle message data within a preset time period before and after the fault occurs for fault analysis.

[0061] According to the fault code real-time exposure system of the present invention, by means of multiplexing, a single message can carry a large number of fault codes, thereby greatly improving the efficiency of reporting fault codes and enabling rapid location of vehicle faults.

[0062] In one illustrative embodiment of the real-time fault code exposure system 100, the ECU controller 110 maps fault data to fault code messages, including: the ECU controller 100 generates a corresponding fault code based on the fault data, maps the fault code to the data field of the application message, and uses the application message as the fault code message. A fault code message frame includes a multiplexing switch signal and fault code information. The multiplexing switch signal is the multiplexing group number n. The multiplexing group number n occupies four bits, with a value of 0 ≤ n ≤ 15. This enables the transmission of fault code messages to the central gateway via multiplexing. The ECU controller 110 uploads fault code messages to the central gateway 120 via multiplexing, including: the ECU controller 100 periodically and cyclically sends fault code messages to the central gateway 120 according to the multiplexing group number n, starting from 0 and incrementing by 1 sequentially.

[0063] For example, in the data field of a fault code message, fault code information is represented by two bits per fault code, and the fault codes are arranged sequentially. This allows a maximum of 30 fault codes to be carried in the data field of a single fault code message, thereby improving the efficiency of fault code reporting. The relationship between the fault code sequence number K and the multiplexing group sequence number n is: K = DTC(n*30+m), where 1≤m≤30. This establishes the relationship between the fault code sequence number K and the multiplexing group sequence number n.

[0064] The present invention further provides a vehicle that uses the above-mentioned real-time fault code exposure system 100 for vehicles, which can autonomously report a large number of fault codes to the cloud server 140 at one time.

[0065] According to the real-time fault code exposure method provided by this invention, by employing a message multiplexing scheme, in the data field of the CAN message, every two bits map to the state of a fault code, enabling a maximum of 30 fault codes to be carried in one frame, and thus a maximum of 480 fault codes to be carried in one message, greatly improving the efficiency of fault code reporting by the ECU controller. Furthermore, the real-time fault code exposure method of this invention omits the process of interaction between the ECU controller and external commands, significantly reducing unpredictable ECU controller failures caused by such interaction and improving driving safety.

[0066] The detailed descriptions listed above are merely specific descriptions of feasible embodiments of the present invention and are not intended to limit the scope of protection of the present invention. All equivalent implementation schemes or modifications made without departing from the spirit of the present invention, such as combinations, divisions or repetitions of features, should be included within the scope of protection of the present invention.

Claims

1. A method for real-time exposure of fault codes for a vehicle, the vehicle including an ECU controller, a central gateway, and a remote communication module; The vehicle is connected with a cloud server, and the vehicle communication comprises the following steps: The method comprises: The ECU controller acquires fault data of the vehicle; The ECU controller maps the fault data into fault code messages, and uploads the fault code messages to the central gateway in a multiplexing manner; comprising: The ECU controller generates corresponding fault codes according to the fault data, maps the fault codes to the data field of an application message, and takes the application message as the fault code message, wherein one frame of the fault code message comprises a multiplexing switch signal and fault code information, the multiplexing switch signal is a multiplexing group serial number n, the multiplexing group serial number n occupies four Bit positions, and 0≤n≤15; and The ECU controller periodically and cyclically sends the fault code message to the central gateway according to the multiplexing group serial number n in the order of starting from 0 and sequentially increasing 1; The central gateway receives and locally stores the fault code message; The central gateway packages the locally stored fault code message into a fault message, and sends the fault message to the remote communication module, the remote communication module receives the fault message and uploads the received fault message to the cloud server; and The cloud server receives and stores the fault message, and analyzes the data of the fault message according to a mapping rule, reads the fault code, and displays the fault code.

2. The fault code real-time exposure method of claim 1, wherein The mapping rule of the fault code in the fault code message comprises that in the data field of one frame of the fault code message, the fault code information is arranged in order with two Bit positions representing one fault code.

3. The fault code real-time exposure method of claim 2, wherein The mapping rule of the fault code in the fault code message further comprises that the relationship between the serial number K of the fault code and the multiplexing group serial number n is K=DTC(n*30+m), wherein 1≤m≤30.

4. A fault code real-time exposure system (100) for a vehicle, the system comprising an ECU controller (110), a central gateway (120), a remote communication module (130), and a cloud server (140), wherein The ECU controller (110) acquires fault data of the vehicle, and maps the fault data into fault code messages, and uploads the fault code messages to the central gateway (120) in a multiplexing manner; wherein The mapping of the fault data into the fault code message comprises: the ECU controller (110) generates a corresponding fault code according to the fault data, and maps the fault code to a data field of an application message as the fault code message, wherein a frame of the fault code message comprises multiplexing switch signal and fault code information, the multiplexing switch signal is a multiplexing group serial number n, wherein the multiplexing group serial number n occupies four Bit positions, 0≤n≤15; and The uploading of the fault code message to the central gateway (120) in a multiplexing manner comprises: the ECU controller (110) periodically and cyclically sends the fault code message to the central gateway (120) according to the multiplexing group serial number n in the order of starting from 0 and sequentially increasing by 1; The central gateway (120) receives and locally stores the fault code message, and packs the locally stored fault code message into a fault message and sends the fault message to the remote communication module (130); The remote communication module (130) receives the fault message and uploads the received fault message to the cloud server (140); and The cloud server (140) receives and stores the fault message, and a background monitoring system thereof analyzes data of the fault message according to a mapping rule, reads the fault code and displays the fault code.

5. The fault code real-time exposure system (100) of claim 4, wherein The mapping rule of the fault code in the fault code message comprises: in a data field of a frame of the fault code message, the fault code information is arranged in order by representing one fault code with every two Bit positions.

6. The fault code real-time exposure system (100) of claim 5, wherein The mapping rule of the fault code in the fault code message further comprises: the relationship between the serial number K of the fault code and the multiplexing group serial number n is K=DTC(n*30+m), wherein 1≤m≤30.

7. A vehicle characterized by comprising: The vehicle adopts the fault code real-time exposure system (100) for a vehicle according to any one of claims 4 to 6.

Images