CN109274708B

CN109274708B - Message processing method, device and system applied to automatic driving vehicle

Info

Publication number: CN109274708B
Application number: CN201710588497.7A
Authority: CN
Inventors: 李建飞; 温丰
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2017-07-18
Filing date: 2017-07-18
Publication date: 2021-10-15
Anticipated expiration: 2037-07-18
Also published as: CN109274708A

Abstract

The embodiment of the invention discloses a message processing method, equipment and a system based on an automatic driving vehicle, wherein the equipment comprises the following components: the receiver is used for receiving a first message sent by the terminal equipment; at least one receiving slave controller for processing the first message; the at least one master controller is used for selecting a target slave controller from the at least one receiving slave controller according to the first message so as to send the first message to the target slave controller for processing; at least one transmit slave controller to generate a second message in accordance with a state of the autonomous vehicle; a transmitter, configured to send the second message to the terminal device. By adopting the embodiment of the invention, the problems of traffic jam, vehicle congestion and the like caused by untimely message processing in the prior art can be solved, and the high efficiency of message processing is improved.

Description

Message processing method, device and system applied to automatic driving vehicle

Technical Field

The invention relates to the technical field of vehicle networking, in particular to a message processing method, device and system applied to an automatic driving vehicle.

Background

The Vehicle networking is a large system network which is based on an in-Vehicle network, an inter-Vehicle network and a Vehicle-mounted mobile internet and performs wireless communication and information exchange between vehicles and X (V2X) according to an agreed communication protocol and a data interaction standard. In general, X may be classified into three categories, i.e., Infrastructure (Infrastructure), Pedestrian (Pedestrian), and vehicle (vehicle). The V2X enables communication between vehicles, between vehicles and base stations, and between base stations to obtain messages sent by X, such as a series of traffic messages including road condition messages, road messages, pedestrian messages, and so on, and further can implement intelligent traffic management, intelligent dynamic information service, and vehicle intelligent control, and the V2X is a typical application of the internet of things technology in the field of traffic systems.

In practice, it has been found that the V2X system supports deployment on autonomous vehicles, which employ a message queuing mechanism to process messages, i.e., after processing of one message is completed, the next message is processed. When the number of messages of the vehicle V2X is increased, especially in the case of driving the vehicle in a complicated road section, the message processing congestion is easily caused by the mechanism, and the normal driving of the vehicle and the surrounding vehicles is further influenced, so that the problems of vehicle congestion and the like are caused.

Disclosure of Invention

The embodiment of the invention discloses a message processing method, device and system based on an automatic driving vehicle, wherein a plurality of receiving slave controllers can be used for processing a first message, a plurality of sending slave controllers can be used for generating a second message according to vehicle requirements to be sent to a terminal device, the message can be efficiently processed, and V2X communication with the surrounding environment can be carried out in real time.

In a first aspect, an embodiment of the present invention discloses a message processing device based on an autonomous vehicle, including:

the receiver is used for receiving a first message sent by the terminal equipment;

at least one receiving slave controller for processing the first message;

the at least one master controller is used for selecting a target slave controller from the at least one receiving slave controller according to the first message so as to send the first message to the target slave controller for processing;

at least one transmit slave controller to generate a second message in accordance with a state of the autonomous vehicle;

a transmitter, configured to send the second message to the terminal device.

In a second aspect, an embodiment of the present invention discloses a message processing method based on an autonomous vehicle, including:

the method comprises the steps that message processing equipment receives a first message sent by terminal equipment;

the message processing equipment selects a target slave controller from at least one receiving slave controller according to the first message so as to send the first message to the target slave controller for processing;

the message processing device generates a second message according to the state of the autonomous vehicle;

and the message processing equipment sends the second message to the terminal equipment.

By implementing the embodiment, the plurality of controllers can be used for synchronously processing the messages, the problems of traffic jam, vehicle congestion and the like caused by untimely message processing in the prior art are solved, and the efficiency of message processing is improved.

With reference to the first aspect and the second aspect, in some possible embodiments, the master controller may identify the message identifier carried in the first message, and select a target slave controller from the at least one receiving slave controller according to the message identifier.

In combination with the first and second aspects, in some possible embodiments, the message identification is for identifying a message type to which the first message belongs,

under the condition that the message identifier is a first identifier, the target slave controller is a first slave controller;

under the condition that the message identifier is a second identifier, the target slave controller is a second slave controller;

and under the condition that the message identifier is a third identifier, the target slave controller is a third slave controller.

In combination with the first and second aspects, in some possible embodiments,

the first identifier is a vehicle message identifier, and the first slave controller is a vehicle slave controller;

the second identifier is a pedestrian message identifier, and the second slave controller is specifically a pedestrian slave controller;

the third identifier is an infrastructure message identifier, and the third slave controller is specifically an infrastructure slave controller.

In combination with the first and second aspects, in some possible embodiments,

the master controller can also select a target slave controller from the at least one receiving slave controller according to the working state of each receiving slave controller in the at least one receiving slave controller; wherein the operating state comprises any one of: active state, alarm state, locked state, closed state, error state.

By implementing the above steps, the master controller can preferentially select a receiving slave controller in a locked state or an active state as the target slave controller for processing the first message.

With reference to the first and second aspects, in some possible embodiments, the master controller may further manage an operating status of each of the at least one receiving slave controllers.

Specifically, when the load of the receiving slave controller is greater than a first threshold value and the load of the receiving slave controller is in an increasing trend, the master controller enables a next receiving slave controller to process the load, and sets the working state of the next receiving slave controller to be an active state;

specifically, when the load of the receiving slave controller is greater than a second threshold value, the master controller switches the working state of the receiving slave controller from an active state to an alarm state;

specifically, when the load of the receiving slave controller is smaller than a second threshold, the master controller switches the working state of the receiving slave controller from an alarm state to an active state;

specifically, when the loads of at least two receiving slave controllers of the same type are smaller than a third threshold value, the master controller switches the working state of the receiving slave controller with the lightest load from an active state to a locked state;

specifically, when the time length that the receiving slave controller is in the locked state is greater than a fourth threshold, the master controller switches the working state of the receiving slave controller from the locked state to the closed state;

specifically, when the receiving slave controller has an error, the master controller switches the operating state of the receiving slave controller to an error state.

Accordingly, the master controller may also manage an operating status of each of the at least one transmitting slave controllers.

Specifically, when the load of the sending slave controller is greater than a fifth threshold value and the load of the sending slave controller is in an increasing trend, the master controller enables a next sending slave controller to process the load, and sets the working state of the next sending slave controller to be an active state;

specifically, when the load of the sending slave controller is greater than a sixth threshold, the master controller switches the working state of the sending slave controller from an active state to an alarm state, and closes the demand detection function of the sending slave controller;

specifically, when the load of the sending slave controller is smaller than a seventh threshold, the master controller switches the working state of the sending slave controller from an alarm state to an active state;

specifically, when the loads of at least two sending slave controllers of the same type are smaller than an eighth threshold, the master controller switches the working state of the sending slave controller with the lightest load from an active state to a locked state;

specifically, when the time length that the sending slave controller is in the locked state is greater than a ninth threshold, the master controller switches the working state of the sending slave controller from the locked state to the closed state;

specifically, when the transmitting slave controller has an error, the master controller switches the operating state of the transmitting slave controller to an error state.

By implementing the above steps, the master controller may perform status management on the receiving slave controller or the sending slave controller, and optionally may also perform management such as data maintenance on the receiving slave controller or the sending slave controller, which is not limited.

In a third aspect, an embodiment of the present invention discloses a message processing apparatus, which includes a functional unit configured to execute the method of the second aspect.

In a fourth aspect, an embodiment of the present invention provides a message processing apparatus, including a memory, a communication interface, and a processor coupled to the memory and the communication interface; the memory is used for storing instructions, the processor is used for executing the instructions, and the communication interface is used for communicating with terminal equipment under the control of the processor; wherein the processor, when executing the instructions, performs the method described in the second aspect above.

In this application, the communication interface may be a receiver or a transmitter, and the processor may be a master controller, a receive slave controller, and a transmit slave controller.

In a fifth aspect, a computer-readable storage medium storing program code for mail transmission is provided. The program code comprises instructions for performing the method described in the second aspect above.

In a sixth aspect, there is provided a computer program product comprising instructions which, when run on a computer, cause the computer to perform the method described in the second aspect above.

By implementing the embodiment of the invention, the problems of traffic jam, vehicle congestion and the like caused by untimely message processing in the prior art can be solved, and the high efficiency of message processing is improved.

Drawings

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below.

Fig. 1 is a schematic structural diagram of a message processing device according to an embodiment of the present invention;

FIG. 2 is a schematic flow chart of a message processing method based on an autonomous vehicle according to an embodiment of the present invention;

FIG. 3 is a schematic flow chart of another message processing method based on an autonomous vehicle according to an embodiment of the present invention;

FIG. 4 is a schematic flow chart illustrating a message processing method for an autonomous vehicle according to an embodiment of the present invention;

fig. 5 is a schematic structural diagram of another message processing apparatus according to an embodiment of the present invention;

fig. 6A is a schematic structural diagram of another message processing apparatus according to an embodiment of the present invention;

fig. 6B is a schematic structural diagram of another message processing apparatus according to an embodiment of the present invention;

fig. 7 is a schematic structural diagram of a message processing system according to an embodiment of the present invention.

Detailed Description

The technical solutions in the embodiments of the present invention will be described in detail below with reference to the accompanying drawings of the present invention.

The prior art V2X system is deployed in an autonomous vehicle that utilizes a processor (or controller) to process V2X messages. That is, the message queue mechanism is adopted, and when the processor finishes processing one V2X message, the processor processes the next V2X message. Therefore, when the number of the V2X messages is increased, message congestion and untimely processing occur, so that safe driving of vehicles and surrounding vehicles is influenced, and the problems of vehicle congestion, traffic accidents and the like are caused.

To solve the above problem, please refer to fig. 1, where fig. 1 is a schematic structural diagram of a message processing device based on an autonomous vehicle according to an embodiment of the present invention. The message processing apparatus 100 shown in fig. 1 includes a receiver 102, a master controller 104(host controller), a receive slave controller 106(slave controller), a transmit slave controller 108(master controller), and a transmitter 110.

The master controller 104 has functions of message distribution, data maintenance, slave controller management (specifically, receiving slave controller 106 management and sending slave controller 108 management), and the like.

Specifically, the message distribution means that the master controller 104 distributes the received V2X to the receiving slave controller 106 or the sending slave controller 108 according to a preset rule. The preset rule may be set autonomously on the user side or on the message processing device side, for example, by sending a V2X message to different receiving slave controllers 106 according to the sender type of the V2X message.

Specifically, the data maintenance means that the master controller 104 can maintain the message processing status of each receiving slave controller 106 and each sending slave controller 108, and maintain their operating status, which is described in detail below.

Specifically, the slave controller management means that the master controller 104 can start or stop a corresponding number of the receiving slave controllers 106 and the sending slave controllers 108 in real time according to the maintained message processing conditions of the receiving slave controllers 106 and the sending slave controllers 108.

The receiving slave controller 106 has the functions of processing the first message, controller activation and deactivation, etc. The first message refers to a message distributed by the master controller 104 to the receiving slave controller 106, for example, a V2X message sent by a terminal device to the message processing device 100.

The transmission slave controller 108 has functions of message generation, controller startup and shutdown, and the like. The message generation means that the sending controller 108 can generate a corresponding V2X message according to the state of the autonomous vehicle (i.e. the demand of the vehicle itself) to broadcast to the peripheral terminal devices through the sender 110, for example, generate a vehicle lane-clearing request message, a traffic light state acquisition message, and the like.

The receiver 102 and the transmitter 110 may communicate with a terminal device to receive a message sent by the terminal device or a second message to the terminal device, etc.

In an alternative embodiment, the receiving slave controller 106 may include a first slave controller, a second slave controller, and a third slave controller. Wherein the first slave controller, the second slave controller, and the third slave controller may each process a first message of a different type. The number of the first slave controller, the second slave controller, and the third slave controller may be one or more, and the embodiment of the present invention is not limited.

For example, the receiving slave controller 106 may be divided into a vehicle slave controller (slave _ V), a pedestrian slave controller (slave _ P) and an infrastructure slave controller (slave _ I) according to the difference of the sender of the first message (specifically, the difference of X in V2X). Accordingly, the vehicle slave controller slave _ V may be used to process V2V messages, i.e., messages sent by other vehicles. The pedestrian slave controller slave _ P may be used to process V2P messages, i.e. messages sent by pedestrians. The infrastructure slave _ I may be used to process V2I messages, i.e. messages sent by the infrastructure.

In an alternative embodiment, the number of the master controller 104, the receiving slave controller 106, and the sending slave controller 108 may be one or more, and the embodiment of the present invention is not limited thereto.

In an optional embodiment, the terminal device includes, but is not limited to, a vehicle device, an infrastructure device, a User Equipment (UE), a smart phone (e.g., an Android phone, an IOS phone, etc.), a personal computer, a tablet computer, a palm computer, a Mobile Internet device (MID, Mobile Internet Devices), or a wearable smart device, and the embodiments of the present invention are not limited thereto.

Based on the schematic structural diagram of the message processing apparatus shown in fig. 1, the following describes a specific embodiment related to the reception slave controller and the transmission slave controller of the present invention. Fig. 2 and 4 show specific embodiments relating to a receiving slave controller and a transmitting slave controller, respectively.

Referring to fig. 2, a message processing method based on an autonomous vehicle is disclosed and provided in an embodiment of the present invention. Fig. 2 shows a specific embodiment relating to receiving a slave controller, the method shown in fig. 2 comprising the following implementation steps:

step S202, the receiver receives a first message (namely, a V2X message) sent by the terminal equipment. The receiver sends the first message to the master controller. Accordingly, the master controller receives the first message.

The first message is a V2X message sent by the terminal device to the message processing device, where X is used to characterize the type of the terminal device, and X names may be different in different communication protocols. Typically, the V2X messages include, but are not limited to, V2V messages, V2P messages, V2I messages, or other communication messages.

In an alternative embodiment, the number of the first messages may be one or more, and is not limited. The first message may carry a message identifier, where the message identifier is used to characterize the type of the terminal device, that is, to characterize the message type to which the first message belongs, such as a V2X message, a V2P message, and so on. The first message may also carry identity information (e.g., device ID) of the terminal device, and the identity information of the receiving slave controller (specifically, an identifier of a receiving slave controller) or other information.

And S204, the master controller selects a target slave controller from at least one receiving slave controller according to the first message.

The receiving controller is operable to process messages received by the message processing apparatus, i.e. the first message in step S202. In a case where the number of the receiving slave controllers is at least two, the master controller may select one target slave controller from the at least two receiving slave controllers to process the first message with the target slave controller.

And step S206, the master controller sends the first message to the target slave controller. Accordingly, the target receives the first message from a controller.

Step S208, the target processes the first message from the controller.

Several specific embodiments of step S204 are set forth in detail below.

In the first embodiment, the master controller may arbitrarily select one receiving slave controller from among the at least one receiving slave controller to serve as a target slave controller for processing the first message. The receive slave controller here may be used to process various types of messages, such as may process V2V messages, V2I messages, and so forth.

In a second implementation manner, in a case that the first message carries a message identifier in S202, the master controller may select a target slave controller from the at least one receiving slave controller according to the message identifier.

In the first case, the message identification is used to characterize the type of the first message. Specifically, if the message identifier is a first identifier, the target slave controller may be a first slave controller, where the first slave controller is configured to support processing of a first message that conforms to a type corresponding to the first identifier. Correspondingly, if the message identifier is a second identifier, the target slave controller may be a second slave controller, where the second slave controller is configured to support processing of the first message conforming to the type corresponding to the second identifier. Correspondingly, if the message identifier is a third identifier, the target slave controller may be a third slave controller, where the third slave controller is configured to support processing of the first message conforming to the type corresponding to the third identifier.

The message identifier is used to identify a message type to which the first message belongs, that is, a type that characterizes a sender corresponding to sending the first message. Since there may be different types of provisions in different communication protocols, i.e. the message identities (in particular the first identity, the second identity and the third identity) have different names.

In an alternative embodiment, the message identification is encapsulated in a type (type) field of the first message. The master controller may parse the type field of the first message to learn the message identifier. Typically, the message identification may be any of the following: vehicle message identification, pedestrian message identification, infrastructure message identification. Accordingly, the master controller may learn that the first message paired with the message identification is any one of the following: a vehicle message (i.e., a V2V message), a pedestrian message (i.e., a V2P message), or an infrastructure message (i.e., a V2I message). Further, the master controller may distribute the first message to receiving slave controllers of corresponding types. Specifically, the V2V message is distributed to the vehicle slave controller process, the V2P message is distributed to the pedestrian slave controller process, and the V2I message is distributed to the infrastructure slave controller process.

In an alternative embodiment, the number of the vehicle slave controller, the pedestrian slave controller and the infrastructure slave controller may be one or more, and the embodiment of the present invention is not limited.

In the second case, the message identification may be the identification of a particular receiving slave controller (e.g., controller ID). In the corresponding step S204, the master controller may directly distribute the first message to the receiving slave controller corresponding to the identifier according to the identifier of the receiving slave controller to process the first message. Optionally, the receiving slave controller may refer to the specific explanation in the foregoing related embodiment, that is, the receiving slave controller may be any one of the following: the vehicle slave controller, the pedestrian slave controller and the infrastructure slave controller, the embodiments of the present invention are not limited. The second case is mostly applicable to reply messages after the slave controller processes the message for the certain reception.

In a third embodiment, the master controller may select a target slave controller from the at least one receiving slave controller according to an operating state of each of the at least one receiving slave controllers. The receive slave controller here may be used to handle various types of messages, such as V2V messages, V2P messages, V2I messages, and the like.

Specifically, the master controller may select a receiving slave controller with an active state as the target slave controller to process the first message. Optionally, if there are a plurality of receiving slave controllers currently processing messages, and the loads of the receiving slave controllers all exceed a preset threshold, and the loads of the receiving slave controllers are still in a growing trend, the master controller may preferentially select the receiving slave controller in a locked (locked) state as the target slave controller.

In an alternative embodiment, the operating state includes, but is not limited to, any of the following: active state active, alarm state warning, locked state locked, closed state down, and error state error. The preset threshold may be set autonomously by the user side or the message processing device, which is not limited in the present invention.

In a fourth implementation manner, in S202, the first message carries a message identifier, where the message identifier is used to characterize a type of the first message, and the master controller may select a target slave controller from the at least one receiving slave controller according to a working state of each of the message identifier and the at least one receiving slave controller.

Specifically, the master controller may select at least one candidate slave controller from the at least one receiving slave controller according to the message identifier, where the candidate slave controller is a slave controller in the at least one receiving slave controller, and the candidate slave controller is configured to process a message corresponding to the message identifier, for example, the V2V message may be processed by a selected vehicle slave controller. Then, the master controller can select a target slave controller from the at least one candidate slave controller according to the working state of each candidate slave controller in the at least one candidate slave controller. Preferably, the master controller may select a receiving slave controller whose operating state is in a locked state or an active state as a target slave controller. For how to select the target slave controller according to the message identifier and the working state of each receiving slave controller, reference may be specifically made to the relevant description in the foregoing embodiments, and details are not described here.

In an alternative embodiment, in the third and fourth embodiments, the master controller may select the target slave controller according to an operating status of each of the at least one receiving slave controllers. Accordingly, the master controller also manages the operating status of each of the at least one receiving slave controllers, as described in detail below.

In an alternative embodiment, the message processing device shown in FIG. 1 may be deployed in an autonomous vehicle. When the autonomous vehicle is started, the master controller may start the receiving slave controller and the transmitting slave controller, assign corresponding identifications to them, and initialize the controller state table to perform the implementation steps as shown in the above steps S202 to S208.

The controller status table includes the respective identifications of the receiving slave controller and the sending slave controller, and their respective start time, operating status, type of controller, and so on, and table 1 below exemplarily shows the status table information of the receiving slave controller.

TABLE 1 controller State Table

Controller ID	Type (B)	Starting time	Working state	Others
					s_v_1	slave_V	00	active	--
s_p_1	Slave_P	00	active	--
					s_I_1	Slave_I	00	active	--
--	--	--	--	--

As can be seen from table 1, three kinds of receiving Slave controllers are given, namely a vehicle Slave controller (Slave _ V), a pedestrian Slave controller (Slave _ P) and an infrastructure Slave controller (Slave _ I). In addition, 3 kinds of receiving slave controllers are exemplarily given, each slave controller respectively starts one receiving slave controller at the time 00, namely starts s _ v _1, s _ p _1 and s _ I _1 to process the first message. Other information in table 1 may be reserved field information, such as whether the network is in a networking state, and the like, and the embodiment of the present invention is not limited.

In an alternative embodiment, after step S204, the master controller may also record and update the message distribution statistics table. The message distribution statistical data table includes a type of the first message, a receiving slave controller (i.e., the target slave controller) that processes the first message, start time and a working state of the receiving slave controller, and may further include information related to the sending slave controller, such as an identifier of the sending slave controller, start time and other information. A table of message distribution statistics is given as an example in table 2 below.

Table 2: message distribution statistics table

Message type	Controller ID	Starting time	Working state	Others
					v2v	s_v_1	001	--
v2v	s_v_2	002		--
					v2p	s_p_1	001	--
--	--	--	--	--

As can be seen from table 2, two vehicle slave controllers, s _ V _1 and s _ V _2, for processing the V2V message are exemplary given. And their respective start times, one at time 001 and the other at time 002. For the operation status and other field information, reference may be made to the related description in the foregoing embodiments, and details are not described here.

Based on the embodiment described above in fig. 2, an embodiment in which the master controller manages the operating state of the receiving slave controller is described below. Referring to fig. 3, a message processing method based on an autonomous vehicle according to another embodiment of the present invention is provided. The method as described in fig. 3 comprises the following implementation steps:

step S302, when the master controller detects that the load of the receiving slave controller is larger than a first threshold value and the load of the receiving slave controller is in an increasing trend, the master controller enables the next receiving slave controller to process the load and sets the working state of the next receiving slave controller to be an active state.

The master controller may record, through the message distribution statistical data table, related information of each receiving slave controller in the at least one receiving slave controller, where the related information may include, but is not limited to, an identifier of the controller, a type of processing the first message, start time, and the like.

Accordingly, the master controller may learn, in real time or periodically, the load of the receiving slave controller (specifically, the number of the first messages to be processed in the receiving slave controller) according to a message distribution statistical data table. If the master controller detects that the load of the receiving slave controller is greater than a first threshold value within a first time period while the load of the receiving slave controller is still in a growing trend, the master controller may initiate a next receiving slave controller with the same type and assign an identifier (e.g., an ID) to the next receiving slave controller to enable the next receiving slave controller to process the load (i.e., process the first message). Specifically, the master controller may send a start instruction to the next receiving slave controller. Correspondingly, the next receiving slave controller receives the starting instruction and sets the working state of the next receiving slave controller to be active. For the selection of the next receiving slave controller, reference is made to the relevant explanation for selecting the target slave controller, which is not described in detail here.

Optionally, after the master controller enables the next receiving slave controller, the message distribution statistical data table can be synchronously updated. The first duration may be set autonomously by the user side or the message processing device side, which is not limited in the present invention.

Step S304, when the master controller detects that the load of the receiving slave controller is greater than a second threshold, the master controller switches the working state of the receiving slave controller from an active state to an alarm state, so as to prohibit the first message from being distributed to the receiving slave controller, and increase the load of the receiving slave controller.

When the master controller detects that the load of the receiving slave controller is larger than a second threshold (alarm threshold), the master controller does not distribute the first message to the receiving slave controller any more, so that the receiving slave controller can normally process the first message to be processed in the receiving slave controller, and the load of the receiving slave controller is reduced. Optionally, the master controller may further update the message distribution statistical data table synchronously, and switch the working state of the receiving slave controller to an alarm state warning.

Step S306, under the condition that the main controller detects that the load of the receiving slave controller is smaller than a second threshold value, the main controller switches the working state of the receiving slave controller from an alarm state to an active state.

When the master controller detects that the current load of the receiving slave controller in the alarm state falls below a second threshold value, namely is smaller than the second threshold value, the master controller can switch the working state of the receiving slave controller from the alarm state warning to the active state active so that the receiving slave controller can normally receive and process a first message. Similarly, the master controller can also synchronously update the message distribution statistical data table, and switch the working state of the receiving slave controller to an active state.

And step S308, under the condition that the loads of at least two receiving slave controllers of the same type are smaller than a third threshold value, the master controller switches the working state of the receiving slave controller with the lightest load from an active state to a locking state.

When the master controller detects that the number of receiving slave controllers of a certain type is greater than or equal to 2, and the load of each receiving slave controller is smaller than a third threshold value in a second time period, the master controller can select the receiving slave controller with the smallest load (lightest load), no longer distribute the first message to the receiving slave controller, and update/set the state of the receiving slave controller to be in a locking state. So that the receiving slave processes the first message to be processed within itself. Similarly, the master controller may update the message distribution statistical data table synchronously, and switch the working state of the receiving slave controller to the locked state locked.

The second duration may be set autonomously by the user side or the message processing device side, which is not limited in the embodiment of the present invention.

Step S310, under the condition that the time length of the slave receiving controller in the locking state is greater than a fourth threshold value, the master controller switches the working state of the slave receiving controller from the locking state to the closing state.

When the master controller detects that the receiving slave controller in the locked state does not change in working state after a preset time period (that is, the time period that the receiving slave controller is in the locked state is greater than the fourth threshold), the master controller may switch the working state of the receiving slave controller from the locked state to the closed state down. That is, after the receiving slave controller in the locked state processes the first message to be processed inside, or processes the first message and does not change the state after a period of time elapses, the master controller may switch the operating state of the receiving slave controller to the off state, that is, turn off the receiving slave controller. Similarly, the master controller may update the message distribution statistics table synchronously, and switch the working state of the receiving slave controller to the off state down.

Step S312, when the receiving slave controller has an error, the master controller switches the working state of the receiving slave controller to an error state.

The master controller can detect whether the receiving slave controller generates errors in real time or periodically, and if the receiving slave controller generates errors, the master controller switches the current working state of the receiving slave controller to an error state error. For example, when the master controller does not detect a reply message for a certain message in the receiving slave controller after a preset time period, the master controller may consider that an error occurs in the receiving slave controller, and switch the operating state of the receiving slave controller to an error state.

The first threshold to the fourth threshold may be set independently at the user side or the message processing device side, and they may be the same or different, and the present invention is not limited thereto.

In an alternative embodiment, the steps S302 to S312 are all specific implementations in which the master controller manages the operating state of the receiving slave controller. In addition, the master controller may also perform data maintenance and other management on the receiving slave controller, which is not limited in the present invention.

In an alternative embodiment, the receiving slave controller may be any one or more of the at least one receiving slave controllers, and of course may be the target slave controller in the embodiment of fig. 2.

Please refer to fig. 4, which illustrates a message processing method based on an autonomous vehicle according to an embodiment of the present invention. Fig. 4 shows a specific embodiment relating to a transmitting slave, the method shown in fig. 4 comprising the following implementation steps:

step S402, the sending slave controller generates a second message according to the state of the automatic driving vehicle.

The transmission slave controller is used for processing messages actively transmitted inside the autonomous vehicle. Specifically, the sending slave controller may detect a current state of the autonomous vehicle in real time or periodically, and generate a corresponding second message according to the state of the autonomous vehicle, that is, the sending slave controller may generate a corresponding demand message according to a real-time demand of the autonomous vehicle. For example, a preceding vehicle request yield message, a turn notification message, a traffic light (traffic light) status acquisition message, and the like are generated. Namely, the second message is generated by the terminal device according to the real-time requirement of the automatic driving vehicle and is sent to other external terminal devices.

In an optional embodiment, the second message may further carry an Identifier (ID) of the sending slave controller, so that the message may be directly fed back to the sending slave controller according to the identifier of the sending slave controller during the message feedback. Optionally, the second message may also carry an identifier of the message processing device, or other information, and the like, which is not limited in the present invention.

In an alternative embodiment, the transmission slave controller may be any one or more of the at least one transmission slave controllers in fig. 1, without limitation.

Step S404, the transmitting slave controller transmits the second message to a transmitter. Accordingly, the transmitter receives the second message.

Step S406, the transmitter transmits the second message to the terminal device.

And after the sending controller generates the second message, the second message can be broadcast to other peripheral terminal equipment through the sender.

In an alternative embodiment, the embodiment described with reference to FIG. 1 may be seen: the sending slave controller and the sender are all parts of the message processing equipment. The message processing device may be deployed in an autonomous vehicle. When the autonomous vehicle is started, the master controller may start the receiving slave controller and the transmitting slave controller, assign corresponding identifications to them, and initialize the controller state table to perform the implementation steps as shown in the above steps S402 to S406.

In an alternative embodiment, the master controller may activate the at least one transmitting slave controller according to an operating status of each of the transmitting slave controllers. Preferably, the transmission slave controller that is started may be a transmission slave controller whose state is in a locked state. For details, reference may be made to the related description in the foregoing embodiments, which is not repeated herein.

In an alternative embodiment, the master controller may also manage the operating status of each of the at least one transmitting slave controllers, as described in detail below.

In an alternative embodiment, after step S402, the master controller may also record and update the message distribution statistics table. Specifically, the master controller updates information statistics related to the sending slave controller, such as the number of the second messages and the types of the second messages (e.g., V2V message, V2P message, etc.), which is not limited. For the controller status table and the message distribution statistics table, reference may be made to the related description in the foregoing embodiments, and details are not described here.

Based on the embodiment illustrated in fig. 4, an embodiment in which the master controller manages the operating state of the receiving slave controller is described below. Fig. 5 is a schematic diagram of another message processing method based on an autonomous vehicle according to an embodiment of the present invention. The method as shown in fig. 5 comprises the following implementation steps:

step S502, when the master controller detects that the load of the sending slave controller is larger than a fifth threshold value and the load of the sending slave controller is in an increasing trend, the master controller enables the next sending slave controller to process the load, and the working state of the next sending slave controller is set to be an active state.

And step S504, under the condition that the main controller detects that the load of the sending slave controller is larger than a sixth threshold value, the main controller switches the working state of the sending slave controller from an active state to an alarm state, and closes the demand detection function of the sending slave controller.

When the master controller detects that the load of the sending slave controller (i.e., the number of the sending slave controller generating the second message) reaches an alarm threshold, the master controller may close the demand detection function of the sending slave controller, i.e., close the function of the sending slave controller generating the second message, and currently, the state of the autonomous vehicle is no longer detected and the second message is generated according to the state. Therefore, the sending slave controller normally processes the second message to be processed inside, and the load of the sending slave controller is reduced.

Step S506, under the condition that the main controller detects that the load of the sending slave controller is smaller than a seventh threshold value, the main controller switches the working state of the sending slave controller from an alarm state to an active state, and starts a demand detection function of the sending slave controller.

When the master controller detects that the load of the sending slave controller falls below the alarm threshold, the master controller may start the demand detection function of the sending slave controller again, detect the state of the autonomous vehicle using the function, and generate the second message according to the state.

And step S508, under the condition that the loads of at least two sending slave controllers of the same type are smaller than an eighth threshold value, the master controller switches the working state of the sending slave controller with the lightest load from an active state to a locking state.

Step S510, when the master controller detects that the time length that the sending slave controller is in the locked state is greater than a ninth threshold, the master controller switches the working state of the sending slave controller from the locked state to the closed state.

And step S512, under the condition that the sending slave controller generates errors, the master controller switches the working state of the sending slave controller into an error state.

Step S502 to step S512 may correspond to the related detailed description in the embodiment described with reference to fig. 3, and are not repeated herein.

By implementing the embodiment, the messages of the same type can be distributed to the controllers of the corresponding types to be processed, and the messages can be synchronously processed by the plurality of controllers, so that load sharing is realized, and the message processing efficiency is improved. In addition, because the message can be processed by a plurality of controllers, when a certain controller is attacked, all information of the user can not be revealed, and the safety can be improved to a certain extent.

The above-mentioned scheme provided by the embodiment of the present invention is introduced mainly from the point of interaction between the terminal device and the message processing device. It will be appreciated that the message processing apparatus, in order to carry out the above-described functions, comprises corresponding hardware structures and/or software modules for performing the respective functions. The elements and algorithm steps of the various examples described in connection with the embodiments disclosed herein may be embodied in hardware or in a combination of hardware and computer software. Whether a function is performed as hardware or computer software drives hardware depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present teachings.

The embodiment of the present invention may perform the division of the functional units on the message processing device according to the above method example, for example, each functional unit may be divided corresponding to each function, or two or more functions may be integrated into one processing unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit. It should be noted that the division of the unit in the embodiment of the present invention is schematic, and is only a logic function division, and there may be another division manner in actual implementation.

Fig. 6A shows a schematic diagram of a possible structure of the message processing apparatus according to the above-described embodiment, in the case of an integrated unit. The message processing apparatus 600 includes: a processing unit 602 and a communication unit 603. The processing unit 602 is configured to control and manage actions of the message processing apparatus 600, for example, the processing unit 602 is configured to support the message processing apparatus 600 to perform steps S204, S206, and S208 in fig. 2, steps S302 to S312 in fig. 3, step S402 in fig. 4, and/or to perform other steps of the technology described herein. The communication unit 603 is configured to support communication between the message processing apparatus 600 and other terminal apparatuses, for example, the communication unit 603 is configured to support the message processing apparatus 600 to perform step S202 in fig. 2, steps S404 and S406 in fig. 4, and/or to perform other steps of the techniques described herein. The message processing apparatus 600 may further include a storage unit 601 for storing program codes and data of the message processing apparatus 600.

The Processing Unit 602 may be a Processor or a controller, such as a Central Processing Unit (CPU), a general-purpose Processor, a Digital Signal Processor (DSP), an Application-Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA), or other Programmable logic devices, transistor logic devices, hardware components, or any combination thereof. Which may implement or perform the various illustrative logical blocks, modules, and circuits described in connection with the disclosure. The processor may also be a combination of computing functions, e.g., comprising one or more microprocessors, DSPs, and microprocessors, among others. The communication unit 603 may be a communication interface, a transceiver, a transceiving circuit, etc., wherein the communication interface is a generic term and may comprise one or more interfaces, such as an interface between a message processing device and a terminal device. The storage unit 601 may be a memory.

In this application, the processing unit 602 may be a receiving slave controller, a transmitting slave controller and a master controller in fig. 1, and the communication unit 603 may be a receiver and a transmitter. The number of the receiving slave controllers, the number of the sending slave controllers and the number of the master controllers may be one or more, and the embodiment of the present invention is not limited.

When the processing unit 602 is a processor, the communication unit 603 is a communication interface, and the storage unit 601 is a memory, the message processing apparatus according to the embodiment of the present invention may be the message processing apparatus shown in fig. 6B.

Referring to fig. 6B, the message processing apparatus 610 includes: processor 612, communication interface 613, memory 611. Optionally, the message processing device 610 may also include a bus 614. The communication interface 613, the processor 612 and the memory 611 may be connected to each other via a bus 614; the bus 614 may be a Peripheral Component Interconnect (PCI) bus, an Extended Industry Standard Architecture (EISA) bus, or the like. The bus 614 may be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one thick line is shown in FIG. 6B, but this is not intended to represent only one bus or type of bus.

The specific implementation of the message processing device shown in fig. 6A or fig. 6B may also correspond to the corresponding description of the method embodiments shown in fig. 2 to fig. 5, and is not described herein again.

Based on the same inventive concept, please refer to fig. 7, which is a message processing system according to an embodiment of the present invention. The message processing system shown in fig. 7 includes a terminal device and a message processing device.

The message processing device may be the message processing device in the embodiment of fig. 6A or fig. 6B;

the terminal device may be configured to send a first message to the message processing device; and receiving a second message generated by the message processing device.

For related content not shown in fig. 7, reference may be made to the related description in the embodiments described in fig. 1 to fig. 5, which is not described herein again.

The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied in hardware or in software executed by a processor. The software instructions may be comprised of corresponding software modules that may be stored in a Random Access Memory (RAM), a flash Memory, a Read Only Memory (ROM), an Erasable Programmable ROM (EPROM), an Electrically Erasable Programmable ROM (EEPROM), a register, a hard disk, a removable hard disk, a compact disc Read Only Memory (CD-ROM), or any other form of storage medium known in the art. An exemplary storage medium is coupled to the processor such the processor can read information from, and write information to, the storage medium. Of course, the storage medium may also be integral to the processor. The processor and the storage medium may reside in an ASIC. Additionally, the ASIC may reside in a network device. Of course, the processor and the storage medium may reside as discrete components in a network device.

It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. And the aforementioned storage medium includes: various media that can store program codes, such as ROM, RAM, magnetic or optical disks.

Claims

1. A message processing apparatus applied to an autonomous vehicle, comprising:

at least one receiving slave controller for processing the first message;

a transmitter, configured to send the second message to the terminal device.

2. The apparatus of claim 1, wherein the first message carries a message identifier;

and the at least one master controller is used for identifying the message identifier carried in the first message and selecting a target slave controller from the at least one receiving slave controller according to the message identifier.

3. The apparatus of claim 2,

under the condition that the message identifier is a third identifier, the target slave controller is a third slave controller;

wherein the message identifier is used for identifying the message type to which the first message belongs.

4. The apparatus of claim 3,

the second identifier is a pedestrian message identifier, and the second slave controller is a pedestrian slave controller;

the third identifier is an infrastructure message identifier, and the third slave controller is an infrastructure slave controller.

5. The apparatus according to any one of claims 1 to 4,

the at least one master controller is used for selecting a target slave controller from the at least one receiving slave controller according to the working state of each receiving slave controller in the at least one receiving slave controller; wherein the operating state comprises any one of: active state, alarm state, locked state, closed state, error state.

6. An autonomous vehicle based message handling device, characterized in that it comprises all the features of the device of any of claims 1 to 5, wherein,

the at least one master controller is further configured to manage a working state of each receiving slave controller in the at least one receiving slave controller.

7. The apparatus of claim 6,

when the load of the receiving slave controller is larger than a first threshold value and the load of the receiving slave controller is in an increasing trend, enabling a next receiving slave controller by the master controller to process the load, and setting the working state of the next receiving slave controller to be an active state;

under the condition that the load of the receiving slave controller is larger than a second threshold value, the master controller switches the working state of the receiving slave controller from an active state to an alarm state;

under the condition that the load of the receiving slave controller is smaller than a second threshold value, the master controller switches the working state of the receiving slave controller from an alarm state to an active state;

under the condition that the loads of at least two receiving slave controllers of the same type are smaller than a third threshold value, the master controller switches the working state of the receiving slave controller with the lightest load from an active state to a locking state;

under the condition that the time length of the receiving slave controller in the locking state is greater than a fourth threshold value, the master controller switches the working state of the receiving slave controller from the locking state to the closing state;

and under the condition that the receiving slave controller has an error, the master controller switches the working state of the receiving slave controller into an error state.

8. Message processing device based on an autonomous vehicle, characterized in that it comprises all the features of the device of any of claims 1 to 7, wherein,

the at least one master controller is further configured to manage a working state of each sending slave controller in the at least one sending slave controller.

9. The apparatus of claim 8,

when the load of the sending slave controller is larger than a fifth threshold value and the load of the sending slave controller is in an increasing trend, the master controller enables a next sending slave controller to process the load, and the working state of the next sending slave controller is set to be an active state;

under the condition that the load of the sending slave controller is larger than a sixth threshold value, the master controller switches the working state of the sending slave controller from an active state to an alarm state and closes the demand detection function of the sending slave controller;

under the condition that the load of the sending slave controller is smaller than a seventh threshold value, the master controller switches the working state of the sending slave controller from an alarm state to an active state;

under the condition that the loads of at least two sending slave controllers of the same type are smaller than an eighth threshold value, the master controller switches the working state of the sending slave controller with the lightest load from an active state to a locked state;

under the condition that the time length of the sending slave controller in the locking state is greater than a ninth threshold value, the master controller switches the working state of the sending slave controller from the locking state to a closing state;

and under the condition that the sending slave controller has an error, the master controller switches the working state of the sending slave controller into an error state.

10. A message processing system comprising a message processing apparatus and a terminal apparatus, wherein:

the message processing apparatus is a message processing apparatus as claimed in any one of claims 1 to 9 above;

the terminal device is used for sending a first message to the message processing device; and receiving a second message sent by the message processing equipment.

11. A message processing method for an autonomous vehicle, comprising:

the method comprises the steps that message processing equipment applied to the automatic driving vehicle receives a first message sent by terminal equipment;

the message processing equipment selects a target slave controller from at least one receiving slave controller in the message processing equipment according to the first message so as to send the first message to the target slave controller for processing;

12. The method of claim 11, wherein the first message carries a message identifier, and wherein the message processing device selects the target slave controller from the at least one receiving slave controller according to the first message comprises:

and the message processing equipment identifies the message identifier carried in the first message and selects a target slave controller from the at least one receiving slave controller according to the message identifier.

13. The method of claim 12,

14. The method of claim 13,

15. The method according to any one of claims 11-14, wherein the message processing device selecting a target slave controller from at least one receiving slave controller according to the first message comprises:

the message processing equipment selects a target slave controller from the at least one receiving slave controller according to the working state of each receiving slave controller in the at least one receiving slave controller; wherein the operating state comprises any one of: active state, alarm state, locked state, closed state, error state.

16. A method of message handling based on an autonomous vehicle, the method comprising all the features of the method of any of claims 11 to 15, wherein the method further comprises: the message processing device manages an operating state of each of the at least one receiving slave controller.

17. The method of claim 16,

when the load of the receiving slave controller is larger than a first threshold value and the load of the receiving slave controller is in an increasing trend, enabling a next receiving slave controller by a master controller in the message processing equipment to process the load, and setting the working state of the next receiving slave controller to be an active state;

18. A method of message handling based on an autonomous vehicle, the method comprising all the features of the method of any of claims 11 to 17, wherein the method further comprises:

the message processing device manages the working state of each of at least one transmitting slave controller in the message processing device.

19. The method of claim 18,

when the load of the sending slave controller is larger than a fifth threshold value and the load of the sending slave controller is in an increasing trend, the master controller in the message processing equipment enables a next sending slave controller to process the load, and the working state of the next sending slave controller is set to be an active state;

20. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 11 to 19.