Adding Custom Interrupt Vectors to 8051 CPU in Keil Debugger Simulation

Interrupt Vector Table Modification Challenges in 8051 Simulation

The core issue revolves around the modification of the interrupt vector table for an 8051 CPU within the Keil debugger environment. The original interrupt vectors are predefined and hardcoded within the 8051 architecture, and the user aims to add custom interrupt vectors for simulation purposes. The challenge lies in integrating these new vectors into the Keil debugger, which requires modifications to both the hardware description (VHDL) and the software environment (Keil). The user has identified that the interrupt vectors are not directly accessible through the standard Keil device database or associated DLL files (S8051.DLL, TP51.DLL, DP51.DLL), making it unclear how to proceed with the integration.

The 8051 architecture uses a fixed interrupt vector table located at the beginning of the memory space (starting at address 0x0000). Each interrupt vector occupies 8 bytes, and the table typically supports up to 5-6 standard interrupts. Adding custom interrupts requires extending this table, which is not natively supported by the Keil debugger or the 8051 architecture. The user has attempted to explore the Keil device database, specifically the MON and SIM variables, but has not found a clear method to map custom interrupt vectors to the debugger.

The hardware side of the problem involves modifying the state machine in VHDL to accommodate the new interrupts. However, the software side requires the debugger to recognize these new vectors during simulation. This dual requirement highlights the complexity of the issue, as it spans both hardware and software domains. The user’s attempt to use a resource hacker program to inspect the DLL files suggests a deep dive into the debugger’s internal workings, but this approach has not yielded actionable insights.

Keil Debugger Limitations and VHDL State Machine Integration

The primary cause of the issue stems from the inherent limitations of the Keil debugger when dealing with custom interrupt vectors. The Keil debugger is designed to work with predefined interrupt vectors for the 8051 architecture, and it does not provide a straightforward mechanism to add or modify these vectors. The MON and SIM variables in the Keil device database are likely related to monitoring and simulation functionalities, but they do not expose the necessary interfaces for interrupt vector customization.

Another contributing factor is the lack of documentation or examples for extending the interrupt vector table in the Keil environment. The 8051 architecture itself does not support dynamic modification of the interrupt vector table, which means any changes must be carefully integrated into both the hardware and software toolchains. The user’s attempt to inspect the DLL files indicates a gap in the available tools and APIs for this purpose.

The VHDL state machine modifications on the hardware side introduce additional complexity. While the state machine can be updated to handle new interrupts, these changes must be synchronized with the software environment to ensure proper simulation. The absence of a clear method to map custom interrupt vectors to the Keil debugger creates a disconnect between the hardware and software implementations. This disconnect is further exacerbated by the debugger’s reliance on predefined configurations, which do not account for user-defined extensions.

Custom Interrupt Vector Integration in Keil Debugger Simulation

To address the issue of adding custom interrupt vectors to the 8051 CPU in the Keil debugger simulation, a multi-step approach is required. This approach involves modifications to both the hardware description (VHDL) and the software environment (Keil), as well as the use of custom scripts or tools to bridge the gap between the two.

Step 1: Extending the Interrupt Vector Table in VHDL

The first step is to extend the interrupt vector table in the VHDL description of the 8051 CPU. This involves modifying the state machine to support additional interrupt vectors. The new vectors must be placed in a memory region that does not conflict with the existing vectors or other critical memory areas. For example, if the original interrupt vector table ends at address 0x002F, the new vectors can be placed starting at address 0x0030.

-- Example VHDL code to extend the interrupt vector table
process (clk, reset)
begin
    if reset = '1' then
        interrupt_vector_table <= (others => (others => '0'));
    elsif rising_edge(clk) then
        -- Original interrupt vectors
        interrupt_vector_table(0) <= "00000000"; -- Reset vector
        interrupt_vector_table(1) <= "00000001"; -- External interrupt 0
        interrupt_vector_table(2) <= "00000010"; -- Timer 0 overflow
        interrupt_vector_table(3) <= "00000011"; -- External interrupt 1
        interrupt_vector_table(4) <= "00000100"; -- Timer 1 overflow
        interrupt_vector_table(5) <= "00000101"; -- Serial port interrupt

        -- Custom interrupt vectors
        interrupt_vector_table(6) <= "00000110"; -- Custom interrupt 1
        interrupt_vector_table(7) <= "00000111"; -- Custom interrupt 2
        -- Add more custom vectors as needed
    end if;
end process;

Step 2: Modifying the Keil Debugger Configuration

The next step is to modify the Keil debugger configuration to recognize the new interrupt vectors. This can be achieved by creating a custom device database entry for the 8051 CPU. The MON and SIM variables in the device database can be used to specify the memory locations of the new interrupt vectors. However, this requires a deep understanding of the Keil debugger’s internal structure and may involve reverse-engineering the existing DLL files.

To create a custom device database entry, follow these steps:

1. Locate the Keil Device Database: The device database is typically located in the Keil installation directory under the UV4 folder. The file is usually named DB51.INI or similar.

2. Add a New Entry: Create a new entry in the device database for the modified 8051 CPU. Specify the memory locations of the new interrupt vectors using the MON and SIM variables.

[Custom_8051]
MON=0x0030
SIM=0x0038

3. Update the Debugger Configuration: Modify the Keil project settings to use the custom device database entry. This can be done through the Options for Target dialog in Keil.

Step 3: Using Custom Scripts to Bridge Hardware and Software

To ensure that the hardware and software modifications are properly synchronized, custom scripts can be used to automate the process of updating the interrupt vector table in the Keil debugger. These scripts can be written in a scripting language such as Python or Perl and can interact with the Keil debugger through its command-line interface (CLI).

# Example Python script to update the interrupt vector table in Keil
import subprocess

# Define the new interrupt vectors
new_vectors = {
    0x0030: "00000110",  # Custom interrupt 1
    0x0038: "00000111",  # Custom interrupt 2
}

# Update the Keil debugger configuration
for address, value in new_vectors.items():
    subprocess.run(["C:\\Keil\\UV4\\UV4.exe", "-f", "update_vector_table.ini", f"-MON={address}", f"-SIM={value}"])

Step 4: Validating the Custom Interrupt Vectors

Once the modifications are complete, the final step is to validate the custom interrupt vectors in the Keil debugger. This involves running a simulation and verifying that the new interrupts are correctly recognized and handled by the debugger. The validation process should include the following steps:

1. Load the Modified VHDL Design: Ensure that the modified VHDL design is loaded into the simulation environment.

2. Set Breakpoints on Custom Interrupts: Set breakpoints on the custom interrupt vectors to verify that they are correctly triggered during simulation.

3. Monitor the Interrupt Handling: Use the Keil debugger’s monitoring tools to observe the behavior of the custom interrupts and ensure that they are handled as expected.

4. Debug and Iterate: If any issues are identified during validation, use the Keil debugger’s debugging tools to diagnose and resolve the problems. This may involve further modifications to the VHDL design or the Keil debugger configuration.

Conclusion

Adding custom interrupt vectors to the 8051 CPU in the Keil debugger simulation environment is a complex task that requires careful coordination between hardware and software modifications. By extending the interrupt vector table in VHDL, modifying the Keil debugger configuration, using custom scripts to bridge the gap, and validating the results, it is possible to achieve the desired functionality. However, this process requires a deep understanding of both the 8051 architecture and the Keil debugger, as well as the ability to work with low-level tools and APIs. With the right approach, the integration of custom interrupt vectors can be successfully accomplished, enabling more advanced simulation and debugging capabilities for the 8051 CPU.