Peripheral Libraries and Drivers for Microcontrollers: A Comprehensive Survey

© 2023, IRJET | Impact Factor value: 8.226 | ISO 9001:2008 Certified Journal | Page 246
Peripheral Libraries and Drivers for Microcontrollers: A
Comprehensive Survey
Santosh N1, Shanta Rangaswamy2
1Student, Dept. of Computer Science, V College of Engineering, Bangalore, India
2Professor, Dept. of Computer Science, V College of Engineering, Bangalore, India
---------------------------------------------------------------------***---------------------------------------------------------------------
Abstract - Microcontrollers are fundamental components
of embedded systems, enabling a wide range of applications
across industries. To harness their full potential, efficient
and reliable interaction with the hardware peripherals is
crucial. Peripheral libraries and drivers act as
intermediaries between the microcontroller's core and the
peripherals, providing abstraction and standardization for
seamless integration and utilization. This survey paper
presents a comprehensive overview of the landscape of
peripheral libraries and drivers for microcontrollers. It
examines their role, architecture, features, challenges, and
the trends shaping their evolution. The paper also discusses
key considerations for selecting, designing, and optimizing
these software components to ensure robust and efficient
operation in embedded systems.
Key Words: Embedded Systems, Peripheral Libraries,
Microcontrollers
1.INTRODUCTION
Microcontrollers serve as the heart of numerous
embedded systems, controlling devices and processes in
sectors such as automotive, industrial automation,
consumer electronics, healthcare, and more. Peripheral
libraries and drivers play a pivotal role in facilitating
communication between the microcontroller's core
processing unit and its peripherals, enabling software
developers to interface with hardware components
without having to deal with low-level details. This paper
aims to provide an extensive survey of the peripheral
libraries and drivers ecosystem for microcontrollers,
covering their characteristics, challenges, and emerging
trends.
2. BACKGROUND AND EVOLUTION
Microcontrollers are the cornerstone of modern
embedded systems, facilitating the seamless integration of
computational intelligence into a wide range of
applications across industries. These compact integrated
circuits combine processing units, memory, and various
peripheral interfaces onto a single chip, enabling them to
perform specific tasks with efficiency and precision.
Early Microcontroller Architectures: In the early days of
microcontrollers, architectures such as the Intel 8051,
Motorola 68HC11, and PIC microcontrollers emerged as
pioneers. These architectures laid the foundation for
subsequent developments, despite their limited
processing power, memory capacity, and basic peripheral
offerings. Their role in controlling basic tasks like timers
and communication interfaces underscored the potential
of microcontrollers in a variety of applications.
Challenges of Direct Hardware Interaction: Developers
faced formidable challenges when directly interacting with
hardware peripherals in early microcontrollers. The need
to write intricate, hardware-specific code for each
peripheral led to time-consuming and error-prone
development processes. Lack of standardization across
different microcontroller families further compounded the
complexity, resulting in code that was often non-portable
and difficult to maintain.
Evolution of Microcontroller Features: As technology
advanced, so did the capabilities of microcontrollers.
Increased clock speeds, expanded memory, and the
integration of diverse peripheral interfaces became key
features of modern microcontrollers. This evolution was
driven by the demand for microcontrollers that could
handle more complex embedded applications, ranging
from automotive control systems to smart appliances.
Emergence of Peripheral Libraries and Drivers: The
challenges associated with direct hardware interaction
prompted the development of peripheral libraries and
drivers. These software components aimed to standardize
and simplify the process of interfacing with peripherals.
By providing a consistent, abstracted layer of interaction,
developers could write code that was more portable
across different microcontroller architectures.
Role of Standards and Abstraction: Industry standards
played a crucial role in shaping the evolution of peripheral
libraries and drivers. Efforts to establish uniform APIs and
methodologies for peripheral interaction paved the way
for higher-level abstractions. These abstractions shielded
developers from low-level hardware intricacies, allowing
them to focus on creating robust and efficient applications.
Transition to Higher-Level Abstractions: With the rise of
peripheral libraries and drivers, the transition from
writing low-level, hardware-specific code to using higher-
International Research Journal of Engineering and Technology (IRJET) e-ISSN: 2395-0056
Volume: 10 Issue: 10| Oct 2023 www.irjet.net p-ISSN: 2395-0072

level abstractions became apparent. Developers could now
utilize standardized interfaces provided by these libraries,
resulting in reduced development time and improved code
quality. This shift allowed developers to concentrate on
application logic rather than the nuances of hardware
communication.
Impact on Embedded Systems Development: The impact
of peripheral libraries and drivers on embedded systems
development cannot be overstated. These components
significantly reduced the barriers to entry for developers,
enabling them to create complex applications more
efficiently. Code reusability, standardization, and cross-
platform compatibility became key drivers of innovation
in the embedded systems domain.
From humble beginnings to the sophisticated
microcontrollers of today, the evolution of microcontroller
architectures has been a journey of remarkable growth.
This evolution laid the groundwork for the development of
peripheral libraries and drivers, which emerged as vital
tools for simplifying and standardizing embedded systems
development. As a result, developers can now harness the
full potential of microcontrollers to create innovative
solutions across diverse industries.
3. IMPORTANCE OF PERIPHERAL LIBRARIES AND
DRIVERS
This section delves into the significance of peripheral
libraries and drivers in microcontroller-based systems. It
discusses the advantages they offer in terms of
abstraction, reusability, and maintainability, while
highlighting their role in minimizing development time
and ensuring software portability across different
microcontroller platforms.
1. Abstraction and Standardization: Peripheral libraries
and drivers provide a layer of abstraction that shields
developers from the complexities of hardware
interactions. By presenting standardized APIs, these
components enable software developers to interact with
peripherals without needing in-depth knowledge of the
underlying microcontroller's registers and protocols. This
abstraction promotes code reusability and simplifies
development across different projects and microcontroller
platforms.
2. Accelerated Development: Efficient development is
crucial in today's fast-paced technological landscape.
Peripheral libraries and drivers significantly expedite the
development process by offering pre-written, optimized
code for interfacing with hardware peripherals. This
accelerates the creation of applications, as developers can
focus on implementing the desired functionalities instead
of dealing with low-level hardware intricacies.
3. Cross-Platform Compatibility: The diversity of
microcontroller architectures can make porting software
between platforms a daunting task. Peripheral libraries
and drivers mitigate this challenge by providing a
consistent interface regardless of the underlying
hardware. This compatibility allows developers to reuse
code across various microcontroller families, minimizing
development efforts and facilitating product portability.
4. Focus on Application Logic: With peripheral libraries
and drivers handling low-level hardware interactions,
developers can allocate more time and resources to
developing application-specific functionalities. This
separation of concerns allows for cleaner and more
modular code, making maintenance, updates, and
debugging more efficient.
5. Reduction of Development Costs: Building peripheral
interaction code from scratch can be time-consuming and
resource-intensive. Peripheral libraries and drivers reduce
development costs by eliminating the need for extensive
hardware expertise and dedicated development resources.
This cost reduction is particularly valuable for smaller
teams and organizations with limited resources.
6. Flexibility and Customization: While peripheral libraries
offer a high-level interface, they often include
customization options for developers who require more
granular control over hardware peripherals. This balance
between abstraction and customization allows developers
to tailor their solutions according to specific requirements.
7. Community Support and Updates: Well-established
peripheral libraries and drivers often have active
communities of developers contributing to their
improvement. These communities provide support,
guidance, and updates, ensuring that the software remains
relevant and up-to-date with the latest hardware
advancements and industry standards.
4. ARCHITECTURE AND COMPONENTS
This paper explores the typical architecture of peripheral
libraries and drivers, examines how they are structured to
abstract hardware complexities, how they manage
communication with peripherals, and how they provide
APIs (Application Programming Interfaces) for developers
to control and configure various peripherals. Examples of
well-known architectures such as HAL (Hardware
Abstraction Layer) and LL (Low-Level) libraries are
discussed.
1. Layered Architecture: Peripheral libraries and drivers
are often designed with a layered architecture that
abstracts the complexity of hardware interaction and
provides a clear separation between software and
hardware. This architecture typically comprises three
main layers:

Application Layer:
This layer represents the user's software application,
utilizing the provided APIs of peripheral libraries and
drivers to interface with hardware peripherals.
Middleware Layer:
Positioned between the application layer and the
hardware abstraction layer, the middleware layer offers
advanced functionality and often includes protocols,
communication stacks, and additional services that
enhance peripheral interaction.
Hardware Abstraction Layer (HAL):
The HAL is the foundational layer responsible for
abstracting hardware complexities. It provides a
standardized interface for peripheral initialization,
configuration, and interaction.
2. Components of Peripheral Libraries and Drivers:
Peripheral libraries and drivers consist of several key
components that collectively enable efficient
communication with hardware peripherals:
Peripheral Initialization: This component handles the
initialization of peripheral hardware, configuring
registers, clock settings, and pin configurations to prepare
the peripheral for operation.
Configuration Interfaces: Libraries provide APIs for
configuring various aspects of peripherals, such as baud
rates, data formats, sampling rates, and more.
Interrupt Handlers: These components manage interrupts
generated by peripherals, ensuring timely response to
events like data reception, errors, or timer overflows.
Power Management: Many libraries include power
management features that allow peripherals to enter low-
power states when not in use, contributing to energy
efficiency.
Data Structures and Enums: Libraries often define data
structures and enumerations that encapsulate
configuration options, making it easier for developers to
set parameters using readable and intuitive code.
Error Handling: Libraries may include mechanisms to
handle errors and exceptions that can occur during
peripheral operation, ensuring graceful degradation and
effective debugging.
Synchronization Mechanisms: In multi-threaded
environments, synchronization mechanisms are crucial for
preventing race conditions when accessing and
configuring shared peripherals.
Platform Abstraction: For cross-platform compatibility,
libraries may include platform-specific adaptations that
map the standardized API calls to the underlying
microcontroller's registers and functionalities.
3. Abstraction Levels:
Peripheral libraries and drivers often provide multiple
levels of abstraction to cater to different developer needs:
High-Level Libraries: These libraries offer simplified APIs
that abstract most hardware details, suitable for rapid
application development.
Low-Level Libraries: Designed for developers who require
more control, low-level libraries provide direct access to
registers and fine-grained configuration options.
Middleware: Positioned between high-level and low-level
libraries, middleware libraries offer advanced
functionalities like communication protocols and stacks.
The architecture and components of peripheral libraries
and drivers are designed to provide developers with
standardized, efficient, and manageable ways to interact
with microcontroller peripherals. These components
abstract hardware intricacies, facilitate initialization and
configuration, manage data transfer, and enable cross-
platform compatibility, ultimately streamlining the
development of microcontroller-based systems.
5. FEATURES AND FUNCTIONALITIES
This section presents an in-depth analysis of the features
and functionality offered by peripheral libraries and
drivers. It covers aspects such as peripheral initialization,
configuration, interrupt handling, power management,
and synchronization mechanisms.
1. Peripheral Initialization and Configuration
Peripheral libraries and drivers simplify the process of
initializing and configuring hardware peripherals, which is
often a complex and error-prone task. These components
provide functions that automate the setup of peripheral
registers, clock sources, pin configurations, and other
essential settings required for proper operation. By
abstracting the initialization process, developers can avoid
tedious manual configurations and ensure that peripherals
are correctly configured before use. This feature
significantly reduces the risk of misconfigurations and
accelerates the development process.
2. Standardized APIs
Standardized APIs are a hallmark of peripheral libraries
and drivers. These libraries offer a consistent and uniform
interface for developers to interact with various
peripherals. Each peripheral type comes with a set of

functions that encapsulate the necessary commands for its
configuration and operation. This standardized approach
reduces the learning curve when working with different
microcontroller families, enabling developers to reuse
their knowledge across projects. Additionally,
standardized APIs enhance collaboration among
developers by providing a common framework for
understanding and sharing code.
3. Abstraction of Hardware Complexities
Microcontroller peripherals often involve intricate
communication protocols, timing requirements, and
register configurations. Peripheral libraries and drivers
abstract these hardware complexities, shielding
developers from the low-level details. Instead of dealing
with the nitty-gritty of setting and manipulating registers,
developers can use high-level function calls that internally
handle these details. This abstraction simplifies the
development process, reduces the chances of errors, and
allows developers to focus on the core functionality of
their applications.
4. Interrupt Handling
Interrupts are essential for real-time responsiveness in
embedded systems. Peripheral libraries and drivers
manage interrupts generated by peripherals and provide a
standardized mechanism for developers to define
interrupt service routines (ISRs). ISRs are functions that
are executed in response to specific events, such as data
arrival, timer overflow, or external triggers. By managing
interrupts, these components ensure timely and accurate
handling of events, contributing to the real-time behavior
of the system.
5. Synchronization and Multithreading Support
In multi-threaded applications, where multiple threads or
tasks run concurrently, synchronization becomes crucial
to avoid conflicts and ensure data integrity. Peripheral
libraries and drivers offer synchronization mechanisms
that prevent race conditions when multiple threads access
and configure shared peripherals simultaneously. These
mechanisms include locks, semaphores, and other
synchronization primitives that enable safe concurrent
access, enhancing the reliability and stability of multi-
threaded applications.
6. Power Management
Energy efficiency is a priority in many embedded systems,
especially those powered by batteries or operating in
remote locations. Peripheral libraries and drivers often
include power management features that allow
peripherals to enter low-power states when they are not
actively in use. These components provide functions to
enable or disable peripherals, control clock frequencies,
and optimize power consumption. By managing power
states intelligently, developers can achieve significant
energy savings without compromising functionality.
7. Modularity and Reusability
Peripheral libraries and drivers promote code modularity
and reusability by encapsulating peripheral-specific
functionalities into separate, self-contained modules.
These modules can be reused across different projects,
reducing development time and minimizing redundant
coding efforts. This modularity also facilitates
maintenance and updates since changes can be localized
to specific modules without affecting the entire
application.
8. Flexibility and Customization
While providing high-level abstractions, peripheral
libraries and drivers often offer customization options for
developers who require more granular control over
peripheral configurations. These options allow developers
to fine-tune parameters, adjust timing settings, or override
default behaviors. This flexibility ensures that developers
can tailor peripheral interactions according to the specific
requirements of their applications while still benefiting
from the efficiency of standardized APIs.
By offering these features and functionalities, peripheral
libraries and drivers empower developers to create
efficient, reliable, and optimized microcontroller-based
systems, regardless of the complexity of the hardware
peripherals involved.
6. CHALLENGES AND CONSIDERATIONS
The challenges associated with designing and using
peripheral libraries and drivers are examined in this
section. These challenges include maintaining
compatibility across microcontroller generations,
ensuring real-time responsiveness, optimizing memory
usage, and handling complex peripheral interactions.
This section explores the potential hurdles and important
factors to take into account when working with these
software components.
1. Compatibility Across Microcontroller Families: Different
microcontroller families may have variations in peripheral
implementations, register layouts, and feature sets.
Ensuring compatibility across various microcontroller
platforms can be challenging, as developers need to adapt
the same library or driver to different architectures.
Maintaining a balance between abstraction and platform-
specific optimizations becomes crucial to achieve broad
compatibility.

2. Trade-off Between Abstraction and Performance:
Abstraction layers provided by peripheral libraries and
drivers can introduce a performance overhead due to the
additional layers of code execution. Striking the right
balance between abstraction and performance
optimization is essential, especially in applications with
stringent real-time requirements. Developers must
carefully consider the impact of abstraction on latency and
responsiveness.
3. Memory Footprint: Peripheral libraries and drivers
often come with code and data overhead to manage
abstractions, data structures, and configurations. In
resource-constrained systems, this extra memory usage
can be a concern. Developers need to evaluate whether the
benefits of using these components outweigh the
associated memory cost and make informed decisions
based on their application requirements.
4. Learning Curve and Documentation Quality: While
peripheral libraries aim to simplify development, there
might still be a learning curve associated with
understanding the APIs, configuration options, and usage
patterns. The quality of documentation provided by the
library is critical for reducing this learning curve. Clear,
comprehensive, and up-to-date documentation is essential
for helping developers effectively utilize the library's
features.
5. Maintainability and Updates: Peripheral libraries and
drivers might undergo updates, bug fixes, and feature
enhancements. However, incorporating these updates into
existing projects can sometimes introduce compatibility
issues or require modifications to existing code.
Developers must weigh the benefits of updates against the
potential effort needed for integration and testing.
6. Scalability and Performance Optimizations: Scalability
can be a challenge when transitioning from small-scale
prototyping to large-scale deployment. Performance
optimizations that work well in smaller systems might not
be as effective in larger, more complex applications.
Developers need to assess and optimize the library's
performance as the application scales.
Navigating these challenges and considerations requires a
balanced approach that considers the specific needs of the
project, the target microcontroller, and the desired level of
control and abstraction.
7. EMERGING TRENDS
As technology evolves, so do peripheral libraries and
drivers. This section highlights emerging trends in this
domain, such as the integration of middleware
components, support for IoT (Internet of Things)
protocols, increased focus on energy efficiency, and the
growing role of software frameworks that simplify and
standardize peripheral access.
Integration of middleware components: Middleware is
software that sits between the operating system and the
peripherals. It provides a layer of abstraction that makes it
easier for developers to access the peripherals.
Middleware components are becoming increasingly
integrated into peripheral libraries and drivers, making
them easier to use and more efficient.
Support for IoT protocols: The IoT is connecting billions of
devices together, and peripheral libraries and drivers need
to support the protocols that are used to communicate
between these devices. Some of the most popular IoT
protocols include MQTT, CoAP, and Zigbee.
Increased focus on energy efficiency: Embedded devices
are often battery-powered, so it is important for
peripheral libraries and drivers to be energy efficient. This
can be achieved by using techniques such as power
management and sleep modes.
AI and Neural Network Integration: As artificial
intelligence gains traction, peripheral libraries are starting
to provide support for neural networks and AI
frameworks, enabling on-device inference.
Microcontrollers can analyze data locally, making real-
time AI-powered decisions without relying on cloud
services. This is particularly valuable in applications like
edge AI and intelligent sensors.
8. BEST PRACTICES AND OPTIMIZATION
TECHNIQUES
Developers often face challenges in optimizing and fine-
tuning the performance of peripheral libraries and drivers.
This section outlines best practices for designing efficient
libraries.
1. Comprehensive Understanding of Datasheet
Best Practice: An exhaustive comprehension of the
microcontroller's datasheet is crucial to comprehending
peripheral configurations, registers, and interactions. This
foundational knowledge serves as a bedrock for efficient
library utilization.
Impact: Profound familiarity with the hardware empowers
informed decision-making and facilitates optimization of
configurations.
2. Utilization of High-Level APIs
Best Practice: Leveraging high-level functions proffered by
peripheral libraries to abstract low-level intricacies
contributes to complexity reduction and simplification of
development efforts.

Impact: High-level APIs simplify coding tasks, foster code
reusability, and ensure consistent interaction with
peripherals.
3. Emphasis on Power Management
Best Practice: Harnessing power-saving modes and
features available through peripheral libraries aids in
curtailing power consumption during periods of inactivity
or low operational demand.
Impact: Energy-efficient designs augment battery lifespan
and heighten the sustainability of battery-powered
devices.
4. Priority to Error Handling
Best Practice: Implementing thorough error handling
mechanisms using error codes, status flags, and exception
handling available within the libraries guarantees graceful
management of unexpected scenarios.
Impact: Effective error handling bolsters system
resilience, stability, and eases the debugging process.
5. Rigorous Benchmarking and Profiling
Best Practice: Employing benchmarking procedures to
assess the performance of the application using peripheral
libraries, identifying bottlenecks, and pinpointing areas
ripe for optimization.
Impact: Benchmarking serves as a focal point for
optimization efforts, enhancing critical sections, and
overall performance enhancement.
6. Optimization of Data Transfer
Best Practice: Incorporating efficient data transfer
methods such as Direct Memory Access (DMA) for swift
data exchanges between peripherals and memory.
Impact: Optimized data transfer mitigates processor
involvement, fostering heightened overall system
efficiency.
7. Rigorous Testing Regimen
Best Practice: Methodically testing the application across a
spectrum of scenarios, edge cases, and stress tests
uncovers potential issues, validating robust performance.
Impact: Thorough testing heightens application reliability,
diminishes the likelihood of unforeseen behavior, and
assists in identifying optimization avenues.
By adhering to these best practices and optimization
techniques, one can harness the complete potential of
peripheral libraries and drivers within microcontroller-
based development. These strategies foster superior
efficiency, reliability, and performance within applications,
while simultaneously endorsing code maintainability and
reusability.
9. CONCLUSIONS
Peripheral libraries and drivers form a critical bridge
between microcontroller hardware and software
applications. This survey paper has provided a
comprehensive exploration of their role, architecture,
features, challenges, and trends. As the embedded systems
landscape continues to evolve, a solid understanding of
these software components is indispensable for enabling
efficient, reliable, and innovative microcontroller-based
solutions.
REFERENCES
[1] Balarin, F. Chiodo, M. Giusto, Paolo Hsieh, Hoyen
Jurecska, Attila Lavagno, Luciano Passerone, C.
Sangiovanni-Vincentelli, Alberto Sentovich, Ellen
Suzuki, K. Tabbara, B.. (2023). Hardware- software
codesign of embedded systems: the polis approach.
[2] Ren, Xianzhen. (2021). Research on a software
architecture of speech recognition and detection
based on interactive reconstruction model.
International Journal of Speech Technology. 24. 1-9.
10.1007/s10772-020-09770-3.
[3] R. K. Yadav, M. B. Patil, and S. R. Jadon, ”Design and
Implementation of a Driver Framework for
Microcontroller- Based Systems Using Model-Based
Design,” International Journal of Electronics and
Telecommunications, vol. 66, no. 1, pp. 91-97, 2020.
[4] H. D. Mane and M. N. Bhaskar, ”Peripheral Driver
Development for Microcontrollers Using a Model-
Driven Approach,” International Journal of
Engineering and Advanced Technology (IJEAT), vol. 9,
no. 6, pp. 1413-1418, 2020.
[5] S. S. Rane and S. K. Bhosale, ”Development of a
Peripheral Library for ARM Cortex-M4
Microcontrollers,” International Journal of Advanced
Research in Computer and Communication
Engineering, vol. 8, no. 4, pp. 202-206, 2019.
[6] S. Goudar and V. Jain, ”Device Driver Development for
STM32F103 Microcontroller using FreeRTOS and
CMSIS,” International Journal of Advanced Research
in Computer Science and Software Engineering, vol. 9,
no. 1, pp. 432-437, 2019.
[7] B. K. Singh and A. K. Yadav, ”Design and Development
of a Peripheral Driver for NXP LPC2148
Microcontroller,” International Journal of Computer
Applications, vol. 177, no. 5, pp. 29-35, 2019.

[8] K. M. Chaudhari and S. V. Barve, ”Development and
Implementation of Peripheral Library (PLIB) for
Atmel SAM3X8E Microcontroller,” International
Journal of Engineering Research and Technology
(IJERT), vol. 7, no. 10, pp. 139-144, 2018.
[9] H. Li, ”Design and Implementation of Device Drivers
for Embedded Systems,” Journal of Computer and
Communications, vol. 4, no. 9, pp. 50-55, 2016.
[10] M. M. Rahman, M. A. Hossain, and M. S. Islam,
”Development of Peripheral Library for ARM Cortex-
M0 Microcontroller,” International Journal of
Computer Applications, vol. 129, no. 9, pp. 32-37,
2015.
[11] Robert and Jones, Bryan. (2010). Improving the
effectiveness of microcontroller education. 172 - 175.
10.1109/SECON.2010.5453894.
[12] Reese, Robert. (2005). Embedded System Emphasis In
An Introductory Microprocessor Course. 10.525.1-
10.525.7. 10.18260/1- 2–15572.
[13] Han-Way Huang, PIC Microcontroller: An Introduction
to Software and Hardware Interfacing, CENGAGE
Delmar Learning, July 2004, 816 pp.
[14] Peatman, John. (2003). Embedded Design with the
PIC18F452 Microcontroller.
[15] Dolinay, Jan andDosta´lek, Petr and Vasˇek,
V. (2004). Microcontroller software library for process
control. 10. 105- 112
[16] Wang, Shaojie Malik, Sharad Bergamaschi,
Reinaldo. (2003). Modeling and Integration of
Peripheral Devices in Embedded Systems. Proc. of
ACM/IEEE DATE. 136- 141.
10.1109/DATE.2003.1253599.
[17] Bolsens, Ivo Man, Haris Lin, Bill Rompaey, Karl
Vercauteren, Steven Verkest, Diederik. (1997).
Hardware/Software co-design of the digital
telecommunication systems. Proceedings of the
IEEE.85. 391 - 418. 10.1109/5.558713.
[18] Balarin, Felice Sentovich, Ellen Chiodo, Massimiliano
Giusto, Paolo Hsieh, Harry Tabbara, Bassam Jurecska,
Attila Marelli, Magneti Elettronica, Divisione Torino,
Venaria Lavagno, Luciano Passerone, Claudio Suzuki,
Kei. (1997).
[19] Hardware-Software Co-Design Of Embedded Systems
Hardware- Software Co-Design Of Embedded Systems.
10.1007/978-1-4615- 6127-9.

Peripheral Libraries and Drivers for Microcontrollers: A Comprehensive Survey

Recommended

Recommended

More Related Content

Similar to Peripheral Libraries and Drivers for Microcontrollers: A Comprehensive Survey

Similar to Peripheral Libraries and Drivers for Microcontrollers: A Comprehensive Survey (20)

More from IRJET Journal

More from IRJET Journal (20)

Recently uploaded

Recently uploaded (20)

Peripheral Libraries and Drivers for Microcontrollers: A Comprehensive Survey