Explaining How HiSilicon's HAL Reduces Development Cycles

HiSilicon's Hardware Abstraction Layer (HAL) is a critical software layer. It decouples applications from specific hardware details. This separation is the primary mechanism for Accelerating Time to Market. The HAL allows an OEM to write portable code without deep knowledge of the underlying hardware or Board Support Package (BSP). An OEM can then reuse software across different hardware platforms, making the BSP and HAL a powerful combination for developers.

Key Takeaways

• HiSilicon's HAL makes coding easier. It turns complex hardware tasks into simple function calls. This helps developers build things faster.
• The SDK gives developers ready-made tools and code. This means they can start building applications right away. It saves time and money.
• Special drivers help hardware work at its best. They let powerful parts like GPUs do their job. This makes devices run much faster.
• The HAL helps companies update products easily. They can use new hardware without rewriting all their software. This saves effort and speeds up upgrades.

Simplifying Development with HAL Abstraction

HiSilicon's software architecture fundamentally simplifies the development process. It achieves this by abstracting complex hardware interactions into a manageable set of high-level functions. This approach allows an OEM to focus on creating value-added features instead of getting lost in low-level hardware details. The result is a more efficient and streamlined workflow from concept to production.

From Registers to APIs

Traditionally, developers wrote code that directly manipulated hardware registers. This process is tedious, error-prone, and requires deep knowledge of the specific hardware. The HiSilicon HAL eliminates this complexity. It provides a library of standardized Application Programming Interfaces (APIs) that act as a middle layer.

An OEM developer no longer needs to understand the intricate configuration of every hardware component. Instead, they call a simple function. The HAL handles the low-level communication with the Board Support Package (BSP) and hardware.

This abstraction covers a wide range of peripherals. Developers can control components like timers, GPIO, and UART using consistent API calls. The HAL effectively hides the underlying hardware differences, making the code cleaner and more maintainable. This layer sits on top of the BSP, creating a powerful and portable development environment.

Faster Prototyping and Iteration

This shift from registers to APIs directly accelerates prototyping and product iteration. With the HAL, an OEM can build and test application logic much faster. The decoupling of software from the physical hardware provides several key advantages for rapid development:

• Isolated Component Development: Teams can develop and test firmware modules independently of the final hardware.
• Supply Chain Flexibility: The HAL makes it easier to swap microcontrollers or other components if supply issues arise, as the application code remains largely unchanged.
• Enhanced Code Reusability: An OEM can leverage existing software across multiple projects, even with a different BSP, significantly reducing development time.

This portability allows developers to quickly move an application to new hardware or even a simulated environment for testing. The HAL provides the foundation for a flexible and efficient development cycle.

SDK and Drivers: Accelerating Time to Market

While the HAL provides a stable foundation, the Software Development Kit (SDK) and dedicated drivers are the engines for accelerating time to market. HiSilicon packages its software into a complete ecosystem. This ecosystem gives an OEM a powerful head start. It moves development beyond basic hardware interaction into rapid, feature-rich application building. This comprehensive approach is a key strategy for accelerating time to market.

Using the SDK for Rapid Application Building

The HiSilicon SDK is a complete, out-of-the-box development environment. It bundles libraries, pre-compiled binaries, and crucial development tools. An OEM does not need to spend weeks setting up a project. The SDK provides a ready-made framework built on top of the HAL and BSP. This immediate setup is a major factor in accelerating time to market.

The SDK streamlines the entire development workflow for an OEM. It offers significant advantages that reduce complexity and effort.

• Faster Development: Pre-written code modules and libraries allow developers to integrate features efficiently, saving time and accelerating development.
• Cost Savings: The SDK significantly reduces developer hours and the long-term cost of maintaining custom code.
• Improved Quality: It includes pre-tested and optimized code. This practice reduces bugs and avoids hardware compatibility issues tied to the BSP.
• Seamless Integration: The SDK is designed for easy integration with specific platforms and the underlying Board Support Package.

For example, the SDK often includes sample code for common functions. A developer can see a practical implementation for initializing a peripheral, like an infrared (IR) receiver, and adapt it for their project.

// Sample code for initializing an IR receiver
package main

import (
    "fmt"
    hiapi "github.com/leandrotsampa/hisilicon"
)

func main() {
    // Initialize the IR module
    hiapi.HI_UNF_IR_Init()
    // Enable the IR key
    hiapi.HI_UNF_IR_EnableRepKey(hiapi.HI_TRUE)

    for {
        // Get the key value
        if key, err := hiapi.HI_UNF_IR_GetValueWithProtocol(200); err == nil {
            fmt.Printf("Received Key: %#x\n", key.Lower)
        }
    }
    // De-initialize the IR module
    hiapi.HI_UNF_IR_DeInit()
}

This approach, combined with tools like ISP tuning utilities for image sensors, empowers an OEM to build and test applications quickly. It makes the SDK an essential tool for accelerating time to market.

Leveraging Vendor Drivers for Hardware Acceleration

Modern HiSilicon SoCs contain specialized hardware accelerators for intensive tasks. These include Graphics Processing Units (GPUs), Digital Signal Processors (DSPs), and Neural Processing Units (NPUs). However, this powerful hardware is only effective if the software can access it. This is where the vendor driver plays a critical role.

A vendor driver is a highly specialized piece of software. It acts as the exclusive translator between the operating system (via the HAL) and a specific hardware component. The driver unlocks the full potential of the hardware. Without the correct driver, the system cannot use these powerful accelerators and must fall back to the less efficient CPU. This makes the driver a vital link in the chain from the BSP to the application.

The primary benefit for an OEM is offloading complex computations from the main processor. This process, known as hardware acceleration, dramatically improves performance and efficiency. It is fundamental to accelerating time to market for advanced products.

HiSilicon provides optimized drivers that enable the system to leverage this hardware for specific jobs. For instance, a dedicated driver can offload complex cryptography operations to security accelerators. This frees up the CPU for other tasks. The driver ensures the hardware is used correctly, managing its power and resources efficiently. This synergy between the driver and the hardware is essential for building high-performance devices.

Strategic Advantages for Long-Term Growth

Adopting HiSilicon's software architecture offers more than just immediate project acceleration. It provides a strategic framework for sustainable growth and future innovation. This foundation allows an OEM to adapt to market changes and scale its operations efficiently.

Streamlining Migration to New SoCs

Migrating a product to a new System-on-Chip (SoC) is often a complex and costly process. The HiSilicon HAL architecture dramatically simplifies this transition. It provides a stable and consistent API layer that separates application code from the underlying hardware. An OEM can develop software that is not tied to a specific hardware configuration.

When a new SoC is introduced, the core application logic remains largely unchanged. Development efforts can focus on adapting the Board Support Package (BSP) to the new hardware. This modularity offers several key benefits:

• Reduced Rework: An OEM avoids rewriting entire applications for each hardware revision.
• Faster Upgrades: Products can be updated with the latest hardware more quickly.
• Platform Stability: The consistent API across different SoCs ensures that the software remains stable and maintainable, even as the underlying BSP evolves.

This approach allows an OEM to future-proof its software investment. The same software base can support multiple hardware generations, reducing long-term development costs.

Enabling Parallel Team Development

The HAL's layered architecture is a powerful enabler for parallel development. It creates a clean separation between the application layer and the hardware-specific BSP. This decoupling allows software and hardware teams to work independently and concurrently.

The HAL acts as a contract. The hardware team builds the BSP and drivers to meet the HAL's specifications. At the same time, the application team writes code that calls the HAL's standard functions, often using simulators or development boards.

This workflow removes critical dependencies that often cause delays. The software team does not need to wait for the final hardware to be available to begin its work. This separation simplifies debugging, as problems can be quickly isolated to either the application, the HAL, or the BSP. This efficiency empowers an OEM and its OEM partners to shorten the overall development cycle and bring products to market faster.

---

HiSilicon's software stack offers a clear path for an OEM to accelerate product launches. The architecture provides several key advantages for an OEM.

• The HAL simplifies complex coding into high-level API calls.
• The SDK and drivers give an OEM a ready-to-use development toolkit.
• The modular design supports long-term product scalability.

Ultimately, this strategy helps an OEM reduce development cycles. An OEM can launch products faster than the competition.

FAQ

What is the difference between the HAL and the BSP?

The Hardware Abstraction Layer (HAL) offers a standard API for applications. The Board Support Package (BSP) contains hardware-specific code and drivers for a particular board. The HAL sits on top of the BSP, separating the application from the low-level hardware details.

Can an OEM use the HAL without the full SDK?

Yes, an OEM can use the HAL independently. The HAL provides the core API for hardware interaction. However, the Software Development Kit (SDK) offers additional libraries, tools, and sample code. The SDK significantly accelerates the overall development process for an OEM.

How does the HAL help with hardware changes?

The HAL provides a consistent API layer. An OEM writes application code to this stable layer. When hardware changes, developers only need to update the underlying BSP. The application code requires minimal or no changes, which simplifies the migration process.

Is the HAL specific to one operating system?

HiSilicon designs the HAL to be adaptable. It can support various operating systems, such as Linux or LiteOS. This flexibility allows an OEM to choose the best OS for its product without rewriting the core hardware interaction logic provided by the HAL.