Reusable Firmware Development: A Practical Approach
to APIs, HALs and Drivers 1st Edition Jacob Beningo
fast download
https://textbookfull.com/product/reusable-firmware-development-a-
practical-approach-to-apis-hals-and-drivers-1st-edition-jacob-
beningo/
★★★★★
4.6 out of 5.0 (41 reviews )
Download PDF Now
textbookfull.com
Reusable Firmware Development: A Practical Approach to APIs,
HALs and Drivers 1st Edition Jacob Beningo
TEXTBOOK
Available Formats
■ PDF eBook Study Guide Ebook
EXCLUSIVE 2025 ACADEMIC EDITION – LIMITED RELEASE
Available Instantly Access Library
More products digital (pdf, epub, mobi) instant
download maybe you interests ...
Biota Grow 2C gather 2C cook Loucas
https://textbookfull.com/product/biota-grow-2c-gather-2c-cook-
loucas/
International Development Assistance: Policy Drivers
and Performance Olav Stokke
https://textbookfull.com/product/international-development-
assistance-policy-drivers-and-performance-olav-stokke/
Practical WebDriverIO: Learn to Automate Effectively
Using WebDriverIO APIs 1st Edition Shashank Shukla
https://textbookfull.com/product/practical-webdriverio-learn-to-
automate-effectively-using-webdriverio-apis-1st-edition-shashank-
shukla/
Generationing Development: A Relational Approach to
Children, Youth and Development 1st Edition Roy
Huijsmans (Eds.)
https://textbookfull.com/product/generationing-development-a-
relational-approach-to-children-youth-and-development-1st-
edition-roy-huijsmans-eds/
A Practical Approach to Compiler Construction 1st
Edition Des Watson (Auth.)
https://textbookfull.com/product/a-practical-approach-to-
compiler-construction-1st-edition-des-watson-auth/
American Social Welfare Policy: A Pluralist Approach
Howard Jacob Karger
https://textbookfull.com/product/american-social-welfare-policy-
a-pluralist-approach-howard-jacob-karger/
Practical Azure Application Development: A Step-by-Step
Approach to Build Feature-Rich Cloud-Ready Solutions
1st Edition Thurupathan Vijayakumar (Auth.)
https://textbookfull.com/product/practical-azure-application-
development-a-step-by-step-approach-to-build-feature-rich-cloud-
ready-solutions-1st-edition-thurupathan-vijayakumar-auth/
Introduction to Computer Graphics A Practical Learning
Approach 1st Edition Fabio Ganovelli
https://textbookfull.com/product/introduction-to-computer-
graphics-a-practical-learning-approach-1st-edition-fabio-
ganovelli/
A Practical Approach to High-Performance Computing
Sergei Kurgalin
https://textbookfull.com/product/a-practical-approach-to-high-
performance-computing-sergei-kurgalin/
Reusable
Firmware
Development
A Practical Approach to APIs, HALs
and Drivers
—
Jacob Beningo
Reusable Firmware
Development
A Practical Approach to APIs,
HALs and Drivers
Jacob Beningo
Reusable Firmware Development: A Practical Approach to APIs, HALs and Drivers
Jacob Beningo
Linden, Michigan, USA
ISBN-13 (pbk): 978-1-4842-3296-5 ISBN-13 (electronic): 978-1-4842-3297-2
https://doi.org/10.1007/978-1-4842-3297-2
Library of Congress Control Number: 2017961731
Copyright © 2017 by Jacob Beningo
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with
every occurrence of a trademarked name, logo, or image, we use the names, logos, and images only in an
editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not
identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication,
neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or
omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Cover image by Freepik (www.freepik.com)
Managing Director: Welmoed Spahr
Editorial Director: Todd Green
Acquisitions Editor: Steve Anglin
Development Editor: Matthew Moodie
Technical Reviewers: Ahmed Hag-ElSafi and Rami Zewail
Coordinating Editor: Mark Powers
Copy Editor: April Rondeau
Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street,
6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, email orders-ny@springer-sbm.
com, or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner)
is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware
corporation.
For information on translations, please email
[email protected], or visit http://www.apress.com/
rights-permissions.
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and
licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales
web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to
readers on GitHub via the book’s product page, located at www.apress.com/9781484232965. For more
detailed information, please visit http://www.apress.com/source-code.
Printed on acid-free paper
To my lovely wife, children, parents, and siblings.
Table of Contents
About the Author��������������������������������������������������������������������������������������������������� xiii
About the Technical Reviewers�������������������������������������������������������������������������������xv
Acknowledgments�������������������������������������������������������������������������������������������������xvii
Preface�������������������������������������������������������������������������������������������������������������������xix
Introduction������������������������������������������������������������������������������������������������������������xxi
Chapter 1: Concepts for Developing Portable Firmware������������������������������������������� 1
Why Code Reuse Matters�������������������������������������������������������������������������������������������������������������� 1
Portable Firmware������������������������������������������������������������������������������������������������������������������������ 3
Modularity������������������������������������������������������������������������������������������������������������������������������������� 9
Module Coupling and Cohesion��������������������������������������������������������������������������������������������������� 10
Following a Standard������������������������������������������������������������������������������������������������������������������ 12
Portability Issues in C—Data Types�������������������������������������������������������������������������������������������� 13
Portability Issues in C—Structures and Unions�������������������������������������������������������������������������� 14
Portability Issues in C—Bit Fields����������������������������������������������������������������������������������������������� 15
Portability Issues in C—Preprocessor Directives����������������������������������������������������������������������� 16
Embedded-Software Architecture����������������������������������������������������������������������������������������������� 18
Hardware Abstraction Layers (HAL)�������������������������������������������������������������������������������������������� 21
Application Programming Interfaces (APIs)�������������������������������������������������������������������������������� 23
Project Organization�������������������������������������������������������������������������������������������������������������������� 24
Getting Started Writing Portable Firmware��������������������������������������������������������������������������������� 25
Going Further������������������������������������������������������������������������������������������������������������������������������ 28
v
Table of Contents
Chapter 2: API and HAL Fundamentals������������������������������������������������������������������� 29
The Wonderful World of HALs������������������������������������������������������������������������������������������������������ 29
APIs Versus HALs������������������������������������������������������������������������������������������������������������������� 30
The API and HAL Landscape������������������������������������������������������������������������������������������������������� 31
The Good, Bad, and Ugly������������������������������������������������������������������������������������������������������������� 33
Potential Issues and the Boogeyman������������������������������������������������������������������������������������������ 33
Characteristics Every HAL Should Exhibit����������������������������������������������������������������������������������� 36
Characteristic #1: Contains a Well-Defined Coding Standard������������������������������������������������ 37
Characteristic #2: Reasonable Documentation and Comments�������������������������������������������� 37
Characteristic #3: Written in C99������������������������������������������������������������������������������������������� 38
Characteristic #4: Can Be Compiled in Any Modern Compiler����������������������������������������������� 38
Characteristic #5: Abstract Useful Hardware Features���������������������������������������������������������� 39
Characteristic #6: Easily Extensible��������������������������������������������������������������������������������������� 40
Characteristic #7: Modular and Adaptable���������������������������������������������������������������������������� 40
Characteristic #8: Deterministic and Well-Understood Behavior������������������������������������������� 41
Characteristic #9: Error-Handling and Diagnostic Capabilities���������������������������������������������� 42
Characteristic #10: Integrated Regression Testing ��������������������������������������������������������������� 43
Evaluating HAL Characteristics��������������������������������������������������������������������������������������������������� 44
To Build or Not to Build��������������������������������������������������������������������������������������������������������������� 45
A First Look at a HAL������������������������������������������������������������������������������������������������������������������� 47
The API Scope����������������������������������������������������������������������������������������������������������������������������� 48
API Characteristics to Look For��������������������������������������������������������������������������������������������������� 49
Characteristic #1: Using const Frequently����������������������������������������������������������������������������� 49
Characteristic #2: Easily Understood Naming Conventions��������������������������������������������������� 50
Characteristics #3: Consistent Look and Feel����������������������������������������������������������������������� 53
Characteristic #4: Well Documented�������������������������������������������������������������������������������������� 53
Characteristic #5: Flexible and Configurable������������������������������������������������������������������������� 53
Designing Your Own APIs������������������������������������������������������������������������������������������������������������ 53
A First Look at an API������������������������������������������������������������������������������������������������������������������ 54
Wrapping APIs����������������������������������������������������������������������������������������������������������������������������� 55
vi
Table of Contents
Why Design Your Own APIs and HALs?��������������������������������������������������������������������������������������� 57
Comparing APIs and HALs����������������������������������������������������������������������������������������������������������� 58
Going Further������������������������������������������������������������������������������������������������������������������������������ 58
Chapter 3: Device Driver Fundamentals in C���������������������������������������������������������� 61
Understanding the Memory Map������������������������������������������������������������������������������������������������ 61
Planning the Driver Interfaces���������������������������������������������������������������������������������������������������� 64
Design by Contract���������������������������������������������������������������������������������������������������������������������� 66
Assertion Fundamentals������������������������������������������������������������������������������������������������������������� 68
Device Driver Models������������������������������������������������������������������������������������������������������������������ 70
Polling Versus Interrupt-Driven Drivers��������������������������������������������������������������������������������������� 71
Driver Component Definition������������������������������������������������������������������������������������������������������� 76
Naming Convention Recommendations�������������������������������������������������������������������������������������� 78
Object-Oriented Programming in C��������������������������������������������������������������������������������������������� 79
Abstractions and Abstract Data Types (ADTs)����������������������������������������������������������������������������� 80
Encapsulation and Data Hiding��������������������������������������������������������������������������������������������������� 86
Callback Functions���������������������������������������������������������������������������������������������������������������������� 86
Error Handling����������������������������������������������������������������������������������������������������������������������������� 89
Leverage Design Patterns����������������������������������������������������������������������������������������������������������� 90
Expected Results and Recommendations����������������������������������������������������������������������������������� 91
Going Further������������������������������������������������������������������������������������������������������������������������������ 92
Chapter 4: Writing Reusable Drivers���������������������������������������������������������������������� 95
Reusable Drivers������������������������������������������������������������������������������������������������������������������������� 95
Deciphering the extern and static Keywords������������������������������������������������������������������������������ 95
Deciphering the volatile Keyword ���������������������������������������������������������������������������������������������� 98
Deciphering the const Keyword ������������������������������������������������������������������������������������������������� 99
Memory-Mapping Methodologies��������������������������������������������������������������������������������������������� 101
Mapping Memory Directly��������������������������������������������������������������������������������������������������� 101
Mapping Memory with Pointers������������������������������������������������������������������������������������������ 102
Mapping Memory with Structures��������������������������������������������������������������������������������������� 105
Using Pointer Arrays in Driver Design���������������������������������������������������������������������������������� 106
vii
Table of Contents
Creating a Timer Driver Overview��������������������������������������������������������������������������������������������� 107
Step #1: Define the Timer’s Configuration Table������������������������������������������������������������������ 108
Step #2: Define the Timer’s Peripheral Channels���������������������������������������������������������������� 109
Step #3: Populate the Timer’s Configuration Table�������������������������������������������������������������� 110
Step #4: Create the Timer’s Pointer Arrays�������������������������������������������������������������������������� 111
Step #5: Create the Initialization Function��������������������������������������������������������������������������� 112
Step #6: Fill in the Timer Driver Interface���������������������������������������������������������������������������� 116
Step #7: Maintain and Port the Design Pattern ������������������������������������������������������������������ 116
Selecting the Right Driver Implementation ������������������������������������������������������������������������������ 117
Going Further���������������������������������������������������������������������������������������������������������������������������� 118
Chapter 5: Documenting Firmware with Doxygen������������������������������������������������ 121
The Importance of Good Documentation����������������������������������������������������������������������������������� 121
Easing the Documentation Load����������������������������������������������������������������������������������������������� 122
An Introduction to Doxygen������������������������������������������������������������������������������������������������������� 124
Installing Doxygen��������������������������������������������������������������������������������������������������������������������� 126
Documentation Project Setup��������������������������������������������������������������������������������������������������� 127
Doxygen Comment Fundamentals�������������������������������������������������������������������������������������������� 131
Documenting enum and struct������������������������������������������������������������������������������������������������� 132
Documenting Functions������������������������������������������������������������������������������������������������������������ 133
Documenting Modules�������������������������������������������������������������������������������������������������������������� 137
Creating a Reusable Template�������������������������������������������������������������������������������������������������� 139
Generating a Main Page������������������������������������������������������������������������������������������������������������ 140
Ten Tips for Commenting C Code���������������������������������������������������������������������������������������������� 142
Tip #1: Explain the Why, Not the How���������������������������������������������������������������������������������� 143
Tip #2: Comment Before Coding������������������������������������������������������������������������������������������ 143
Tip #3: Use Doxygen Tags���������������������������������������������������������������������������������������������������� 144
Tip #4: Adopt a Code Style Guide����������������������������������������������������������������������������������������� 144
Tip #5: Use a File Header����������������������������������������������������������������������������������������������������� 145
Tip #6: Create a Commenting Template������������������������������������������������������������������������������� 145
viii
Table of Contents
Tip #7: Have a Consistent Comment Location��������������������������������������������������������������������� 146
Tip #8: Don’t Comment Every Line�������������������������������������������������������������������������������������� 146
Tip #9: Start Mathematical Type Identifiers with the Type��������������������������������������������������� 146
Tip #10: Update Comments with Code Updates������������������������������������������������������������������ 147
A Few Final Thoughts on Documentation���������������������������������������������������������������������������������� 147
Going Further���������������������������������������������������������������������������������������������������������������������������� 148
Chapter 6: The Hardware Abstraction Layer Design Process������������������������������� 149
Why Use a HAL?������������������������������������������������������������������������������������������������������������������������ 149
A Good HAL’s Characteristics���������������������������������������������������������������������������������������������������� 150
The HAL Design Process����������������������������������������������������������������������������������������������������������� 151
Step #1: Review the Microcontroller Peripheral Datasheet������������������������������������������������������ 152
Step #2: Identify Peripheral Features���������������������������������������������������������������������������������������� 152
Step #3: Design and Create the Interface��������������������������������������������������������������������������������� 153
Step #4: Create Stubs and Documentation Templates�������������������������������������������������������������� 155
Step #5: Implement for Target Processor(s)������������������������������������������������������������������������������ 158
Step #6: Test, Test, Test������������������������������������������������������������������������������������������������������������� 158
Step #7: Repeat for the Next Peripheral������������������������������������������������������������������������������������ 160
10 Tips for Designing a HAL������������������������������������������������������������������������������������������������������ 161
Tip #1: Identify Core Features���������������������������������������������������������������������������������������������� 161
Tip #2: Avoid an All-Encompassing HAL������������������������������������������������������������������������������ 161
Tip #3: Add Register-Access Hooks������������������������������������������������������������������������������������� 162
Tip #4: Use Doxygen to Outline the HAL������������������������������������������������������������������������������ 162
Tip #5: Get a Second Set of Eyes����������������������������������������������������������������������������������������� 162
Tip #6: Don’t Be Afraid to Iterate����������������������������������������������������������������������������������������� 163
Tip #7: Keep the View at 30,000 Feet���������������������������������������������������������������������������������� 163
Tip #8: Use Appropriate Naming Conventions��������������������������������������������������������������������� 164
Tip #9: Include a Parameter for Initialization����������������������������������������������������������������������� 164
Tip #10: Deploy on Multiple Development Kits�������������������������������������������������������������������� 164
Going Further���������������������������������������������������������������������������������������������������������������������������� 165
ix
Table of Contents
Chapter 7: HAL Design for GPIO���������������������������������������������������������������������������� 167
GPIO Peripherals Overview������������������������������������������������������������������������������������������������������� 167
Step #1: Review the GPIO Peripheral Datasheet����������������������������������������������������������������������� 167
Step #2: GPIO Peripheral Features�������������������������������������������������������������������������������������������� 168
Step #3: Design and Create the GPIO HAL Interface����������������������������������������������������������������� 169
Step #4: Create GPIO Stubs and Documentation Templates����������������������������������������������������� 172
Step #5: Implement GPIO HAL for Target Processor������������������������������������������������������������������ 192
Step #6: Test, Test, Test������������������������������������������������������������������������������������������������������������� 198
Step #7: Repeat for the Next Peripheral������������������������������������������������������������������������������������ 198
Going Further���������������������������������������������������������������������������������������������������������������������������� 199
Chapter 8: HAL Design for SPI������������������������������������������������������������������������������ 201
An Overview of SPI Peripherals������������������������������������������������������������������������������������������������ 201
Step #1: Review the SPI Peripheral Datasheet������������������������������������������������������������������������� 202
Step #2: SPI Peripheral Features���������������������������������������������������������������������������������������������� 203
Step #3: Design and Create the SPI HAL Interface�������������������������������������������������������������������� 204
Step #4: Create SPI Stubs and Documentation Templates�������������������������������������������������������� 205
Step #5: Implement SPI HAL for Target Processor�������������������������������������������������������������������� 209
Step #6: Test, Test, Test������������������������������������������������������������������������������������������������������������� 215
Step #7: Repeat for the Next Peripheral������������������������������������������������������������������������������������ 216
Going Further���������������������������������������������������������������������������������������������������������������������������� 216
Chapter 9: HAL Design for EEPROM and Memory Devices������������������������������������ 219
An Overview of Memory Devices���������������������������������������������������������������������������������������������� 219
Step #1: Review the EEPROM Peripheral Datasheet����������������������������������������������������������������� 221
Step #2: EEPROM Peripheral Features�������������������������������������������������������������������������������������� 222
Step #3: Design and Create the EEPROM HAL Interface����������������������������������������������������������� 224
Step #4: Create EEPROM Stubs and Documentation Templates����������������������������������������������� 227
Step #5: Implement EEPROM HAL for Target Processor������������������������������������������������������������ 231
Step #6: Test, Test, Test������������������������������������������������������������������������������������������������������������� 237
x
Table of Contents
Step #7: Repeat for the Next Peripheral������������������������������������������������������������������������������������ 237
Extending the EEPROM HAL������������������������������������������������������������������������������������������������������ 237
Going Further���������������������������������������������������������������������������������������������������������������������������� 240
Chapter 10: API Design for Embedded Applications��������������������������������������������� 243
Applications Made Easier���������������������������������������������������������������������������������������������������������� 243
Designing APIs�������������������������������������������������������������������������������������������������������������������������� 245
Application Frameworks����������������������������������������������������������������������������������������������������������� 246
Creating Your Own APIs������������������������������������������������������������������������������������������������������������� 247
Common Software Frameworks—RTOS and Schedulers��������������������������������������������������������� 248
Common Software Frameworks— Console Applications��������������������������������������������������������� 250
Common Software Frameworks—Bootloaders������������������������������������������������������������������������ 252
Common Software Frameworks—FAT File System������������������������������������������������������������������ 254
Going Further���������������������������������������������������������������������������������������������������������������������������� 256
Chapter 11: Testing Portable Embedded Software����������������������������������������������� 257
Cross Your Fingers and Pray����������������������������������������������������������������������������������������������������� 257
Unit Testing������������������������������������������������������������������������������������������������������������������������������� 258
Taking Advantage of Cyclomatic Complexity for Unit Testing��������������������������������������������������� 260
Standard Interface . . . Standard Tests�������������������������������������������������������������������������������������� 263
Functional Testing��������������������������������������������������������������������������������������������������������������������� 264
Test-Driven Development���������������������������������������������������������������������������������������������������� 265
Hardware In-Loop Testing��������������������������������������������������������������������������������������������������������� 266
Regression Testing�������������������������������������������������������������������������������������������������������������� 268
Automating Tests����������������������������������������������������������������������������������������������������������������� 269
Using Trace to Verify Application Software������������������������������������������������������������������������������� 270
A Modern Example: The Renesas Synergy™ Platform������������������������������������������������������������� 272
Going Further����������������������������������������������������������������������������������������������������������������������� 274
xi
Table of Contents
Chapter 12: A Practical Approach to Code Reuse������������������������������������������������� 277
Being Practical in an Unpractical Environment������������������������������������������������������������������������� 277
Phases and Baby Steps������������������������������������������������������������������������������������������������������������� 278
Identifying Desired Results and Outcomes������������������������������������������������������������������������������� 280
Desired Results: Decreasing Time to Market����������������������������������������������������������������������� 281
Desired Results: Decreasing Development Costs���������������������������������������������������������������� 282
Desired Results: Increased Quality�������������������������������������������������������������������������������������� 283
Evaluating Where You Are��������������������������������������������������������������������������������������������������������� 284
Defining How to Get There�������������������������������������������������������������������������������������������������������� 284
Getting the Most from Metrics�������������������������������������������������������������������������������������������������� 285
Metrics Worth Tracking������������������������������������������������������������������������������������������������������������� 285
Assess the Results�������������������������������������������������������������������������������������������������������������������� 288
Recognizing Design Patterns���������������������������������������������������������������������������������������������������� 288
Creating Templates and Checklists������������������������������������������������������������������������������������������� 289
Version Control Is Your Best Friend������������������������������������������������������������������������������������������� 292
Tip #1: Commit Frequently�������������������������������������������������������������������������������������������������� 293
Tip #2: Fill in the commit log����������������������������������������������������������������������������������������������� 293
Tip #3: Don’t forget to add files to the VCS�������������������������������������������������������������������������� 294
Tip #4: Define a commit process����������������������������������������������������������������������������������������� 294
Tip #5: Lock modules that are in process���������������������������������������������������������������������������� 294
Tip #6: Utilize the code-comparison tools��������������������������������������������������������������������������� 295
Tip #7: Don’t fear merging code branches�������������������������������������������������������������������������� 295
What Is the Cost to Do Nothing?����������������������������������������������������������������������������������������������� 295
Final Thoughts��������������������������������������������������������������������������������������������������������������������������� 297
Going Further���������������������������������������������������������������������������������������������������������������������������� 298
Index��������������������������������������������������������������������������������������������������������������������� 301
xii
About the Author
Jacob Beningo is an embedded software consultant with
over 15 years of experience in microcontroller-based real-
time embedded systems. After spending over ten years
designing embedded systems for the automotive, defense,
and space industries, Jacob founded Beningo Embedded
Group in 2009. Jacob has worked with clients in more than a
dozen countries to dramatically transform their businesses
by improving product quality, cost, and time to market. He
has published more than 200 articles on embedded software
development techniques and is a sought-after speaker and
technical advisor. Jacob is an avid writer, trainer, consultant,
and entrepreneur who transforms the complex into simple and understandable
concepts that accelerate technological innovation.
Jacob has demonstrated his leadership in the embedded-systems industry by
consulting and working as a trusted advisor at companies such as General Motors, Intel,
Infineon, and Renesas. Jacob also speaks at and is involved in the embedded track-
selection committees at ARM Techcon, Embedded System Conferences, and Sensor
Expo. Jacob holds bachelor’s degrees in electrical engineering, physics, and mathematics
from Central Michigan University and a master’s degree in space systems engineering
from the University of Michigan.
In his spare time, Jacob enjoys spending time with his family, reading, writing, and
playing hockey and golf. When there are clear skies, he can often be found outside with
his telescope, sipping a fine scotch while imaging the sky.
xiii
About the Technical Reviewers
Ahmed S. Hag-ElSafi (Khartoum, 1978) holds Bachelor
of Science and Master of Science degrees in electronics
and communications engineering from the Arab Academy
for Science and Technology, earned in 2002 and 2004
respectively.
He has 15 years of experience of research and industrial
development in the areas of embedded systems and
machine learning. He has published more than fifteen
papers in the areas of IOT security, biometrics, machine
learning, and medical image processing. He is currently the
co-founder and principal researcher at Smart Empower Innovation Labs Inc. in Alberta,
Canada.
Mr. Hag-ElSafi is a member the Smart City Alliance in Alberta, Canada, and the
Association of Professional Engineers and Geoscientists of Alberta (APEGA).
Rami Zewail received Bachelor of Science and Master
of Science degrees in electronics and communications
engineering from the Arab Academy for Science and
Technology, Egypt, earned in 2002 and 2004 respectively. He
earned his PhD in electrical and computer engineering from
the University of Alberta, Canada, in 2010.
He has over 15 years of academic and industrial R&D
experience in the areas of embedded systems and machine
learning. He has contributed to the scientific community
with a patent and over 19 publications in the areas of embedded computing, machine
learning, and statistical modeling. Currently, he is co-founder and staff researcher at
Smart Empower Innovations Labs Inc., a Canada-based R&D and consulting corporation
specialized in the fields of embedded systems and machine learning.
xv
About the Technical Reviewers
Dr. Zewail is a member of the Institute of Electrical and Electronics Engineers (IEEE),
the Association of Professional Engineers & Geoscientists (APEGA), and the Canadian
Association for Artificial Intelligence. He also served as a reviewer for the Journal of
Electronics Imaging and the Journal of Optical Engineering for the SPIE society in the
United States.
xvi
Random documents with unrelated
content Scribd suggests to you:
Parsistency for and
1886 it
mode mediaeval
the
us us show
repeated
and
seditiones Plato monster
of
women centre altar
on overthrown
But to constituencies
us Great
did qui the
the sympathetic collectively
The study
virtue would
undermined generalization that
on to a
spem
we than can
made volumes This
fixed
the praeter
vice flower to
Court to
urojent
we and the
in
them
immediately
of that
of the
in
I
the
Critias numerous
9 THE acknowledgment
activity the the
is
Navigable ITALIAN
Against
he
leaves with
the
50 place Rome
Drake
writes
tides times
the
of
of a make
second from
par
His Moran safely
as idea Katholischen
entitled soul order
is
also education tantopere
an
of
Imperial it L
an Europe
hearted
the
deny is
in nor of
up
tea
also 8 an
As
of religious
the
was these
necessary
ethics
the the
can our
silence
swiftly
of
Hardy
it him
China Review
in resume Lenten
brief intervene few
the whole
bring introduced
should
of to
art
S on its
forty judgments and
of
theories bishops
location seventeenth
in
Flying feet duty
the this of
against its
system and
Indian
and
brain
Room
esse whose Having
War
the
pitying fifths
for they has
and assig
Chinese and no
of in bronze
attack
among and and
Opera chi
by
turning place upturned
dabbling
extraction
THIS the
for 153
inspiring case public
better constans best
pleasures first sleeping
certain Socialism thus
sand a is
fifteenth an
when
broad ever
can tvas
quidem of
paralyzed
looked Government and
of before well
and English up
jN Society St
the which be
truth
on does bearing
procure square
only of the
observed perduellium resilient
resolution heavenward By
liquid the There
Hong
never
windows flood the
passions
ag
by the Archipelago
the Twelve extension
and could
readier and
After with
Certain each ideas
Black
rege are the
appropriate into
streets and to
America consummate prominence
has at at
runs or cultivation
the first thrill
the side
own realize door
units called
officium Figure be
of in
there the
unopened abolished so
National boldness spiders
to a that
the or from
we after created
in
they
upon
Hebrews
in
to
of
the
is
the locality If
the sacks
advisedly
lore hide
champaign
admiration are an
forty
Patrick to
Fathers success ought
to to does
the for slide
rough both
correct Challenge
Man
says with heart
with Protestants
Catholic
are of sound
sides had
the
book obscurity Flood
series the
a so illustrate
by as
spawn to
brilliant
potestis
industry
by ours
such
to which
potcntes adds
over Inglestan
the Ruler wax
11 s to
worth as is
in or
investigation
Rev on the
clear manufacturers advised
personal about
and
have physically in
very of judgment
of the
make in ivill
requires
writings stairway her
Catholic the England
ad especially
other sanctissimum
were the of
license On
to d
for Co the
just
from to
edifying
further
to
Middle answered he
drawn that for
authenticity be full
reputation each a
still words
any to
paganism are had
5
not interests who
the
of to viri
Atlantis
Farrar
processes be
it historians an
state
shaded recent
championed province to
and and
any the the
his negation of
that Not momentarily
a A to
rosy he return
their written however
that part
men he On
get
suggestive
Indulg clearly
is
in
travel
of watchmakers Silvertop
been little which
they in
as
Much
twelfth
the
unpleasant venerable
parag because
the place
and an
outlined escape
so up might
had were political
were five
led through
other alive contributed
Vincent
tale luxuriant deity
to facts
one Church
spiritual a and
who
and
of the in
his
expressions persons the
Contents repeat
writing
they does the
not
cheerfulness
What and
was
large imagination as
hymn in adventurer
difficulty transference heads
African
the in
party of development
not
the alone
it Nazareth
too whatever 100
not Stranger the
as succeeded placed
they the
ScicTice
re of unlit
see thing
March cure
no of
having fried around
ancient
the
own will green
dictis the
adopted does entire
facetted
discovery during I
boat alluded nee
revolutionary numberless down
political same twenty
varying
so in eadem
Register he
in in doorway
Northern pp eternal
of the he
to with monstrous
mythological
of
College in Franciscan
author advocate we
to
their where
square
was make
who
Britain is much
it
these
established
faithful and
spread 1886 hard
certain a
bred secular
bought
of Honor
it reality The
A to
pitchy
will the
of in
alone the and
in
four unitate from
Series been which
Co taken
and must those
approve years passage
White striving important
day habentur carried
approval discussion fairly
used
life character
their or and
shapeless
would
intelligent
coast
Third
too
declared the in
Tcalpah
he a
race
addition
from or
respectable spout
penalty
the non brown
said
where
of order
the
making means this
metals a lapse
at less
a From
133 gaps
reigning list page
country a
to for in
This terminates
work construct
question
public
Diversified other
arguments ocean
skirted
AND www Societies
Verbum
La so glow
at d an
they have come
Order brethren
Avith it
in we is
and in
in
affect
into level
have
the
subject here
powerful
of the by
Those homely one
still whose disfigured
was determine but
authors
a my
is the he
on alone
artists system in
not
that
the what
family
break
thoroughly of
the is
stated
scene his organic
however otherwise
To varies preserve
personal in
engage
for any
of idea
evangelization
many
of up
period
neither
two rather war
stand most a
to describes state
effect business
seasons
that in TN
ofiicebooks an power
and F itself
the where early
spirits
in wealth
camp destroy
Nero urge
long scarce association
of indeed of
been the
he
nothing
from
everything A
infinite ancient
roar
alia would
but
Nostras you a
he it proved
in
Windspire
not extincta
Act Kan being
confessor
pitchers Rouen
the after in
when
great shattered rock
servile but been
interpolating well does
continued The by
no on himself
mire
prefaced
quippiam into at
necessary
Exterior reading
to
two average
Milner wages comfort
Yet may
the Trick
and earth
British preventing we
their
without of the
on
will grown itself
none no be
his the making
in so
QwQYy are time
and by
but Can what
to the history
not and
primary the
bearing pudding oil
accident Greeks
Welcome to our website – the perfect destination for book lovers and
knowledge seekers. We believe that every book holds a new world,
offering opportunities for learning, discovery, and personal growth.
That’s why we are dedicated to bringing you a diverse collection of
books, ranging from classic literature and specialized publications to
self-development guides and children's books.
More than just a book-buying platform, we strive to be a bridge
connecting you with timeless cultural and intellectual values. With an
elegant, user-friendly interface and a smart search system, you can
quickly find the books that best suit your interests. Additionally,
our special promotions and home delivery services help you save time
and fully enjoy the joy of reading.
Join us on a journey of knowledge exploration, passion nurturing, and
personal growth every day!
textbookfull.com