Vehicle-mounted camera equipment firmware development method and device, electronic equipment and storage medium

Abstract

The application discloses a kind of vehicle-mounted camera equipment firmware development method, device, electronic equipment and storage medium.The features include: receiving the firmware development instruction input by user;Parse the firmware development instruction, determine the firmware development function called by firmware development instruction and to be developed object;Wherein, the to be developed object includes engineering file and node interface;Receive the development execution instruction input by user, execute firmware development function to the to be developed object according to the development execution instruction.It is realized that firmware development of vehicle-mounted camera equipment is quickly realized by development instruction, improves the development efficiency of firmware, reduces the workload of development staff.

Description

Technical Field

[0001] This invention relates to the field of vehicle system development, and more particularly to a method, apparatus, electronic device, and storage medium for firmware development of vehicle-mounted camera equipment. Background Technology

[0002] With the rapid development of vehicle electronics, in-vehicle camera equipment can capture images of the vehicle's interior and exterior. Through image processing, vehicles can effectively improve driving performance and safety. Currently, firmware development for in-vehicle camera equipment typically involves using the OpenVX framework in embedded systems to abstract the underlying hardware and unify the interface. Users currently use Texas Instruments' RTOS SDK to develop and compile the firmware. However, because firmware development requires a large amount of code, updating and modifying the firmware necessitates identifying the objects to be modified within a massive proxy list before making individual changes, resulting in low user efficiency. Summary of the Invention

[0003] This invention provides a method, apparatus, electronic device, and storage medium for firmware development of vehicle-mounted camera equipment, enabling fully automated and accurate testing of window applications.

[0004] According to one aspect of the present invention, a firmware development method for an in-vehicle camera device is provided, comprising:

[0005] Receive firmware development instructions from the user;

[0006] The firmware development instructions are parsed to determine the firmware development functions called by the instructions and the objects to be developed; wherein, the objects to be developed include project files and node interfaces;

[0007] Receive development execution instructions input by the user, and perform firmware development functions on the object to be developed according to the development execution instructions.

[0008] According to another aspect of the present invention, a firmware development apparatus for an in-vehicle camera device is provided, comprising:

[0009] A development function selection module is used to receive firmware development instructions input by the user;

[0010] The instruction parsing module is used to parse the firmware development instructions and determine the firmware development functions and objects to be developed called by the firmware development instructions; wherein, the objects to be developed include project files and node interfaces;

[0011] The firmware development module is used to receive development execution instructions input by the user and perform firmware development functions on the object to be developed according to the development execution instructions.

[0012] According to another aspect of the present invention, an electronic device is provided, the electronic device comprising:

[0013] At least one processor; and

[0014] A memory communicatively connected to the at least one processor; wherein,

[0015] The memory stores a computer program that can be executed by the at least one processor, which enables the at least one processor to execute the vehicle-mounted camera firmware development method according to any embodiment of the present invention.

[0016] According to another aspect of the present invention, a computer-readable storage medium is provided, the computer-readable storage medium storing computer instructions for causing a processor to execute and implement the vehicle-mounted camera firmware development method according to any embodiment of the present invention.

[0017] The technical solution of this invention receives firmware development instructions input by the user. These instructions determine the firmware function to be developed, eliminating the need for staff to search through large amounts of code and improving firmware development efficiency. The instructions are parsed to determine the firmware development function invoked and the object to be developed. The object to be developed includes project files and node interfaces. Parsing the firmware development instructions allows entry into the development process corresponding to the firmware development function, calling the object to be developed that can be developed by the firmware development function, further simplifying the development process and improving efficiency. Finally, the invention receives development execution instructions input by the user and executes the firmware development function on the object to be developed according to these instructions. Firmware development based on development execution instructions achieves development without code, improving the efficiency of firmware development for automotive camera equipment. This solves the technical problem of cumbersome and inefficient firmware development processes in existing automotive camera equipment, meeting the need for rapid development of automotive firmware, simplifying the development process, and saving development costs.

[0018] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of the present invention, nor is it intended to limit the scope of the invention. Other features of the invention will become readily apparent from the following description. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0020] Figure 1 This is a flowchart of a firmware development method for an in-vehicle camera device provided in an embodiment of the present invention;

[0021] Figure 2 This is a flowchart of another method for developing firmware for an in-vehicle camera device provided in an embodiment of the present invention;

[0022] Figure 3 This is a flowchart of another method for developing firmware for an in-vehicle camera device provided in an embodiment of the present invention;

[0023] Figure 4 This is a flowchart of another method for developing firmware for an in-vehicle camera device provided in an embodiment of the present invention;

[0024] Figure 5 This is a schematic diagram of the structure of a firmware development device for an in-vehicle camera provided in an embodiment of the present invention;

[0025] Figure 6 This is a schematic diagram of the structure of an electronic device that implements the firmware development method for vehicle-mounted camera devices according to embodiments of the present invention. Detailed Implementation

[0026] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0027] Figure 1 This is a flowchart illustrating a method for developing firmware for an in-vehicle camera device according to an embodiment of the present invention. This embodiment is applicable to the development of firmware for in-vehicle camera devices. The method can be executed by an in-vehicle camera device firmware development device, which can be implemented in hardware and / or software and can be configured in an electronic device. Figure 1 As shown, the method includes:

[0028] S110: Receives firmware development instructions input by the user.

[0029] Firmware development commands can be terminal commands defined in the development environment. It should be noted that when users are developing firmware, they can install the initialization tool and enter development help commands in the development terminal to query firmware development commands and their corresponding development functions.

[0030] Optionally, the process for installing the initialization tools on the development terminal is as follows: Enter "Vision" in the development terminal. According to the terminal's feedback prompt "Please set the absolute path of the RTOS SDK project", enter the absolute path of the development project directory, enter the RTOS SDK project, and choose whether to set up the development environment. If you choose to set up the development environment, the terminal compiles the original SDK, executes development commands, compiles the necessary development tools for firmware development, and completes the setup of the development environment. After the development environment setup is completed, exit Vision from the development terminal.

[0031] Specifically, the user initializes the development environment on the development terminal and inputs firmware development commands for the vehicle-mounted camera device firmware development.

[0032] S120. Parse the firmware development instructions to determine the firmware development functions and objects to be developed that are called by the firmware development instructions.

[0033] Among them, the firmware development function can be a pre-configured development function for developing firmware for vehicle-mounted camera equipment.

[0034] The object to be developed can be a development object within the firmware of the vehicle-mounted camera device. It should be noted that the firmware of the vehicle-mounted camera device consists of multiple code files, and the object to be developed can be any of these code files. The object to be developed includes project files and node interfaces. Project files can be simulation program files provided by the development environment during the development process; node interfaces can be interface code extracted from the main program of the vehicle-mounted camera device firmware for isolated testing.

[0035] Specifically, the user inputs firmware development commands, the firmware development commands are parsed, the firmware development functions called by the firmware development commands are determined, and the objects to be developed by the user are determined through the firmware development functions.

[0036] S130: Receive the development execution instruction input by the user, and execute firmware development functions on the object to be developed according to the development execution instruction.

[0037] The development execution instructions can be instructions for developing the firmware code of the vehicle-mounted camera device. It should be noted that the development execution instructions can select the object to be developed and then perform functional development on that object.

[0038] Specifically, after the user selects the firmware development function, the system displays the objects to be developed that can be developed using the firmware development function, receives the development execution instructions input by the user, and executes the firmware development function on the objects to be developed after confirming the objects to be developed by the user.

[0039] Optionally, in another optional embodiment of the present invention, the firmware development instructions include at least one of parameter adjustment instructions, node debugging instructions, and firmware compilation instructions.

[0040] The parameter adjustment command can be a command to adjust the parameters of the vehicle camera firmware. Optionally, in the development of vehicle camera firmware, the shooting performance of the vehicle camera can be controlled by setting the parameters of the vehicle camera firmware, such as adjusting the shooting resolution parameters, shooting interval parameters, shooting duration parameters, and shooting angle parameters. For example, by using the parameter adjustment command, selecting to adjust the shooting resolution parameter of the vehicle camera, and inputting the adjustment resolution as "1920x1080", the resolution of the vehicle camera's shooting resolution will be adjusted to 1920x1080.

[0041] The node debugging commands can be commands used to test and debug various nodes in the vehicle camera firmware. Optionally, during the development of vehicle camera firmware, users need to test and debug the various node interfaces they develop, and the node debugging commands are used to test the interfaces of the nodes that need to be debugged.

[0042] The firmware compilation instructions can be commands used to compile various project files within the vehicle camera firmware. Optionally, during the development of vehicle camera firmware, it is necessary to compile the developed firmware functions and import them into the vehicle camera device to be developed, enabling the vehicle camera device to implement the user-developed functions.

[0043] The technical solution of this invention receives firmware development instructions input by the user. These instructions determine the firmware function to be developed, eliminating the need for staff to search through large amounts of code and improving firmware development efficiency. The instructions are parsed to determine the firmware development function invoked and the object to be developed. The object to be developed includes project files and node interfaces. Parsing the firmware development instructions allows entry into the development process corresponding to the firmware development function, calling the object to be developed that can be developed by the firmware development function, further simplifying the development process and improving efficiency. Finally, the invention receives development execution instructions input by the user and executes the firmware development function on the object to be developed according to these instructions. Firmware development based on development execution instructions achieves development without code, improving the efficiency of firmware development for automotive camera equipment. This solves the technical problem of cumbersome and inefficient firmware development processes in existing automotive camera equipment, meeting the need for rapid development of automotive firmware, simplifying the development process, and saving development costs.

[0044] Figure 2This is a flowchart of another vehicle-mounted camera firmware development method provided by an embodiment of the present invention. The relationship between this embodiment and the above embodiments is that the firmware development function includes a parameter setting function, and the development execution instruction includes a file parameter update instruction. The method for setting and updating file parameters in vehicle-mounted camera firmware development is described in detail below. Figure 2 As shown, the firmware development method for this vehicle-mounted camera device includes:

[0045] S210: Receive firmware development instructions input by the user.

[0046] In this embodiment of the invention, the firmware development command is a parameter adjustment command.

[0047] Specifically, when a user needs to adjust the parameters of the vehicle camera firmware, they input a parameter adjustment command; upon receiving the user's parameter adjustment command, the system recognizes that the user has made parameter adjustments.

[0048] S220. Parse the parameter adjustment command, and call the parameter setting function according to the parameter adjustment command; display the project files sequentially based on the parameter setting function.

[0049] The parameter setting function allows for setting parameters in the project files during firmware development for vehicle-mounted camera equipment.

[0050] Optionally, the parameter setting function can automatically identify all project files during the development process. When the user sets parameters, it obtains the project files that can be set and their numbers, and displays all project files that can be set in sequence according to their numbers.

[0051] Specifically, upon receiving a parameter adjustment command, the command is parsed, and the corresponding parameter setting function is invoked. The parameter setting function is used to obtain the project files for which parameter settings can be performed and their numbers. The project files for which parameter settings can be performed are then displayed sequentially according to their numbers.

[0052] S230: Receive the development execution instruction input by the user, and execute firmware development functions on the object to be developed according to the development execution instruction.

[0053] Among these, the development execution command can be a file parameter update command. The parameter update command can be an update command that updates the parameters of the project file in the firmware of the vehicle-mounted camera device.

[0054] Optionally, in another optional embodiment of the present invention, receiving the development execution instruction input by the user and performing firmware development functions on the object to be developed according to the development execution instruction includes:

[0055] The system receives a file parameter update command input by the user, determines the header file to be updated and the parameters to be updated corresponding to the file parameter update command, and performs firmware development functions on the header file to be updated according to the parameters to be updated if the header file to be updated exists in the project file. If the header file to be updated does not exist in the project file, the system generates the header file to be updated according to a preset file generation method and inputs the parameters to be updated into the header file to be updated.

[0056] The header file to be updated can be a header file in the project file that defines firmware functions. For example, in the firmware of an in-vehicle camera device, the header file related to shooting resolution can define the resolution of the in-vehicle camera when shooting. By modifying the header file related to shooting resolution, the resolution of the in-vehicle camera when shooting can be modified.

[0057] The parameters to be updated can be parameters that need to be modified in the header file to be updated. For example, when updating the header file related to shooting resolution in the firmware of an in-vehicle camera device, the parameters to be updated can be the resolution parameters in the header file. The shooting resolution-related parameters in the header file are updated to the resolution parameters to be updated, thereby updating the resolution of the in-vehicle camera device when shooting.

[0058] The file generation method can be a pre-defined method for creating header files.

[0059] Specifically, after receiving the file parameter update command input by the user, the command is parsed to determine the header file and parameters to be updated. The system then checks whether the header file exists. If the header file exists in the project file, the firmware development function is executed based on the parameters to be updated. If the header file does not exist in the project file, it is generated using a preset file generation method, and the parameters to be updated are input into the header file.

[0060] Optionally, in another optional embodiment of the present invention, the step of performing firmware development functions on the header file to be updated according to the parameters to be updated includes:

[0061] If the file parameters in the header file to be updated are the same as the parameters to be updated, then the firmware development function will be stopped.

[0062] If the file parameters of the header file to be updated are different from the parameters to be updated, then the header file to be updated is renamed according to the preset file generation method, and the file parameters of the header file to be updated are updated according to the parameters to be updated.

[0063] Specifically, if a header file to be updated exists in the project files, the file parameters of the header file to be updated are obtained, and it is determined whether the file parameters of the header file to be updated are the same as the parameters to be updated. If the file parameters of the header file to be updated are different from the parameters to be updated, the header file to be updated is renamed according to the preset file generation method, and the file parameters of the header file to be updated are updated to the parameters to be updated. If the file parameters of the header file to be updated are the same as the parameters to be updated, the header file to be updated does not need to be modified, and the firmware development function is stopped.

[0064] For example, in the parameter setting function, the project files for different functions are arranged by number. app_single_cam_main_capture is the project source code for capturing images with the front-view camera, and app_single_cam_capture_display is the project source code for real-time video stream transmission. In the parameter setting function, inputting the file parameter update command: 1, 1920, 1080, determines app_single_cam_main_capture, which is numbered 1, based on the file parameter update command. In the project, if a header file defining the resolution (ldc_lut_3840x2166.h) exists and needs updating, the old parameter variables are used throughout the entire project file. The main function updates the assignment of the static array variable ldc_lut from ldc_lut_3840x2166.h to the parameter to be updated: LDC_LUT_1920_1080. The macro definitions LDC_TABLE_WIDTH and LDC_TABLE_WIDTH related to the LDC input parameters are also updated to 1920u and 1080u respectively. Finally, the system displays "Parameter update complete" to the user.

[0065] The technical solution of this invention receives parameter adjustment instructions input by the user. These instructions determine the parameter setting functions for development, simplifying the development process and directly determining the direction of firmware modification, thus improving firmware development efficiency. The invention then parses the parameter adjustment instructions and invokes the parameter setting functions accordingly. Based on these parameters, the project files are displayed sequentially. The development process corresponding to the parameter setting functions is then entered, and the function determines the project files that can be modified, further simplifying the development process and improving efficiency. Finally, the invention receives development execution instructions input by the user and executes firmware development functions on the object to be developed according to these instructions. Firmware development is performed based on these execution instructions, achieving development without coding, improving the efficiency of firmware development for vehicle-mounted camera equipment, solving the technical problems of cumbersome and inefficient firmware development processes in existing technologies, meeting the demand for rapid development of vehicle-mounted firmware, simplifying the development process, and saving development costs.

[0066] Figure 3 This is a flowchart of another vehicle-mounted camera firmware development method provided by an embodiment of the present invention. The relationship between this embodiment and the above embodiments is that the firmware development function includes node debugging function, and the development execution instructions include node debugging instructions. The method for node debugging function in vehicle-mounted camera firmware development is described in detail below. Figure 3 As shown, the firmware development method for this vehicle-mounted camera device includes:

[0067] S310 receives firmware development instructions input by the user.

[0068] In this embodiment of the invention, the firmware development instructions can be node debugging instructions.

[0069] Specifically, when a user needs to debug the node interface of the vehicle camera device firmware, they can input a node debugging command; upon receiving the node debugging command input by the user, the system will recognize that the user is performing node debugging.

[0070] S320. Parse the node debugging command, and call the node debugging function according to the node debugging command; display the node interfaces sequentially based on the node debugging function.

[0071] Among them, the node debugging function can be used to debug the node interfaces in the firmware development of vehicle-mounted camera equipment.

[0072] The node interface can be any of the interfaces provided in the firmware of the vehicle-mounted camera device.

[0073] Optionally, the node debugging function can automatically identify each node interface in the main function of the vehicle camera device firmware during development. When the user performs node debugging, it obtains the node interfaces that can be debugged and their numbers in the main program, and displays all node interfaces that can be debugged in sequence according to their numbers.

[0074] Specifically, upon receiving a node debugging command, the command is parsed, the corresponding node debugging function is invoked, and the node interface that can be debugged and its number are obtained through the node debugging function. The node interfaces that can be debugged are then displayed sequentially according to their numbers.

[0075] S330: Receive the development execution command input by the user, and execute firmware development functions on the object to be developed according to the development execution command.

[0076] The development execution command can be a command to be tested. The command to be tested can be a user-input command used to select a node interface for debugging.

[0077] Optionally, in another optional embodiment of the present invention, receiving the development execution instruction input by the user and performing firmware development functions on the object to be developed according to the development execution instruction includes:

[0078] Receive the user's input test command and determine the test node based on the test command;

[0079] Obtain the test image data corresponding to each node to be tested, input each test image data into the corresponding node to be tested, and determine the node test result of the node to be tested.

[0080] The node to be tested can be the node interface selected by the user through the test command.

[0081] The node test results can be the test results output by the node debugging function. Optionally, the node test results may have different data structures and storage methods depending on the results of the node debugging function. If the node debugging function successfully tests the node interface, the node test results input by the node debugging function are stored in the node result path in the format of data + image; if the node debugging function fails to test the node interface, the output is named with timestamp + node name and output to the test error path.

[0082] Test image data can be standard image test data corresponding to each node interface. Test image data can be used as a test template for node interfaces, making it convenient for users to analyze test results themselves.

[0083] Specifically, upon receiving the user's input test command, the system responds to the user's input test command, determines the test node based on the test command, retrieves the test image data corresponding to each test node, inputs the test image data to the corresponding test node, and obtains the node test result of the test node.

[0084] For example, the user inputs a node debugging command in the development terminal. The node debugging command can be "vision-dbg". After the user inputs the node debugging command, the node debugging function corresponding to the node debugging command is invoked. The node debugging function automatically identifies the node interface in the firmware of the vehicle camera device and prints it in the development terminal in sequence according to the node interface number. The user inputs the test command to select the node number, determines the node interface to be debugged according to the test command, and obtains the test image data corresponding to each node interface. The test image data is used as a template. If the node debugging function successfully tests the node interface, the node test result input by the node debugging function is stored in the node result path in the format of data + image. If the node debugging function fails to test the node interface, the output is named with timestamp + node name and output to the test error path.

[0085] Optionally, in this embodiment of the invention, if the multiple node interfaces have an input-output relationship, that is, the output of node interface A is the input of node interface B, when acquiring the test image data of node interface B, the node test result of node interface A is used as the test image data of node interface B.

[0086] For example, taking tivxVpacVissNode and tivxVpacLdcNode as examples, the user inputs the vision-dbg command, which outputs all node interfaces in the vehicle camera device firmware and receives the input test command. The test command selects tivxVpacVissNode and tivxVpacLdcNode as the test nodes. The test item is to convert the image format and then perform distortion correction on the image. During the test, the test image data corresponding to tivxVpacVissNode is obtained and input into tivxVpacVissNode to obtain the node test result of tivxVpacVissNode. Then, the node test result of tivxVpacVissNode is used as the test image data of tivxVpacLdcNode and input into tivxVpacLdcNode to obtain the final node test result output by tivxVpacLdcNode.

[0087] The technical solution of this invention receives node debugging instructions input by the user. These instructions determine the node debugging function to be developed, simplifying the development process, directly determining the direction of firmware modification, and improving firmware development efficiency. The invention then parses the node debugging instructions and invokes the node debugging function accordingly. Based on the node debugging function, the invention sequentially displays the node interfaces. It enters the development process corresponding to the node debugging function, invoking the function to determine the node interfaces that can be tested, further simplifying the development process and improving efficiency. Finally, it receives development execution instructions input by the user and executes firmware development functions on the object to be developed according to these instructions. This firmware development based on development execution instructions achieves development without coding, improving the efficiency of firmware development for automotive camera equipment. It solves the technical problems of cumbersome and inefficient firmware development processes in existing automotive camera equipment, meeting the demand for rapid development of automotive firmware, simplifying the development process, and saving development costs.

[0088] Figure 4 This is a flowchart of another vehicle-mounted camera firmware development method provided by an embodiment of the present invention. The relationship between this embodiment and the above embodiments is that the firmware development function includes a file compilation function; the development execution instructions include firmware compilation instructions; the method for compiling project files in vehicle-mounted camera firmware development is described in detail, such as... Figure 4 As shown, the firmware development method for this vehicle-mounted camera device includes:

[0089] S410 receives firmware development instructions input by the user.

[0090] In this embodiment of the invention, the firmware development instructions may be firmware compilation instructions.

[0091] Specifically, when a user needs to compile the project file of the vehicle camera device firmware, they input a firmware compilation command; upon receiving the firmware compilation command input by the user, the system recognizes that the user is requesting firmware compilation of the project file.

[0092] S420. Parse the firmware compilation instructions, and call the file compilation function according to the firmware compilation instructions; display the project files sequentially based on the file compilation function.

[0093] The file compilation function can be used to compile project files in the firmware development of vehicle-mounted camera equipment.

[0094] Optionally, the file compilation function can automatically identify the project files included in the firmware of the vehicle camera device during the development process. When the user compiles the file, it can obtain all the project files that can be compiled and display them in order of their file numbers.

[0095] Specifically, upon receiving a firmware compilation command, the system parses the firmware compilation command, calls the file compilation function corresponding to the firmware compilation command, obtains the project files that can be compiled and their numbers through the file compilation function, and displays the project files that can be compiled in sequence according to the project file numbers.

[0096] S430: Receive the development execution instruction input by the user, and execute firmware development functions on the object to be developed according to the development execution instruction.

[0097] The development execution command can be a compilation command. A compilation command can be a user-input command used to select a project file for compilation.

[0098] Optionally, in another optional embodiment of the present invention, receiving the development execution instruction input by the user and performing firmware development functions on the object to be developed according to the development execution instruction includes:

[0099] The project file to be compiled is determined according to the compilation instructions; the project file to be compiled is traversed to determine the compilation framework of the project file to be compiled; the compilation framework is identified to determine the compilation target platform; the compilation script is called to compile the project file to be compiled according to the compilation target platform to determine the executable file corresponding to the project file to be compiled.

[0100] The project file to be compiled can be a project file selected by the user through the compilation command. Optionally, when selecting a project file to be compiled through the compilation command, the user can either enter the project file number to select the project file as the project file to be compiled, or the user can enter all compilation commands to select all project files as the project files to be compiled.

[0101] Among them, the compilation framework can be a framework tool that compiles the source code of the project file into machine code.

[0102] The target platform for compilation can be the platform on which the source code of the project files is compiled into an executable file for that platform. Optionally, during the compilation process, the compiler will generate an executable file for the target platform based on its characteristics and limitations. The same executable file may exhibit different performance and reliability characteristics on different target platforms.

[0103] Among them, the compilation script can be a tool for compiling the source code of the project file.

[0104] Specifically, the compiler receives the compilation instructions input by the user, determines the project file to be compiled selected by the user, obtains the project file to be compiled, traverses the project file to be compiled, determines the compilation framework corresponding to the project file to be compiled, identifies the compilation framework corresponding to the project file to be compiled, determines the compilation target platform of the project file to be compiled, calls the compilation script to compile the project file to be compiled, and outputs the executable file corresponding to the compilation target platform.

[0105] For example, taking `app_single_cam_main_capture` as an example, when the user inputs the number of the project file corresponding to `app_single_cam_main_capture`, the system enters `app_single_cam_main_capture`, iterates through the `concerto.mak` configuration file in the `app_single_cam_main_capture` directory, determines the compilation framework and target platform "vx_app_single_cam" corresponding to `app_single_cam_main_capture`, and then calls...

[0106] The compilation script for app_single_cam_main_capture uses the CLANG command `make vx_app_single_cam CLANG_USE=1` to compile app_single_cam_main_capture and output the executable file corresponding to "vx_app_single_cam".

[0107] The technical solution of this invention receives firmware compilation instructions input by the user. These instructions determine the file compilation function for development, simplifying the development process and directly identifying the firmware compilation target, thus improving firmware development efficiency. The invention then parses the firmware compilation instructions and calls the file compilation function accordingly. Based on the file compilation function, the invention sequentially displays the project files. It enters the development process corresponding to the file compilation function, calling the file compilation function to determine the project files that can be tested, further simplifying the development process and improving efficiency. Finally, it receives development execution instructions input by the user and executes firmware development functions on the object to be developed according to these instructions. This firmware development based on development execution instructions achieves development without code, improving the efficiency of firmware development for automotive camera devices. It solves the technical problems of cumbersome and inefficient firmware development processes in existing automotive camera devices, meeting the demand for rapid development of automotive firmware, simplifying the development process, and saving development costs.

[0108] Figure 5 This is a schematic diagram of the structure of a firmware development device for an in-vehicle camera provided in an embodiment of the present invention. Figure 5 As shown, the device includes: a development function selection module 510, an instruction parsing module 520, and a firmware development module 530, wherein,

[0109] The development function selection module 510 is used to receive firmware development instructions input by the user;

[0110] The instruction parsing module 520 is used to parse the firmware development instructions and determine the firmware development functions and objects to be developed called by the firmware development instructions; wherein, the objects to be developed include project files and node interfaces;

[0111] Firmware development module 530 is used to receive development execution instructions input by the user and perform firmware development functions on the object to be developed according to the development execution instructions.

[0112] The technical solution of this invention receives firmware development instructions input by the user. These instructions determine the firmware function to be developed, eliminating the need for staff to search through large amounts of code and improving firmware development efficiency. The instructions are parsed to determine the firmware development function invoked and the object to be developed. The object to be developed includes project files and node interfaces. Parsing the firmware development instructions allows entry into the development process corresponding to the firmware development function, calling the object to be developed that can be developed by the firmware development function, further simplifying the development process and improving efficiency. Finally, the invention receives development execution instructions input by the user and executes the firmware development function on the object to be developed according to these instructions. Firmware development based on development execution instructions achieves development without code, improving the efficiency of firmware development for automotive camera equipment. This solves the technical problem of cumbersome and inefficient firmware development processes in existing automotive camera equipment, meeting the need for rapid development of automotive firmware, simplifying the development process, and saving development costs.

[0113] Optionally, the firmware development instructions include at least one of parameter adjustment instructions, node debugging instructions, and firmware compilation instructions.

[0114] Optionally, the instruction parsing module is specifically used for:

[0115] Parse the parameter adjustment command and call the parameter setting function according to the parameter adjustment command;

[0116] The project files are displayed sequentially based on the parameter settings.

[0117] Optionally, the firmware development module is specifically used for:

[0118] Receive a file parameter update instruction input by the user, and determine the header file to be updated and the parameters to be updated corresponding to the file parameter update instruction;

[0119] If the header file to be updated exists in the project file, the firmware development function is executed on the header file to be updated according to the parameters to be updated.

[0120] If the header file to be updated does not exist in the project file, the header file to be updated is generated according to a preset file generation method, and the update parameters are input into the header file to be updated.

[0121] Optionally, the firmware development module is further used for:

[0122] If the file parameters in the header file to be updated are the same as the parameters to be updated, then the firmware development function will be stopped.

[0123] If the file parameters of the header file to be updated are different from the parameters to be updated, then the header file to be updated is renamed according to the preset file generation method, and the file parameters of the header file to be updated are updated according to the parameters to be updated.

[0124] Optionally, the instruction parsing module is further used for:

[0125] Parse the node debugging command and invoke the node debugging function according to the node debugging command;

[0126] The node interfaces are displayed sequentially based on the node debugging function.

[0127] Optionally, the firmware development module is further used for:

[0128] Receive the user's input test command and determine the test node based on the test command;

[0129] Obtain the test image data corresponding to each node to be tested, input each test image data into the corresponding node to be tested, and determine the node test result of the node to be tested.

[0130] Optionally, the instruction parsing module is further used for:

[0131] The firmware compilation instructions are parsed, and the file compilation function is invoked according to the firmware compilation instructions;

[0132] The project files are displayed sequentially based on the file compilation function.

[0133] Optionally, the firmware development module is further used for:

[0134] The project file to be compiled is determined based on the compilation instructions;

[0135] Traverse the project files to be compiled to determine the compilation framework of the project files;

[0136] Identify the compilation framework and determine the target compilation platform;

[0137] The compilation script is invoked to compile the project file to be compiled according to the target compilation platform, and the executable file corresponding to the project file to be compiled is determined.

[0138] The vehicle-mounted camera firmware development apparatus provided in this embodiment of the invention can execute the vehicle-mounted camera firmware development method provided in any embodiment of the invention, and has the corresponding functional modules and beneficial effects of the method.

[0139] Figure 6A schematic diagram of an electronic device 10 that can be used to implement embodiments of the present invention is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices (e.g., helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the invention described and / or claimed herein.

[0140] like Figure 6 As shown, the electronic device 10 includes at least one processor 11 and a memory, such as a read-only memory (ROM) 12 or a random access memory (RAM) 13, communicatively connected to the at least one processor 11. The memory stores computer programs executable by the at least one processor. The processor 11 can perform various appropriate actions and processes based on the computer program stored in the ROM 12 or loaded from storage unit 18 into the RAM 13. The RAM 13 can also store various programs and data required for the operation of the electronic device 10. The processor 11, ROM 12, and RAM 13 are interconnected via a bus 14. An input / output (I / O) interface 15 is also connected to the bus 14.

[0141] Multiple components in electronic device 10 are connected to I / O interface 15, including: input unit 16, such as keyboard, mouse, etc.; output unit 17, such as various types of displays, speakers, etc.; storage unit 18, such as disk, optical disk, etc.; and communication unit 19, such as network card, modem, wireless transceiver, etc. Communication unit 19 allows electronic device 10 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0142] Processor 11 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of processor 11 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various processors running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. Processor 11 performs the various methods and processes described above, such as firmware development methods for automotive camera devices.

[0143] In some embodiments, the vehicle-mounted camera firmware development method may be implemented as a computer program tangibly contained in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program may be loaded and / or installed on electronic device 10 via ROM 12 and / or communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the vehicle-mounted camera firmware development method described above may be performed. Alternatively, in other embodiments, processor 11 may be configured to execute the vehicle-mounted camera firmware development method by any other suitable means (e.g., by means of firmware).

[0144] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0145] Computer programs used to implement the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, such that when executed by the processor, the computer programs cause the functions / operations specified in the flowcharts and / or block diagrams to be performed. The computer programs may be executed entirely on a machine, partially on a machine, or as a standalone software package, partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0146] In the context of this invention, a computer-readable storage medium can be a tangible medium that may contain or store a computer program for use by or in conjunction with an instruction execution system, apparatus, or device. A computer-readable storage medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination thereof. Alternatively, a computer-readable storage medium may be a machine-readable signal medium. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof.

[0147] To provide interaction with a user, the systems and techniques described herein can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the electronic device. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0148] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or computing systems that include middleware components (e.g., application servers), or computing systems that include frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), blockchain networks, and the Internet.

[0149] A computing system can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and VPS services, such as high management difficulty and weak business scalability.

[0150] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this invention can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this invention can be achieved, and this is not limited herein.

[0151] Example 5

[0152] This embodiment provides a computer-readable storage medium storing a computer program thereon. When executed by a processor, the program implements the steps of the vehicle-mounted camera firmware development method provided in any embodiment of the present invention. The method includes:

[0153] Receive firmware development instructions from the user;

[0154] The firmware development instructions are parsed to determine the firmware development functions called by the instructions and the objects to be developed; wherein, the objects to be developed include project files and node interfaces;

[0155] Receive development execution instructions input by the user, and perform firmware development functions on the object to be developed according to the development execution instructions.

[0156] The computer storage medium of this invention can be any combination of one or more computer-readable media. A computer-readable medium can be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium can be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples (a non-exhaustive list) of computer-readable storage media include: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this document, a computer-readable storage medium can be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device.

[0157] Computer-readable signal media may include data signals propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. Computer-readable signal media may also be any computer-readable medium other than computer-readable storage media, capable of sending, propagating, or transmitting programs for use by or in connection with an instruction execution system, apparatus, or device.

[0158] Program code contained on a computer-readable medium may be transmitted using any suitable medium, including but not limited to: wireless, wire, optical fiber, RF, etc., or any suitable combination thereof.

[0159] Computer program code for performing the operations of this invention can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, as well as conventional procedural programming languages—such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0160] Those skilled in the art will understand that the modules or steps of the present invention described above can be implemented using general-purpose computing devices. They can be centralized on a single computing device or distributed across a network of multiple computing devices. Optionally, they can be implemented using computer-executable program code, thereby allowing them to be stored in a storage device for execution by a computing device, or they can be fabricated as separate integrated circuit modules, or multiple modules or steps can be fabricated as a single integrated circuit module. Thus, the present invention is not limited to any particular combination of hardware and software.

[0161] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this invention can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this invention can be achieved, and this is not limited herein.

[0162] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. A firmware development method for a vehicle-mounted camera device, characterized in that, include: Receive firmware development instructions from the user; The firmware development instructions are parsed to determine the firmware development functions called by the instructions and the objects to be developed; wherein, the objects to be developed include project files and node interfaces; The system receives development execution instructions input by the user and performs firmware development functions on the object to be developed according to the development execution instructions; the firmware development instructions include at least one of parameter adjustment instructions, node debugging instructions, and firmware compilation instructions. The firmware development function includes parameter setting functionality; parsing the firmware development instructions to determine the firmware development functions called by the firmware development instructions and the objects to be developed includes: Parse the parameter adjustment command and call the parameter setting function according to the parameter adjustment command; The project files are displayed sequentially based on the parameter settings function; The development execution instructions include file parameter update instructions; receiving user-inputted development execution instructions and executing firmware development functions on the object to be developed according to the development execution instructions includes: Receive a file parameter update instruction input by the user, and determine the header file to be updated and the parameters to be updated corresponding to the file parameter update instruction; If the header file to be updated exists in the project file, the firmware development function is executed on the header file to be updated according to the parameters to be updated. If the header file to be updated does not exist in the project file, the header file to be updated is generated according to a preset file generation method, and the update parameters are input into the header file to be updated.

2. The method according to claim 1, characterized in that, The step of performing firmware development functions on the header file to be updated based on the parameters to be updated includes: If the file parameters in the header file to be updated are the same as the parameters to be updated, then the firmware development function will be stopped. If the file parameters of the header file to be updated are different from the parameters to be updated, then the header file to be updated is renamed according to the preset file generation method, and the file parameters of the header file to be updated are updated according to the parameters to be updated.

3. The method according to claim 1, characterized in that, The firmware development functionality includes node debugging functionality; parsing the firmware development instructions to determine the firmware development functions invoked by the firmware development instructions and the objects to be developed includes: Parse the node debugging command and invoke the node debugging function according to the node debugging command; The node interfaces are displayed sequentially based on the node debugging function.

4. The method according to claim 3, characterized in that, The development execution instructions include instructions to be tested; receiving development execution instructions input by the user, and executing firmware development functions on the object to be developed according to the development execution instructions, includes: Receive the user's input test command and determine the test node based on the test command; Obtain the test image data corresponding to each node to be tested, input each test image data into the corresponding node to be tested, and determine the node test result of the node to be tested.

5. The method according to claim 1, characterized in that, The firmware development function includes file compilation functionality; parsing the firmware development instructions to determine the firmware development functions invoked by the firmware development instructions and the objects to be developed includes: The firmware compilation instructions are parsed, and the file compilation function is invoked according to the firmware compilation instructions; The project files are displayed sequentially based on the file compilation function.

6. The method according to claim 4, characterized in that, The development execution instructions include instructions to be compiled; receiving user-inputted development execution instructions and executing firmware development functions on the object to be developed according to the development execution instructions includes: The project file to be compiled is determined based on the compilation instructions; Traverse the project files to be compiled to determine the compilation framework of the project files; Identify the compilation framework and determine the target compilation platform; The compilation script is invoked to compile the project file to be compiled according to the target compilation platform, and the executable file corresponding to the project file to be compiled is determined.

7. A firmware development device for vehicle-mounted camera equipment, characterized in that, include: A development function selection module is used to receive firmware development instructions input by the user; The instruction parsing module is used to parse the firmware development instructions and determine the firmware development functions and objects to be developed called by the firmware development instructions; wherein, the objects to be developed include project files and node interfaces; The firmware development module is used to receive development execution instructions input by the user and execute firmware development functions on the object to be developed according to the development execution instructions; The firmware development instructions include at least one of parameter adjustment instructions, node debugging instructions, and firmware compilation instructions; The instruction parsing module is specifically used for: Parse the parameter adjustment command and call the parameter setting function according to the parameter adjustment command; The project files are displayed sequentially based on the parameter settings function; The firmware development module is specifically used for: Receive a file parameter update instruction input by the user, and determine the header file to be updated and the parameters to be updated corresponding to the file parameter update instruction; If the header file to be updated exists in the project file, the firmware development function is executed on the header file to be updated according to the parameters to be updated. If the header file to be updated does not exist in the project file, the header file to be updated is generated according to a preset file generation method, and the update parameters are input into the header file to be updated.

Images