Shared memory architecture

• US 8,495,601 B2
• Filed: 06/09/2010
• Issued: 07/23/2013
• Est. Priority Date: 06/09/2010
• Status: Active Grant

• Current Assignee: Lear Corporation
• Original Assignee: Lear Corporation
• Inventors: Lincer, Stanislav, Alari, David Gamez, Aymami, Jordi Moreno, Fbregas, Antoni Ferr
• Primary Examiner(s): DAO, THUY CHAN
• Application Number:
  US12/796,833
• Publication Number:
  US 20110307669A1
• Time in Patent Office: 1,140 Days
• Field of Search: None
• US Class Current: 717/145
• CPC Class Codes: B60L 2240/545 Temperature
• CPC Class Codes: B60L 2240/549 Current
• CPC Class Codes: B60L 3/12 Recording operating variables ; Monitoring of operating variables
• CPC Class Codes: G01R 31/382 Arrangements for monitoring battery or accumulator variables, e.g. SoC
• CPC Class Codes: G06F 12/00 Accessing, addressing or allocating within memory systems or architectures digital input from, or digital output to record carriers, e.g. to disk storage units, G06F3/06
• CPC Class Codes: H01M 10/48 Accumulators combined with arrangements for measuring, testing or indicating the condition of cells, e.g. the level or density of the electrolyte constructional details of current conducting connections for detecting conditions inside cells or batteries, e.g. details of voltage sensing terminals, H01M50/569
• CPC Class Codes: Y02E 60/10 Energy storage using batteries
• CPC Class Codes: Y02T 10/70 Energy storage systems for electromobility, e.g. batteries

Abstract

A shared memory architecture is disclosed to support operations associated with executing shared functions from a shared memory space in such a manner that separate pieces of software can execute the shared functions.

Claims

1. For use with a battery monitoring system (BMS) having an application operable to measure current flow to a vehicle battery and a launcher operable to enable drivers utilized by the application, the BMS having a non-volatile memory and a volatile memory for storing code, the BMS being included within a vehicle having a vehicle bus, the method comprising:

storing application code for application functions capable of being called by the application to an application memory block of the non-volatile memory, including first application code sufficient to determine current flow to the vehicle battery;

storing launcher code for launcher functions capable of being called by the launcher to a launcher memory block of the non-volatile memory, including first launcher code sufficient to initialize the BMS, the BMS requiring initialization prior to the application determining current flow to the vehicle battery;

storing shared code for shared functions capable of being called by the launcher and application to a shared memory block of the non-volatile memory, including first communication code sufficient for use by both of the launcher and application when executing communication related operations over the vehicle bus;

storing one shared function pointer within the shared memory block for each one of the shared functions, each shared function pointer being stored at a location within the shared memory block and pointing to an another location within the shared memory block storing shared code for shared functions, including storing a first shared function pointer that points to the another location storing the first communication code;

re-compiling the shared code such that at least the same shared functions remain available after re-compiling, wherein each shared function pointer is stored at the same location within the shared memory block after the re-compiling.

2. The method of claim 1 further comprising re-compiling the shared memory code such that an amount of memory required to store the shared code for at least one of the shared functions increases in size after the re-compiling.

3. The method of claim 2 further comprising dedicating a first amount of memory within the shared memory block to store the shared function pointers before the re-compiling and dedicating the same first amount of memory within the shared memory is block to store the shared function pointers after the re-compiling.

4. The method of claim 1 further comprising:

storing launcher pointers to launcher callback functions in a shared callback function memory block of the volatile memory while the launcher is operational, the launcher pointers pointing to at least one launcher callback function to be executed for each one of the shared functions; and

storing application pointers to application callback functions in the shared callback function memory block of the volatile memory while the application is operational, the application pointers pointing to at least one application callback function to be executed for each one of shared functions.

5. The method of claim 4 further comprising assigning each one of the shared functions a reference label, including assigning each of the shared function pointers, the launcher pointers and the application pointers the reference label assigned to the corresponding shared function.

6. The method of claim 5 further comprising arranging the storing of the launcher pointers and the application pointers within the shared callback function memory block according to the label assigned thereto such that the launcher pointers and the application pointers having the same reference label are stored at the same location of the shared callback function memory block.

7. The method of claim 4 further comprising writing over each one of the launcher pointers when storing the application pointers to the shared callback memory block.

8. The method of claim 1 further comprising the first communication code being loaded from the non-volatile memory to the volatile memory when the application desires to communicate the current flow over the vehicle bus, including a central processing unit (CPU) identifying the another location at which the first communication code is stored within the non-volatile memory by reading the first shared function pointer, the CPU identifying the first shared function pointer by reading the first application code, the first application code specifying a first pointer that points to the location at which the first shared pointer is stored within the non-volatile memory.

9. A method for performing battery monitoring with use of a battery monitoring system (BMS), the BMS having:

a non-volatile, application memory block having application code for an application operable to execute battery monitoring related functions, the application code including a first pointer to a transmit data function pointer;

a non-volatile, launcher memory block having launcher code for a launcher operable for initializing the BMS, the launcher code including a second pointer to the transmit data function pointer;

a non-volatile, shared memory block having the transmit data function pointer pointing to a storage location within the shared memory block for transmit data code associated with a transmit data function; and

a central processing unit (CPU) configured to facilitate executing functions associated with the application and the launcher, the method comprising;

calling the launcher code from the launcher memory block in order to execute the launcher to initialize the BMS, including executing the transmit data function by processing the first pointer in order to call the transmit data function pointer and then processing the transmit data function pointer in order to call the transmit data code;

subsequently calling the application code from the application memory block in order to execute the battery monitoring function, including executing the transmit data function by processing the second pointer in order to call the transmit data function pointer and then processing the transmit data function pointer in order to call the transmit data code; and

subsequently to calling the launcher code, re-compiling the transmit data code such that at least a portion of the transmit data code is stored a different location of the shared memory block, including storing the transmit data pointer at a same location of the shared memory block as prior to the re-compiling.

10. The method of claim 9 further comprising the first point and the second point pointing to a same location of the shared memory block used to store code associated with the transmit data pointer.

11. The method of claim 9 further comprising the launcher executing the transmit data function in order to transmit a BMS initialization message over a vehicle bus and the application executing the battery monitoring function to transmit a battery current message over the vehicle bus.

12. A battery monitoring system (BMS) having an application operable to measure current flow to a vehicle battery and a launcher operable to enable drivers utilized by the application, the BMS being included within a vehicle having a vehicle bus, the BMS having a non-volatile memory and a volatile memory for storing code to perform a the method of:

storing application code for application functions capable of being called by the application to an application memory block of the non-volatile memory, including first application code sufficient to determine current flow to the vehicle battery;

storing launcher code for launcher functions capable of being called by the launcher to a launcher memory block of the non-volatile memory, including first launcher code sufficient to initialize the BMS, the BMS requiring initialization prior to the application determining current flow to the vehicle battery;

storing shared code for shared functions capable of being called by the launcher and application to a shared memory block of the non-volatile memory, including first communication code sufficient for use by both of the launcher and application when executing communication related operations over the vehicle bus;

storing one shared function pointer within the shared memory block for each one of the shared functions, each shared function pointer being stored at a location within the shared memory block and pointing to an another location within the shared memory block storing shared code for shared functions, including storing a first shared function pointer that points to the another location storing the first communication code; and

re-compiling the shared code such that at least the same shared functions remain available after re-compiling, wherein each shared function pointer is stored at the same location within the shared memory block after the re-compiling.

13. The battery monitoring system of claim 12 further comprising a volatile memory storing a plurality of callback pointers, each one of the callback pointers being associated with each one of the shared functions.

14. The battery monitoring system of claim 13 wherein the callback pointers point to (i) callback function code stored within the first application memory block when the first application is executing and (ii) callback function code stored within the second application memory block when the second application is executing.

15. The battery monitoring system of claim 14 wherein the volatile memory does not simultaneously store pointers to callback function code stored within the first application memory block and the second application memory block.

16. The battery monitoring system of claim 13 wherein the callback pointers are stored in fixed locations of the volatile memory such that the callback pointers for each of the shared functions are stored at the same location for each of the first and second applications.

17. The battery monitoring system of claim 16 wherein the code stored in the shared memory block for each of the shared functions includes a pointer to the fixed location of the one of the callback pointers associated with each shared function.

18. The battery monitoring system of claim 12 wherein the fixed memory locations store the same one of the shared function pointers following each compiling of the shared code when at least the same shared functions are still available.

19. The battery monitoring system of claim 18 wherein an amount of memory required to store the shared code for at least one of the shared functions increases in size following compiling and wherein each of the shared function pointers remain in the same one of the fixed memory locations after the compiling.