EMBEDDED SYSTEM DEVELOPMENT

This internship report submitted in partial fulfillment of the requirement for the award of degree
of

BACHELOR OF TECHNOLOGY
in
ELECTRONICS AND COMMUNICATION ENGINEERING
Submitted by
M. PRADEEP SRI VARMA (VU21EECE0100459)

Under the esteemed guidance of

Guide name
Sri S.S.S Srikanth
Assistant Professor

DEPARTMENT OF ELECTRICAL, ELECTRONICS AND COMMUNICATION

ENGINEERING
GITAM SCHOOL OF TECHNOLOGY
GITAM
(Deemed to be University)
(Estd. u/s 3 of UGC act 1956 & Accredited by NAAC with “A++” Grade)

VISAKHAPATNAM-530045
(2021-2025)
 DEPARTMENT OF ELECTRICAL, ELECTRONICS AND COMMUNICATION
ENGINEERING

GITAM SCHOOL OF TECHNOLOGY

GITAM (Deemed to be University)

CERTIFICATE

This is to certify that this report on “EMBEDDED SYSTEM DEVELOPMENT” is a bonafide

work carried out by M. PRADEEP SRI VARMA(VU21EECE0100459) submitted in partial
fulfillment of the requirements for the award of the degree of Bachelor of Technology in
Electronics and Communication Engineering, GITAM School of Technology, GITAM
(Deemed to be University), Visakhapatnam has successfully completed the industrial training
at “CANTELLAT SOFTWARE PVT.” during the academic year 2020-2024.

INTERNSHIP GUIDE HEAD OF THE DEPARTMENT

Sri S.S.S.Srikanth Dr. P. Bharani Chandra kumar
Assistant Professor Professor
Dept. of EECE Dept. of EECE
GITAM School of Technology GITAM School of Technology
DEPARTMENT OF ELECTRICAL, ELECTR ONICS AND COMMUNICATION
ENGINEERING

GITAM SCHOOL OF TECHNOLOGY

GITAM
(Deemed to be University)

DECLARATION

I hereby declare that the work entitled “EMBEDDED SYSTEM DEVELOPMENT”

is an original work done in the Department of Electrical, Electronics and
Communication Engineering, GITAM School of Technology, GITAM (Deemed to
be University) submitted in partial fulfillment of the requirements for the award of
the degree of B.Tech. in Electronics and Communication Engineering. The work
has not been submitted to any other college or university for the award of any degree
or diploma.

Registration No. Name signature

VU21EECE0100459 M. Pradeep sri varma

INTERNSHIP CERTIFICATE
 ACKNOWLEDGEMENT
We would like to thank our internship guide Sri S. S. S. Srikanth, Assistant
Professor Dept. of EECE for his stimulating guidance and profuse assistance.
We shall always cherish our association with him for his guidance,
encouragement, and valuable suggestions throughout the progress of this
work. We consider it a great privilege to work under his guidance and
constant support.

We would like to thank our Internship Coordinators Dr. D. Madhavi,

Assistant Professor, Dept. of EECE in helping to complete the project by
taking frequent reviews and for their valuable suggestions throughout the
progress of this work.

We consider it as a privilege to express our deepest gratitude to Prof. P.

Bharani Chandra Kumar, Head of the Department, Department of EECE for
his valuable suggestions and constant motivation that greatly helped us to
successfully complete the project work.
Our sincere thanks to Prof. K. Nagendra Prasad, Director, GST, GITAM
(Deemed to be University) for inspiring us to learn new technologies and
tools. Finally, we deem it a great pleasure to thank one and all who helped us
directly and indirectly throughout this project

M. Pradeep sri varma

VU21EECE0100459
 CONTENTS

Page
Chapter No. Description
No.
1 Abstract
1

Chapter 1 Course objectives

1.1 Gain Practical Experience 2

1.2 Learn Programming Microcontrollers 2

1.3 Understand Embedded Systems Architecture 2

1.4 Develop Problem-Solving Skills 2

1.5 Gain Project Management Experience 2

1.6 Enhance Collaboration and Communication Sills 2

1.7 Build a Professional Portfolio 2

Chapter 2 What are Embedded systems and why is this

need to learn?

2.1 High Demand 3

2.2 Diverse Applications 3

2.3 Technical Expertise 3

2.4 Innovation and Problem Solving 3

2.5 . Career Growth Opportunities 3

2.6 Competitive Advantage 3

2.7 Industry Relevance 3

Chapter 3 Modules in the Course 4

Chapter 4 8 Bit Microcontrollers: Architecture of PIC16

Chapter 5 Advanced C Programming 8,9,10

Chapter 6 C Programming with Linked List Data

6.1 Introduction to Linked Lists 11

6.2 Singly Linked Lists 11

6.3 Doubly Linked Lists 11,12

6.4 Operations on Linked Lists 12

6.5 Circular Linked Lists 12

6,6 Memory Management in Linked Lists 12

6.7 Advantages and Disadvantages of Linked List 13

 Chapter 7 Syntax and Structures of C

7.1 Introduction to C Programming 14

7.2 Functions and Pointers 14,15

7.3 Arrays and Strings 15

7.4 Memory Management 15

7.5 Structures and Unions 15,16

7.6 File Handling 16

7.7 Bit Manipulation 16

7.8 Preprocessor Directives 16

Chapter 8 Getting Started with PIC16F1xxx MCUs

using MCC and State Machines

8.1. Understand the Requirements 17

8.2. Set Up Development Environment 17,18

8.3. Develop and Test Individual Modules 18

8.4. Integrate Peripherals and Interfaces 18

8.5. Write and Refactor Code 18,19

8.6. Build and Debug 19

8.7. Test and Verify 19

8.8. Refine and Optimize 19, 20

8.9. Document and Maintain 20

Chapter 9 Advanced Embedded C Tips, Tricks, and Cautions

9.1. Understand the Target Hardware 21

9.2. Optimize Memory Usage 21

9.3. Use Volatile Keyword 22

9.4. Beware of Endianness 22

9.5. Be Mindful of Bit Manipulation 22

9.6. Avoid Busy-Wait Loops 22

9.7. Handle Interrupts Properly 23

9.8. Use Efficient Data Structures 23

9.9. Minimize Function Overhead 23

9.10. Use Appropriate Debugging Tools 23

Chapter 10 C Programming Callbacks

10.1. Introduction to Real-Time Systems 24

10.2. Scheduling Algorithms 25

10.3. Task Synchronization 25

10.4. Interrupt Handling 25,26

10.5. Real-Time Operating System Services 26

10.6. Performance Tuning and Optimization 26

Chapter 11 Design Considerations For Your First IoT Project

11.1. Define the Purpose and Scope 27

 11.2. Choose the Right Hardware 27,28

11.3. Connectivity Options 29

11.4. Data Management 29

11.5. Power Management 29

11.6. Security Considerations 29,30

11.7. Scalability and Flexibility 30

11.8. User Interface and Experience 30

11.9. Testing and Validation 30

11.10. Maintenance and Support 30

Chapter 12 Exploring Bluetooth® Low Energy (BLE)

From First Steps To Final Application

12.1. Introduction to Bluetooth Low Energy (BLE) 32

12.2. BLE Architecture 32

12.3. Setting Up the Development Environment 32

12.4. BLE Profiles and Services 33

12.5. Advertising and Scanning 33

12.6. Establishing Connections 33

12.7. Data Exchange 33,34

12.8. Power Management 34

12.9. Security Considerations 34

12.10. Final Application Development 34,35

Chapter 13 Creating a Sensor Node for Azure IoT Central

13.1. Selecting the Right Hardware 37

13.2. Setting Up the Development Environment 37

 13.3. Connecting to Azure IoT Central 37

13.4. Implementing Secure Communication 37

13.5. Data Acquisition and Processing 38

13.6. Data Transmission 38

13.7. Device Management 38

13.8. Power Management 38

13.9. Data Analytics and Visualization 39

13.10. Scalability and Maintenance 39

Chapter 14 Motor Control Workshop Using dsPIC Digital

Signal Controllers (DSC) Dual Core Devices

14.1. Introduction to Motor Control with dsPIC DSCs 42

14.2 Understanding the dsPIC DSC Architecture 42

14.3. Selecting the Appropriate dsPIC DSC 42

14.4. Setting Up the Development Environment 42

14.5. Motor Control Basics 43

14.6. Implementing PWM for Motor Control 43

14.7. Sensor less Motor Control Technology 43

14.8. Using Quadrature Encoder Interfaces (QEI) 43,44

14.9. Implementing Field-Oriented Control (FOC) 44

14.10. Real-Time Operating Systems (RTOS) for Motor Control 44

14.11. Debugging and Optimization Techniques 44

Chapter 15 Introduction to MPLAB X IDE

15.1. Overview of MPLAB X IDE 47

 15.2. Setting Up MPLAB X IDE 47

15.3. Creating and Managing Projects 47

15.4. Writing and Editing Code 48

15.5. Debugging and Simulation 48

15.6. Advanced Features 48,49

List of Figures

Fig. No. Name of the Figure Page No

4.1 PIC16 Mid-Range Block Diagram 6

11.1 Network Architecture 28

11.2 Five Layer TCPIP Model 28

12.1 PIC BLE Development Board (DT100112) 31

13.1 Steps to Azure Connectivity 36

14.1 Architecture Block Diagram 41

15.1 MPLAB X IDE Software Interface with Hardware Kit 46

Chapter 16 Conclusion 50,51

 Abstract

This report provides an overview of the Embedded Systems Developer

Virtual Internship program, which aims to equip aspiring developers
with practical experience and skills in embedded systems development.
The internship offers participants the opportunity to work on real world
projects remotely, under the guidance of experienced mentors. The
report outlines the objectives of the program, its structure, and the
expected learning outcomes. It highlights the importance of pre-
internship training, project assignments, mentorship, collaboration, and
deliverables. In conclusion, the Embedded Systems Developer Virtual
Internship provides a robust platform for aspiring developers to enhance
their technical skills and prepare for future career opportunities. By
combining theoretical knowledge with practical application, mentorship,
and collaboration, the program ensures that participants are well-
prepared to meet the demands of the embedded systems industry. This
internship serves as a stepping stone for those looking to make a
meaningful impact in the field of embedded systems development.

1
Chapter 1: Course Objectives for the Embedded Systems Developer Virtual
Internship:
1.1 Gain Practical Experience: The primary objective of the virtual internship is to provide
participants with hands-on experience in embedded systems development. Through real-world
projects, interns will have the opportunity to apply theoretical knowledge to practical scenarios,
enhancing their understanding of embedded systems concepts.

1.2. Learn Programming Microcontrollers: One of the key objectives of the internship is to
develop proficiency in programming microcontrollers. Interns will work with popular
microcontroller platforms such as Arduino or Raspberry Pi, learning how to write and debug
code, interface with peripherals, and implement various functionalities.

1.3. Understand Embedded Systems Architecture: The internship aims to familiarize

participants with the architecture and design principles of embedded systems. Interns will learn
about hardware-software co-design, memory management, real-time operating systems, and
other essential aspects of embedded systems development.

1.4. Develop Problem-Solving Skills: Throughout the internship, interns will encounter various
challenges and problems that require them to think critically and develop effective solutions. The
objective is to enhance problem-solving skills, enabling participants to approach complex
embedded systems issues with confidence and creativity.

1.5. Gain Project Management Experience: The internship also focuses on providing interns
with practical experience in project management. Participants will be exposed to the entire
project lifecycle, from requirements gathering to final implementation. They will learn how to
manage tasks, meet deadlines, and collaborate effectively with team members.

1.6. Enhance Collaboration and Communication Skills: Embedded systems development

often involves working in teams and collaborating with different stakeholders. The internship
aims to improve interns' collaboration and communication skills, including the ability to
effectively communicate ideas, work in interdisciplinary teams, and present their work to others.

1.7. Build a Professional Portfolio: By the end of the internship, participants will have
completed several projects and assignments. The objective is to help interns build a professional
portfolio that showcases their skills and experience in embedded systems development, which
can be valuable for future job applications or further education.

2
Chapter 2 : What is embedded systems and why is this need to learn?
Embedded systems are computer systems designed to perform specific tasks within larger
systems or devices. They are found in various domains, including consumer electronics,
automotive, healthcare, industrial automation, and more. Here are some reasons why learning
embedded systems can be beneficial for career growth:

2.1. High Demand: Embedded systems are widely used in various industries, and there is a high
demand for professionals with expertise in designing, developing, and maintaining embedded
systems. This demand is expected to grow as more industries adopt smart devices and Internet of
Things (IoT) technologies.

2.2. Diverse Applications: Embedded systems are used in a wide range of applications, from
simple household appliances to complex automotive systems. Learning embedded systems opens
up opportunities to work on diverse projects and industries, allowing for career versatility and
exploration.

2.3. Technical Expertise: Embedded systems development involves a combination of hardware

and software skills. By learning embedded systems, you gain expertise in areas such as
microcontrollers, programming languages (C/C++), circuit design, firmware development, and
real-time operating systems. These technical skills are highly valued in the job market.

2.4. Innovation and Problem Solving: Embedded systems are at the forefront of technological
advancements. By learning embedded systems, you become part of a field that constantly pushes
the boundaries of innovation. You will work on solving complex problems, optimizing
performance, and developing efficient and reliable systems

2.5. Career Growth Opportunities: As you gain experience and expertise in embedded
systems, you can progress in your career to roles such as embedded systems engineer, firmware
engineer, embedded software developer, IoT engineer, or even move into leadership positions.
With the rapid growth of IoT and smart devices, there area boundant opportunities for career
advancement.

2.6. Competitive Advantage: In today's competitive job market, having specialized skills in
embedded systems can set you apart from other candidates. It demonstrates your ability to work
on complex systems, understand hardware-software interactions, and tackle challenging
technical problems. This can increase your employability and open doors to exciting career
opportunities.

2.7. Industry Relevance: Embedded systems are a critical component of emerging technologies
such as IoT, autonomous vehicles, robotics, and smart devices. By learning embedded systems,
you align yourself with the future of technology and position yourself as a valuable asset to
industries driving these advancements.

3
Chapter 3: Modules in the Course:
The Embedded Systems Developer Virtual Internship consists of a total of 12modules, which are
classified as follows:

Module 1:8 Bit Microcontrollers: Architecture of thePIC16

Module 2: Advanced C Programming

Module 3: Advanced Embedded C Tips, Tricks, and Cautions

Module 4: C Programming Callbacks

Module 5: C Programming: Linked List Data Structures;

Module 6: Creating a Sensor Node for Azure IoT Central

Module 7: Design Considerations For Your First IoT Project

Module 8: Exploring Bluetooth® Low Energy (BLE) From First Steps To Final Application

Module 9: Getting Started with PIC16F1xxx MCUs using MCC and State Machines

Module 10: Introduction To MPLAB® X IDE

Module 11: Motor Control Workshop using dsPIC® Digital Signal Controllers (DSC) Dual Core
Devices

Module 12: Syntax And Structure of C

4
Chapter 4: 8 Bit Microcontrollers: Architecture of the PIC16
Overview: This class will focus on one of our PIC16F1x devices and we will cover its
architecture, memory map, instruction set, interrupt structure and special features. In going
through this class, you will gain a basic understanding of the capabilities of this device family
and how to best utilize a PIC16 in your own application.

Architecture of the PIC16:

The PIC16 series microcontrollers, developed by Microchip Technology, feature an 8-bit
architecture that is widely used in embedded systems. These microcontrollers are known for their
low cost, low power consumption, and ease of use. The architecture of the PIC16 series is based
on a Harvard architecture, which means it has separate program and data memories.

The central processing unit (CPU) is the heart of the PIC16 microcontroller and executes
instructions. It includes an instruction set architecture (ISA) with a wide range of instructions,
including arithmetic, logic, and control instructions. The microcontroller has various registers,
including general-purpose registers (GPRs) for general data storage, special-purpose registers
(SPRs) for specific functions like I/O port control and timers, and file registers.

The program memory stores the instructions that the CPU executes. It is typically non-volatile
and can be Flash or ROM memory, with sizes ranging from 1K to 14K words. The data memory
includes RAM for temporary data storage and EEPROM for non-volatile data storage.

The microcontroller has multiple I/O ports that enable communication with external devices.
These ports can be configured as inputs or outputs and are used for tasks such as reading sensor
data, controlling actuators, and interfacing with peripherals.

There are built-in timers and counters for timing and counting operations, allowing tasks such as
generating delays, measuring time intervals, and generating PWM signals. Interrupts are
supported, allowing for efficient handling of real-time tasks triggered by internal or external
events.

The PIC16 microcontrollers offer a range of on-chip peripherals, including ADCs, DACs,
USARTs, SPI modules, and I2C modules. These peripherals provide additional functionality and
enhance the capabilities of the microcontroller

The PIC16 microcontrollers have a simple and efficient architecture, making them suitable for a
wide range of embedded systems applications.

5
Here is a simplified block diagram of the PIC16 architecture:

Fig 4.1 PIC16 Mid-Range Block Diagram

The PIC16 series microcontrollers, developed by Microchip Technology, feature an 8-bit

architecture widely used in embedded systems due to their low cost, low power consumption,
and ease of use. Here's an in-depth look at the architecture and features of the PIC16 series:

1. Harvard Architecture
 Separate Memory Spaces: The PIC16 microcontrollers use a Harvard architecture,
which means they have separate program and data memory spaces. This allows simultaneous
access to both instruction and data, enhancing performance.
2. CPU and Instruction Set
 Central Processing Unit (CPU): The CPU executes instructions and includes an
Instruction Set Architecture (ISA) that supports various operations, such as arithmetic, logic,
control, and bit-manipulation instructions.

 RISC Architecture: The PIC16 series employs a Reduced Instruction Set Computing
(RISC) architecture, simplifying the instruction set for faster execution.

6
3. Memory Organization
 Program Memory: Typically, non-volatile memory (Flash or ROM) used to store the
program code. Sizes range from 1K to 14K words.
 Data Memory: Comprises RAM for temporary data storage and EEPROM for nonvolatile
data storage.
4. Registers
 General-Purpose Registers (GPRs): Used for general data storage.
 Special-Purpose Registers (SPRs): Used for specific functions like I/O port control,
timers, and status flags.
 File Registers: A part of the data memory used for specific purposes, including GPRs and
SPRs.
5. I/O Ports
 Multiple I/O Ports: These ports allow communication with external devices and can be
configured as inputs or outputs. They are used for reading sensor data, controlling actuators,
and interfacing with peripherals.
6. Timers and Counters
 Built-in Timers and Counters: Used for timing and counting operations, generating
delays, measuring time intervals, and producing PWM signals.
7. Interrupts
 Interrupt Handling: The PIC16 microcontrollers support interrupts, which enable
efficient handling of real-time tasks triggered by internal or external events.
8. On-Chip Peripherals
 Analog-to-Digital Converters (ADCs)
 Digital-to-Analog Converters (DACs)
 Universal Synchronous Asynchronous Receiver Transmitters (USARTs)
 Serial Peripheral Interface (SPI) Modules
 Inter-Integrated Circuit (I2C) Modules These peripherals enhance the microcontroller's
functionality, making it suitable for various applications.
9. Power Management
 Low Power Consumption: Designed for applications requiring efficient power usage, the
PIC16 microcontrollers often feature multiple power-saving modes.
10. Development Tools
 MPLAB® X IDE: An Integrated Development Environment (IDE) provided by
Microchip for developing applications on PIC microcontrollers.
 MPLAB Code Configurator (MCC): A graphical programming tool that simplifies
peripheral setup and code generation.

7
Chapter 5 : Advanced in C Programming
Overview: Take your C programming skills to new heights! The objective of this class is to
enable you to use advanced C programming language constructs and techniques to create
more structured and portable code. You will be able to create structures, unions, and bit
fields. You will use advanced pointer concepts to allow very flexible data access and create
arrays of pointers, arrays of structures and unions, and pointers to arrays of structures and
unions. You will create nested structures and unions along with flexible „typedef‟ methods
to set up data structures and variables. Function pointers are an important concept of the C
programming language and you will use arrays and structures of function pointers to create
portable and flexible state machines. Dereferenced double pointers are discussed in detail.
This class includes 7 instructor-led hands-on labs that clearly demonstrate each concept. You
will use MPLABX® with the powerful built-in simulator and Microchip's XC32 compiler to
analyze the actual effect of coding implementations on variables and to see the interaction of
program and data memory values. You will learn these C language topics from a non-
hardware framework so that you can focus on learning the C language instead of the
microcontroller architecture. The techniques taught in this class are universal ANSI-C
concepts of the C programming language. Before attending this class, attendees should be
proficient with the fundamentals of C programming and have experience writing embedded
C firmware.

This module aims to enhance your skills in writing efficient and optimized code for
microcontrollers. The module covers several key topics, including:
Memory Management: Understanding memory organization in embedded systems, including
the use of stack and heap memory, and techniques for efficient memory allocation and
deallocation.

Pointers and Data Structures: Exploring advanced pointer concepts and their applications in
data structures like linked lists, queues, and stacks. You will learn how to implement and
manipulate these data structures efficiently in embedded systems.

Bit Manipulation: Understanding bitwise operations and their significance in embedded

systems programming. This includes using bitwise operators for efficient memory usage, bit-
level manipulation of registers, and implementing device drivers.

Interrupt Handling: Understanding the concept of interrupts, their importance in real- time
systems, and how to handle them effectively. You will learn how to write interrupt service
routines (ISRs) and handle nested interrupts.

8
Low-Level I/O Programming: Exploring low-level I/O techniques for reading from and
writing to hardware peripherals, such as GPIO (General Purpose Input/Output) ports, timers,
and UART (Universal Asynchronous Receiver-Transmitter) interfaces.

Throughout the module, you will have hands-on coding exercises and projects to reinforce
your learning. These exercises will involve implementing various algorithms and techniques
using the C programming language, specifically focused on embedded systems. By the end
of the module, you will have gained proficiency in advanced C programming techniques
essential for embedded systems development. You will be able to write optimized code,
efficiently manage memory, manipulate bits, handle interrupts, and interface with hardware
peripherals effectively.

Advanced C Programming Techniques

1. Memory Management and Dynamic Data Structures
 Dynamic Memory Allocation: Understanding and using functions like malloc, calloc,
realloc, and free to manage memory dynamically. This is crucial for applications that
require variable-sized data structures or need to handle large amounts of data efficiently.
 Memory Leaks and Debugging: Techniques for detecting and preventing memory
leaks, such as using tools like Valgrind or address sanitizers.
2. Advanced Use of Pointers
 Pointer Arithmetic: Mastering pointer arithmetic to navigate and manipulate arrays
and memory blocks efficiently.
 Pointer to Functions: Utilizing pointers to functions for implementing callback
mechanisms and dynamic function calls, which can lead to more modular and flexible
code.
3. Data Structures and Algorithms
 Linked Lists: Implementing and manipulating singly linked lists, doubly linked lists,
and circular linked lists for dynamic data management.
 Trees and Graphs: Implementing binary trees, binary search trees, AVL trees, and
graph data structures, including depth-first search (DFS) and breadth-first search (BFS)
algorithms.
 Hash Tables: Creating and using hash tables for efficient data retrieval and storage.
4. Concurrency and Multithreading
 Thread Management: Using libraries like pthreads (POSIX threads) to create and
manage threads in a C program, allowing concurrent execution and improved
performance in multi-core systems.
 Synchronization Mechanisms: Implementing mutexes, semaphores, and condition
variables to synchronize access to shared resources and prevent race conditions.

9
5. Bitwise Operations
 Efficient Bit Manipulation: Using bitwise operators for efficient data processing,
such as setting, clearing, toggling, and checking specific bits in a variable. This is
especially useful in embedded systems for register manipulation and flag management.
 Bit Fields in Structures: Defining and using bit fields within structures to compactly
represent data that spans multiple bits, saving memory and simplifying code.
6. Inline Assembly
 Embedding Assembly Code: Integrating assembly code within C programs for
performance-critical sections, allowing for fine-grained control over hardware and
optimized execution.
7. Code Optimization Techniques
 Compiler Optimizations: Leveraging compiler optimization flags and pragmas to
improve the performance and efficiency of the generated machine code.
 Algorithmic Optimizations: Applying algorithmic improvements and best practices to
reduce time complexity (e.g., using more efficient sorting algorithms or data structures).
8. Portability and Standardization
 Writing Portable Code: Ensuring code can be compiled and run on different
platforms by adhering to ANSI C standards and avoiding platform-specific features.
 Conditional Compilation: Using preprocessor directives (#ifdef, #ifndef, #if, #else,
#endif) to include or exclude code segments based on compilation conditions, enhancing
portability and configurability.
9. Debugging and Profiling
 Advanced Debugging Techniques: Using advanced features of debuggers (like GDB)
for setting watchpoints, examining memory, and debugging multi-threaded applications.
 Profiling Tools: Employing profiling tools (such as gprof or perf) to analyze the
performance of your code, identify bottlenecks, and optimize resource usage.
10. Design Patterns in C
 Creational Patterns: Implementing singleton, factory, and builder patterns to manage
object creation and initialization.
 Structural Patterns: Utilizing adapter, bridge, and composite patterns to create
flexible and maintainable code structures.
 Behavioural Patterns: Applying strategy, observer, and state patterns to manage
algorithms, communication, and state transitions within your programs.
Practical Applications and Examples
 Embedded Systems: Applying these advanced techniques to develop efficient and
reliable firmware for microcontrollers and embedded devices.
 System Programming: Writing low-level system software, such as operating system
kernels, device drivers, and system utilities.

10
Chapter 6: C Programming with Linked List Data Structures
Overview: When you complete this class you will be able to create a PIC16F1xxx
application from scratch using State Machines, MPLAB® X and MPLAB Code
Configurator (MCC). You will be able to configure GPIO, Timer, USART and ADC using
MCC.
Using a State Machine format, we will create our PIC16F1619 Application on a Curiosity
Demo Board using MPLABX IDE. We will use MPLAB Code Configurator (MCC) to
Initialize our System and Interface Hardware. The Application will involve step-by-step
creation of our code.

1. Starting with blinking an LED at a half sec rate.

2. Using a push-button switch (key) to start/stop the blinking.
3. USART for serial communication to display “Hello World!” on tera term
4. ADC input from a potentiometer, displaying value of the potentiometer on Tera Term.

C Programming with Linked List Data Structures module focuses on teaching participants
about linked list data structures and their implementation in the C programming language.
Let's break down each topic within this module:

6.1 Introduction to Linked Lists

 Use Cases: Linked lists are preferred when the size of the data structure is unknown or
changes frequently. They are commonly used in dynamic memory allocation,
implementation of stacks and queues, and in applications like managing the sequence of
items (like in a to-do list).
 Variations: Beyond singly, doubly, and circular linked lists, other variations include skip
lists and unrolled linked lists, which are optimized for specific use cases such as search
operations and reducing overhead in storing data.

6.2 Singly Linked Lists

 Memory Overheads: While singly linked lists are memory-efficient due to having only
one pointer per node, they do have overhead in terms of extra space for pointers compared to
arrays.
 Traversal Techniques: In addition to the basic traversal techniques, advanced methods
like using fast and slow pointers can help detect cycles within linked lists efficiently.

6.3 Doubly Linked Lists

 Doubly linked lists are an extension of singly linked lists, where each node contains a data
element, a pointer to the next node, and a pointer to the previous node. This topic covers the

11
implementation and manipulation of doubly linked lists, including node insertion, deletion,
and traversal.
 Implementation Tips: While implementing doubly linked lists, care must be taken to
update both the previous and next pointers during insertion and deletion operations to
maintain the integrity of the list.
 Use Cases: Doubly linked lists are particularly useful in applications where bidirectional
traversal is required, such as in the implementation of LRU (Least Recently Used) cache and
in many undo-redo functionalities in software applications.

6.4 Circular Linked Lists

 Circular linked lists are similar to singly or doubly linked lists, but the last node points
back to the first node, creating a circular structure. Participants will learn how to create,
traverse, insert, and delete nodes in a circular linked list.
 Advantages: Circular linked lists provide a seamless way to go through the list from the
end back to the beginning, which can simplify certain algorithms and processes, such as in
round-robin scheduling.
 Implementation Considerations: Special care is needed to handle the base case of a
single-node list, ensuring the single node points to itself to maintain the circular nature.

6.5 Operations on Linked Lists

 Advanced Operations: Beyond the basic operations, linked lists can be used to implement
more complex data structures like balanced binary trees (using threaded binary trees) or
graph representations (adjacency lists).
 Algorithmic Optimization: Efficiently performing operations like sorting linked lists can
be enhanced using algorithms like Merge Sort, which is well suited for linked lists due to
their non-contiguous memory allocation.

6.6 Memory Management in Linked Lists

 Memory management is an important aspect of linked list implementation. Participants
will learn about dynamically allocating memory for linked list nodes using functions like
malloc () and free (). They will also understand how to handle memory deallocation when
deleting nodes.
 Advanced Allocation: Techniques such as memory pooling or slab allocation can be used
to optimize memory management for linked lists, reducing the overhead and fragmentation
caused by frequent allocations and deallocations.
 Garbage Collection: In environments where manual memory management is prone to
errors, using automatic garbage collection can help manage the memory of dynamically
allocated linked lists safely.

12
6.7 Advantages and Disadvantages of Linked Lists
 Linked lists have their own advantages and disadvantages compared to other data
structures. Participants will learn about the pros and cons of linked lists, including their
efficient insertion and deletion operations but slower random access time.
 Advanced Considerations: While linked lists offer flexibility and ease of insertion and
deletion, their poor cache performance due to non-contiguous memory access can be a
significant disadvantage in high-performance applications. Optimizations like array-based
linked lists or hybrid structures can sometimes provide a middle ground.
 Real-World Applications: Linked lists are extensively used in various real world
applications such as dynamic memory allocators, managing free memory blocks (free lists),
and in operating systems for managing processes and tasks in scheduling algorithms.

13
Chapter 7: Syntax and Structures of C

Overview: This class will enable you to begin writing embedded C language firmware for
microcontrollers. Most major C language constructs will be covered, including variables,
constants, operators, expressions and statements, decision functionality, loops, functions,
arrays, multi-file projects, and data pointers. You will learn all of these C language topics
from a non-hardware framework so that you can focus on learning the C language instead of
the microcontroller architecture.
The presentation will be accompanied by instructor-led code demonstrations that will be
conducted with the powerful MPLAB® simulator. Skills learned in this class will be
applicable to any ANSI C compiler. At the end of the class, you will have the opportunity to
apply your knowledge to program a microcontroller to perform basic input and output
functionality and control. You will also use the MPLAB X IDE to perform actual debugging
on a microcontroller and execute some basic debugging techniques. While not required,
previous experience with any programming language or experience with microcontrollers
would be helpful.

7.1 Introduction to C Programming

In addition to the basics, advanced C programming often involves understanding the
underlying hardware. This includes knowledge about:
 This topic provides an overview of the C programming language and its importance in
embedded systems development. Participants will learn about the basic syntax, data types,
variables, operators, and control flow statements in C.
 Memory Architecture: Understanding the different types of memory (RAM, ROM,
EEPROM) and their usage in embedded systems.
 Optimization Techniques: Techniques such as loop unrolling, inlining functions, and
using register variables to optimize code performance.
 Embedded Constraints: Handling constraints like limited memory and processing power
in embedded systems.

7.2 Functions and Pointers

 Participants will learn about functions, which are fundamental building blocks in C
programming. They will understand how to define and use functions, pass arguments, and

14
return values. Additionally, the topic covers pointers, which are variables that store memory
addresses. Participants will learn how to declare, initialize, and use pointers in their code.
 Function Pointers: These allow you to store the address of a function in a variable,
enabling dynamic function calls and creating function tables for state machines.
 Pointer Arithmetic: Understanding how to perform arithmetic operations on pointers to
navigate through arrays and data structures efficiently.
 Memory Management: Deep dive into dynamic memory management, including
implementing custom memory allocators for better control over memory usage.

7.3 Arrays and Strings

 This topic focuses on arrays and strings in C. Participants will learn how to declare,
initialize, and access array elements. They will also understand how to manipulate strings
using various string handling functions provided by the C language.
 Multidimensional Arrays: Utilizing arrays of arrays for complex data representations,
such as matrices.
 String Manipulations: Advanced techniques for handling and manipulating strings,
including creating custom string functions for specific needs.
 Data Alignment: Ensuring that data structures are aligned in memory for optimal access
speed.

7.4 Memory Management

 Memory management is a crucial aspect of embedded systems development. In this topic,
participants will learn about the different memory regions in an embedded system, such as
stack and heap. They will understand how to allocate and deallocate memory dynamically
using functions like malloc() and free().
 Memory Pools: Implementing and managing memory pools for efficient memory
allocation and deallocation.
 Garbage Collection: Techniques for manual garbage collection in embedded systems
where automated garbage collection is not available.
 Fragmentation Handling: Strategies to handle and minimize memory fragmentation over
time.

7.5 Structures and Unions

 Structures and unions are used to create complex data types in C. Participants will learn
how to define and use structures to group related variables together. They will also
understand unions, which allow different variables to share the same memory space.
 Bitfields in Structures: Using bitfields within structures to save memory when storing
flags and small integers.

15
 Packed Structures: Creating packed structures to ensure data is stored with minimal
padding, which is crucial in memory-constrained environments.
 Type Safety: Advanced techniques to maintain type safety while using unions and
structures.

7.6 File Handling

 File handling is essential for reading from and writing to files in an embedded system.
Participants will learn about file handling operations in C, such as opening, reading, writing,
and closing files. They will also understand how to handle errors during file operations.
 Binary File Operations: Handling binary files for efficient storage and retrieval of non-
text data.
 File Buffers: Implementing file buffers to improve the efficiency of file I/O operations.
 Error Handling: Robust error handling strategies for dealing with various file I/O errors.

7.7 Bit Manipulation

 Bit manipulation involves manipulating individual bits or groups of bits in variables.
Participants will learn about bitwise operators and how to perform various bit-level
operations, such as setting, clearing, toggling, and shifting bits.
 Bitwise Operations: Advanced usage of bitwise operators to implement features like
encryption, checksums, and data compression.
 Bit Masks: Creating and using bit masks to isolate and manipulate specific bits within a
byte or word.
 Performance Considerations: Ensuring bit manipulation operations are performed
efficiently, especially in time-critical applications.

7.8 Preprocessor Directives

 This topic focuses on handling errors and debugging techniques in C programming.
Participants will learn how to handle runtime errors, use debugging tools, and write code
that facilitates error detection and resolution.
 Conditional Compilation: Using preprocessor directives for conditional compilation to
include or exclude code based on specific conditions.
 Macros: Advanced usage of macros to create reusable code snippets and improve code
readability.
 Code Optimization: Utilizing preprocessor directives for optimizing code compilation
and execution.

16
Chapter 8: Getting Started with PIC16F1xxx MCUs using MCC
and State Machines

Overview: When you complete this class, you will be able to create a PIC16F1xxx
application from scratch using State Machines, MPLAB® X and MPLAB Code
Configurator (MCC). You will be able to configure GPIO, Timer, USART and ADC using
MCC.
Using a State Machine format, we will create our PIC16F1619 Application on a Curiosity
Demo Board using MPLABX IDE. We will use MPLAB Code Configurator (MCC) to
Initialize our System and Interface Hardware.

The Application will involve step-by-step creation of our code.

1. Starting with blinking an LED at a half sec rate.
2. Using a push-button switch (key) to start/stop the blinking.
3. USART for serial communication to display “Hello World!” on tera term
4. ADC input from a potentiometer, displaying value of the potentiometer on Tera Term.

Getting started with PIC16F1xxx MCUs (Microcontrollers) using the MPLAB Code
Configurator (MCC) and state machines can simplify the development process. Here is a
step-by-step guide to help you get started:

8.1. Understand the Requirements

 Download and install MPLAB X IDE from Microchip's website.
 Install the compiler and Integrated Development Environment (IDE) plugins, such as XC8
compiler and MPLAB Harmony Configurator (MHC).
 Connect the PIC16F1xxx MCU to your development board or programmer.
 Code Documentation: Beyond just writing clear comments, maintaining comprehensive
design documents that outline the code architecture, data flow, and interaction between
different modules is crucial. Tools like Doxygen can help generate documentation directly
from annotated code.
 Design Patterns: Utilize design patterns such as Singleton for managing hardware
resources, Factory for creating peripheral instances, and Observer for event handling to
improve code maintainability and scalability.

8.2. Set Up Development Environment

 Launch MPLAB X IDE and create a new project.
 Select the appropriate PIC16F1xxx MCU from the device database.
 Choose the XC8 compiler as the toolchain.

17
 Version Control: Employ version control systems (VCS) like Git for tracking changes
and collaboration. Implement branching strategies (e.g., Git Flow) to manage development,
testing, and production branches.
 Automated Builds: Use Continuous Integration (CI) tools like Jenkins or GitHub Actions
to automate builds and run tests. This ensures early detection of integration issues.

8.3. Develop and Test Individual Modules

 Open the MPLAB Code Configurator (MCC) from the Tools menu in MPLAB X IDE.
 Use MCC to configure the peripherals, pins, and other settings of the PIC16F1xxx MCU.
 Configure the required peripherals for your project, such as GPIO, UART, SPI, I2C, etc.
 Generate the initialization code based on your configuration
 Test-Driven Development (TDD): Apply TDD practices by writing tests before
developing the corresponding modules. This helps in identifying edge cases early and
ensures that the code meets the requirements.
 Code Reviews: Conduct regular code reviews using platforms like Gerrit or GitHub Pull
Requests to improve code quality and share knowledge within the team.

8.4. Integrate Peripherals and Interfaces

 Identify the different states and transitions required for your application.
 Create a state machine diagram to visualize the flow and behavior of your application.
 Implement the state machine logic using switch-case or if-else statements in your code.
 Write code to handle state transitions, input events, and output actions.
 Peripheral Libraries: Utilize HAL (Hardware Abstraction Layer) libraries provided by
the MCU manufacturer to simplify peripheral integration. These libraries abstract hardware
details and provide a consistent API across different MCUs.
 Communication Protocols: Implement robust communication protocols with error
checking and recovery mechanisms. For instance, use CRC (Cyclic Redundancy Check) for
data integrity and implement retransmission strategies for error correction.

8.5. Write and Refactor Code

 Start writing the application code based on the generated MCC initialization code and the
state machine design.
 Implement the state machine transitions and actions based on the events and conditions in
your application.
 Integrate peripherals and handle interrupts as necessary.
 Use the MCC-generated functions or libraries to interact with peripherals.

18
 Code Metrics: Use tools like SonarQube to analyse code quality metrics such as
cyclomatic complexity, code duplication, and potential bugs. Regularly refactor code to
address issues identified by these tools.
 Coding Standards: Adhere to coding standards such as MISRA C for safety-critical
systems. This reduces the likelihood of introducing bugs and ensures consistent coding
practices across the team.

8.6. Build and Debug

 Build the project to compile the code and generate the hex file.
 Use the debugging tools provided by MPLAB X IDE to debug your application.
 Set breakpoints, step through the code, and monitor variables to identify and fix any issues.
 Use debugging features like watch windows and call stacks to understand the program
flow.
 Profiling: Utilize profiling tools to measure code performance and identify bottlenecks.
Tools like grove or built-in profilers in IDEs can provide insights into function execution
times and memory usage.
 Advanced Debugging: Use advanced debugging techniques such as real-time tracing,
which allows monitoring of system behaviour without halting the program. Tools like
Tracealyzer can help visualize task execution and timing.

8.7. Test and Verify

 Flash the compiled code onto the PIC16F1xxx MCU using a programmer or debugger.
 Connect the MCU to the target hardware or development board.
 Test the functionality of your application and verify its behavior against the expected
results.
 Use debugging tools, logic analyzers, or oscilloscopes to monitor and analyzethe MCU's
behavior.
 Unit Testing: Develop unit tests for individual functions and modules using frameworks
like Unity or CMock. Automate these tests to run with every build to ensure code reliability.
 Hardware-in-the-Loop (HIL): Implement HIL testing where the developed code
interacts with real or simulated hardware to verify the system's behaviour under different
conditions.

8.8. Refine and Optimize

 Analyze your code for any performance bottlenecks or areas of improvement.
 Optimize the code for efficiency, resource utilization, and power consumption.
 Consider using low-power modes or sleep modes to conserve energy when the MCU is
idle.

19
 Refactor the code to improve readability, maintainability, and modularity.
 Compiler Optimizations: Use compiler optimization flags to improve code performance.
Understand the trade-offs between different optimization levels (e.g., - O2 for balanced
optimization and -O3 for maximum speed).
 Energy Efficiency: Apply techniques such as dynamic voltage and frequency scaling
(DVFS) to reduce power consumption. Use power profiling tools to measure and optimize
energy usage.

8.9. Document and Maintain

 Document your code, including comments, to make it easier to understand and maintain.
 Update the documentation with any modifications or additions to the code.
 Maintain a version control system to track changes and collaborate with other developers.
 Stay updated with the latest firmware updates, libraries, and tools provided by Microchip.
 Code Documentation: Regularly update documentation to reflect changes in the code.
Use tools like Sphinx or Mk Docs to create and maintain comprehensive project
documentation.
 Knowledge Sharing: Establish regular knowledge-sharing sessions within the team to
discuss new techniques, tools, and best practices. Create a shared repository of resources and
examples for future reference. Remember to refer to the PIC16F1xxx MCU datasheet,
reference manual, and other documentation provided by Microchip for detailed information
about the MCU's features, registers, and programming guidelines. Experiment with different
MCC configurations and state machine designs to optimize your application for your
specific requirements.

20
Chapter 9: Advanced Embedded C Tips, Tricks, and Cautions

Overview: Even if you have a good base knowledge of more advanced C programming
concepts, this class will challenge you on some things you may not know about
programming in C and help to take your programming skills to new levels! There are so
many things you can do with your C programming projects that will reduce your code size,
improve execution time, and keep you out of trouble! We will look at some common
mistakes that are made by even the best programmers, including comparison and value
setting confusion, neglecting implicit conversions and sequence points, mixing variable
types, misusing macros, and ignoring side effects. This course will also show you some nice
concepts to help reduce your code size and make your projects easier to read. These
concepts include header file inclusion, using typedefs for function pointers and structures,
performing floating point math without hardware floating point units or firmware libraries,
and initializing and clearing structures and unions. This material is presented with the
assumption that you are already familiar with advanced C programming concepts.

When working with embedded systems and writing code in C, it's important to keep
in mind some advanced tips, tricks, and cautions to ensure efficient code execution,
maintainability, and reliability. Here are some key points to consider:

9.1. Understand the Target Hardware

 Gain a thorough understanding of the target hardware, including the microcontroller's
architecture, memory organization, and peripheral functionalities. This knowledge will help
you write optimized and efficient code.
 Microcontroller Variants: Beyond understanding the general architecture, be familiar
with specific variants of the microcontroller you are using, as different variants can have
unique features and limitations.
 Peripheral Integration: Learn how different peripherals (ADC, DAC, USART, etc.)
interact with the CPU and how to optimize their usage in your applications.

9.2. Optimize Memory Usage

 Embedded systems often have limited memory resources. To optimize memory usage: -
Minimize global variables and use local variables whenever possible. - Avoid unnecessary
memory allocations, especially dynamic memory allocation (malloc/free). - Carefully
manage stack usage, as excessive stack usage can lead to stack overflow.
 Memory Pools: Use memory pools to manage dynamic memory allocation efficiently and
avoid fragmentation.
 Static Allocation: Where possible, prefer static memory allocation to dynamic allocation
to minimize overhead and avoid runtime memory issues.

21
9.3. Use Volatile Keyword
 Use the `volatile` keyword for variables that can be modified by hardware interrupts or
other threads. This ensures that the compiler doesn't optimize away reads or writes to these
variables, guaranteeing their correctness.
 Memory-Mapped Registers: Ensure volatile is used for memory-mapped peripheral
registers to prevent the compiler from optimizing out necessary reads/writes.
 Concurrency: Use volatile in conjunction with proper synchronization mechanisms in
multi-threaded or interrupt-driven code to maintain data integrity.

9.4. Beware of Endianness

 Be aware of the endianness (byte order) of the target hardware. Ensure that your code
handles data correctly when dealing with multi-byte variables or when communicating with
other systems.
 Data Serialization: When transmitting data between systems of different endianness,
serialize and deserialize data properly using well-defined formats (e.g., big-endian or little-
endian).
 Cross-Platform Compatibility: Write code that can adapt to different endianness settings
if it might be used on different hardware platforms.

9.5. Be Mindful of Bit Manipulation

 Be Mindful of Bit Manipulation: Embedded systems often require bit-level operations.
When manipulating individual bits, use bitwise operators (`&`, `|`, `^`, `<>`) and bit masks
to ensure efficient and correct bit manipulation.
 Atomic Operations: Ensure that bit manipulations on shared variables are atomic to
prevent race conditions, especially in interrupt service routines (ISRs) or multithreaded
environments.
 Macro Functions: Use macro functions to encapsulate bit manipulations, making your
code more readable and maintainable.

9.6. Avoid Busy-Wait Loops

 Busy-wait loops (infinite loops that continuously check a condition) can waste CPU cycles
and impact system performance. Instead, use interrupts, timers, or sleep modes to reduce
power consumption and allow the processor to perform other tasks.
 Event-Driven Programming: Implement event-driven programming techniques using
interrupts and hardware timers instead of busy-wait loops to improve efficiency.
 Low-Power Modes: Utilize the microcontroller’s low-power modes effectively to save
power when the system is idle.

22
9.7. Handle Interrupts Properly
 Handle interrupts carefully to ensure the proper execution of critical code. Keep interrupt
service routines (ISRs) short and avoid time-consuming operations within ISRs. Use proper
interrupt prioritization and nesting if supported by the hardware.
 Nested Interrupts: Understand the microcontroller’s support for nested interrupts and
configure priorities correctly to avoid deadlocks or missed interrupts.
 Context Saving: Ensure that the interrupt service routines (ISRs) save and restore the
necessary context to prevent corruption of the main program flow.

9.8. Use Efficient Data Structures

 Employ static analysis tools to catch potential coding issues, such as uninitialized
variables, memory leaks, or buffer overflows. These tool scan help identify potential bugs
and improve code quality.
 Circular Buffers: Implement circular buffers for efficient data storage and retrieval in
applications like UART communication.
 Linked Lists: Use linked lists for managing dynamic data collections, especially when the
size of the data set can vary significantly at runtime.

9.9. Minimize Function Overhead

 Thoroughly test your code on the target hardware, covering different scenarios and edge
cases. Use unit tests, integration tests, and hardware-in-the-loop testing to verify the
correctness and reliability of your code.
 Inline Functions: Use inline functions where appropriate to reduce function call overhead
and improve execution speed.
 Function Pointers: Implement function pointers for creating flexible and efficient state
machines, especially in applications with complex control logic.

9.10. Use Appropriate Debugging Tools

 Document your code and provide clear comments to improve code understandability and
maintainability. Describe the purpose of functions, variables, and complex algorithms,
making it easier for other developers to understand and modify the code in the future.
Remember, embedded systems development requires attention to detail, efficient resource
utilization, and careful consideration of hardware constraints.
 Simulation Tools: Utilize simulation tools provided by the microcontroller's development
environment to test and debug code before deployment.
 Profiling Tools: Use profiling tools to identify performance bottlenecks and optimize code
execution time.

23
Chapter 10: C Programming Callbacks

Overview: Callback functionality is an important concept in embedded programming.

Callbacks allow you to create more flexible and modular functions and enable you to
separate hardware and software operations. They also allow for multiple programmers to
work on a project and provide code to be combined with the main application program. You
can use different callback implementations to reduce your code execution bandwidth and
enable faster and more flexible response to any microcontroller pin or peripheral condition.
In this course, you will be able to explain the components of a callback. You will be able to
use callbacks in both polled and interrupt environments. You will learn how to create library
and object files that can be incorporated into your application program with the use of
callbacks. You will be able to construct very flexible callback structures. Callbacks are a
powerful application of pointers that access functions, so you do need to have a good
understanding of function pointers and the C programming language.

The C Programming Callbacks module in an Embedded Systems Developer Virtual

Internship would typically cover the concept of callbacks in the context of embedded
systems programming. It would provide hands-on exercises and projects to help you
understand and apply the concept in real-world scenarios. Here's an example of what you
might expect to learn and do in such a module:

10.1. Introduction to Real-Time Systems

 The module would start with an introduction to call backs in the context of embedded
systems development. You would learn about the purpose and benefits of using callbacks in
embedded systems programming.

 Real-Time Operating Systems (RTOS): Learn about various RTOS like Free RTOS,
VxWorks, and RTEMS. Understand their architectures, task scheduling algorithms, and how
they handle real-time constraints.

 Types of Real-Time Systems: Differentiate between hard real-time and soft real-time
systems. Hard real-time systems have strict timing constraints (e.g., automotive systems),
while soft real-time systems can tolerate some delays (e.g., multimedia systems).

24
10.2. Scheduling Algorithms
 You would learn about function pointers in C, which are essential for implementing
callbacks. You would understand how function pointers work and how to declare and use
them in your code.

 Rate Monotonic Scheduling (RMS): RMS is a fixed-priority algorithm where tasks with
shorter periods are given higher priority. It’s suitable for periodic tasks.

 Earliest Deadline First (EDF): EDF dynamically assigns priorities based on the closest
deadline. This algorithm is optimal for both periodic and aperiodic tasks.

 Least Laxity First (LLF): LLF schedules tasks based on their laxity (the difference
between the deadline and remaining computation time). This approach is useful in handling
dynamic task priorities.

10.3 Task Synchronization

 You would learn how to define and implement callback functions in C. You would
understand the syntax and conventions for writing callback functions and how to pass them
as arguments to other functions.

 Semaphores: Use semaphores for signaling and mutual exclusion. Binary semaphores
(mutexes) are for locking resources, while counting semaphores manage access to a pool of
resources.

 Event Flags: Event flags allow tasks to wait for specific conditions to be met before
proceeding. This mechanism is useful for synchronizing tasks based on complex events.

 Message Queues: Message queues enable inter-task communication by allowing tasks to

send and receive messages. This method is suitable for decoupling tasks and ensuring data
integrity.

10.4 Interrupt Handling

 The module would cover different callback mechanisms commonly used in embedded
systems development, such as interrupt callbacks, event-driven callbacks, and timer
callbacks. You would learn how to set up and handle these callbacks in your code.

 Interrupt Latency: Minimize interrupt latency by keeping Interrupt Service Routines

(ISRs) short and efficient. Prioritize critical interrupts and use nested interrupts if supported
by the hardware.

25
 Deferred Interrupt Processing: Use deferred interrupt processing techniques like bottom
halves or task lets to handle non-critical tasks outside of the ISR context, reducing ISR
execution time.

 Interrupt Priorities: Configure interrupt priorities based on the criticality of tasks. Ensure
that high-priority interrupts are not blocked by lower-priority ones.

10.5. Real-Time Operating System Services

 The module would include hands-on projects and exercises to reinforce your understanding
of callbacks in embedded systems programming. You would work on practical examples and
implement callbacks in real-world scenarios, such as handling hardware interrupts or
responding to external events.

 Task Management: RTOS services for creating, deleting, suspending, and resuming tasks.
Understand task states (running, ready, blocked) and context switching.

 Time Management: Use RTOS time management services for implementing delays,
timeouts, and periodic task execution. Understand the tick rate and its impact on system
performance.

 Memory Management: Implement memory pools and partitioned memory to efficiently

manage dynamic memory allocation in real-time systems.

10.6. Performance Tuning and Optimization

 The module would also cover best practices and considerations when using callbacks in
embedded systems development. You would learn about topics like callback design patterns,
memory management, and thread safety.

 Profiling and Benchmarking: Use profiling tools to measure task execution times,
context switch times, and interrupt latencies. Benchmark the system under different load
conditions to identify performance bottlenecks.

 Code Optimization: Optimize code by reducing the complexity of algorithms, minimizing

context switches, and using efficient data structures. Ensure that critical code paths are
highly optimized.

 Power Management: Implement power management strategies like dynamic voltage and
frequency scaling (DVFS) to reduce power consumption. Use sleep modes and wake-up
sources to manage energy efficiently.

26
Chapter 11: Design Considerations for Your First IoT Project
Overview: In the Internet of Things, the Things must conform to the Internet, not the other
way around. If you’re just dipping your toes into the IoT, this class is for you. Adding
network connectivity to an embedded product is complex. This class will explore the
foundations of Internet communication. Routers, switches, IP and hardware addressing,
DHCP, NAT, TCP and UDP transport layers, ports, sockets, and DNS will be explained.
The MQTT eco-system will be described, including the pub/sub model, brokers, topics, and
the JSON data structure. Lastly, tools for analyzing these packets and data structures will be
demonstrated (e.g. Wireshark). This class is meant for the engineer who has no problem
setting up their own home network, but has not necessarily explored the detailed
requirements for an IoT device to exchange data with an internet resource.

Designing an IoT project requires careful consideration of various factors to ensure its
successful implementation. Here are some key design considerations for your first IoT
project module in an Embedded Systems Developer Virtual Internship:

11.1 Define the Purpose and Scope

 Clearly define the requirements of your IoT project, including the desired functionalities,
data collection, and communication protocols. Specify the hardware and software
components needed for the project.

 Stakeholder Analysis: Identify all stakeholders and their requirements early in the project.
Understand their expectations, and define clear objectives and success criteria.

 Use Case Scenarios: Develop detailed use case scenarios that describe how users will
interact with the IoT system. This helps in understanding the user journey and identifying
potential challenges.

11.2. Choose the Right Hardware

 Choose a suitable IoT platform that supports your project's requirements. Consider factors
such as scalability, security, ease of integration, data analytics capabilities, and cloud
connectivity options.

 Microcontroller vs. Microprocessor: Decide whether a microcontroller (e.g., ESP8266,

PIC, AVR) or a microprocessor (e.g., Raspberry Pi, BeagleBone) is suitable for your
application based on processing power, power consumption, and cost.

27
 Sensor Selection: Select sensors based on accuracy, range, and power requirements.
Consider environmental conditions (e.g., temperature, humidity) and sensor calibration
needs.

Fig 11.1 Network Architecture

Fig 11.2 Five Layer TCPIP Model

28
11.3. Connectivity Options
 Determine the appropriate connectivity options for your IoT devices. Common choices
include Wi-Fi, Bluetooth, Zigbee, LoRa WAN, cellular networks (2G/3G/4G/5G), or a
combination of these technologies. Select the connectivity option based on factors like
range, power consumption, and data transmission requirements.
 Protocols and Standards: Beyond Wi-Fi and Bluetooth, consider other protocols like
Zigbee, Z-Wave, LoRa WAN, and NB-IoT for specific use cases, especially in terms of
range, data rate, and power consumption.
 Network Topology: Decide on the network topology (star, mesh, hybrid) based on the
scale of deployment and reliability requirements. Mesh networks, for instance, provide
better reliability and coverage for large areas.

11.4. Data Management

 Efficient power management is crucial for IoT devices, especially those running on
batteries. Optimize power consumption to extend device battery life. Consider power saving
techniques like sleep modes, duty cycling, and using low-power components.
 Edge Computing: Implement edge computing to process data locally on the device,
reducing latency and bandwidth usage. This is particularly useful for time-sensitive
applications.
 Data Storage: Choose appropriate storage solutions, such as local storage on SD cards for
small projects or cloud storage for scalable solutions. Ensure data integrity and backup
strategies are in place.

11.5. Power Management

 IoT devices are vulnerable to security threats, so implementing robust security measures is
essential. Incorporate encryption, authentication, and authorization mechanisms to protect
data and prevent unauthorized access. Regularly update firmware and software to address
security vulnerabilities.
 Battery Life Optimization: Implement power-saving techniques like sleep modes, duty
cycling, and energy harvesting (e.g., solar power). Use low-power components and optimize
firmware for energy efficiency.
 Power Supply Design: Design a robust power supply circuit that can handle voltage
fluctuations and provide stable power to all components.

11.6. Security Considerations

 Determine the data you need to collect from your IoT devices and define the data
collection frequency. Analyze the collected data to gain insights and make informed
decisions. Consider using edge computing or cloud- based analytics platforms for data
processing and visualization.

29
 Encryption: Use strong encryption (e.g., AES-256) for data at rest and in transit to prevent
unauthorized access. Implement SSL/TLS for secure communication over the internet.
 Authentication and Authorization: Implement secure authentication mechanisms (e.g.,
OAuth, JWT) and enforce strict access controls. Use multi-factor authentication for added
security.

11.7. Scalability and Flexibility

 Design an intuitive and user-friendly interface for the end-users to interact with your IoT
system. Consider the use of mobile apps, web interfaces, or voice assistants for controlling
and monitoring the devices.
 Modular Design: Design the system with modularity in mind, allowing easy addition or
removal of components and features. Use standard interfaces and communication protocols.
 Cloud Integration: Plan for seamless integration with cloud platforms like AWS IoT,
Azure IoT Hub, or Google Cloud IoT for scalable data management and analytics.

11.8. User Interface and Experience

 Plan for scalability from the beginning. Consider the potential growth of your IoT system
and ensure that it can handle an increasing number of devices, users, and data.
 Mobile and Web Apps: Develop user-friendly mobile and web applications for device
control and monitoring. Ensure the UI is intuitive and responsive.
 Voice and Gesture Control: Consider integrating voice assistants (e.g., Amazon Alexa,
Google Assistant) or gesture control for a hands-free user experience.

11.9. Testing and Validation

 Develop prototypes and conduct thorough testing to validate the functionality,
performance, and reliability of your IoT system. Use simulators, emulators, or real world test
environments to replicate different scenarios and edge cases.
 Prototyping and Simulation: Create prototypes and use simulation tools to test the
system under various conditions. This helps in identifying issues early in the development
process.

11.10. Maintenance and Support

 Ensure that your IoT project complies with relevant regulations and standards, such as data
privacy laws, wireless communication protocols, and safety regulations. Remember to
document your design decisions, learn from any challenges faced during the implementation,
and continuously iterate and improve your IoT project module.
 Firmware Updates: Implement over-the-air (OTA) updates to easily deploy firmware
updates and security patches. Ensure the update process is secure and reliable.

30
Chapter 12: Exploring Bluetooth® Low Energy (BLE) From
First Steps To Final Application

Overview: Struggling to understand how Bluetooth Low Energy (BLE) works? Looking to
start a BLE design? This class is for engineers who want to learn BLE with little to no
background at all. Concepts covered include BLE Specification, connectivity and data
transfer as relates to typical applications. If you need to replace cables in your application
with BLE in the hands-on portion, you will learn how to create a serial port replacement
application in 15 minutes. The hands-on labs will use the PIC/AVR-BLE board and will also
cover sensor acquisition to phone communication using Punch Through's Light blue
Explorer mobile app.
The "Exploring Bluetooth Low Energy from First Steps to Final Application" module
in an Embedded Systems Developer Virtual Internship focuses on understanding and
implementing Bluetooth Low Energy (BLE) technology in IoT applications. Here's an
overview of what this module covers:

Fig 12.1 PIC BLE Development Board (DT100112)

31
12.1. Introduction to Bluetooth Low Energy (BLE)
 Understand the basics of BLE technology, its advantages, and its use cases in IoT
applications. Learn about the differences between traditional Bluetooth and BLE.
 Use Cases: Explore various use cases of BLE in different domains like healthcare (e.g.,
fitness trackers), smart home (e.g., smart locks), automotive (e.g., keyless entry systems),
and retail (e.g., beacons for customer engagement).
 History and Evolution: Understand the history of BLE, which was introduced in
Bluetooth 4.0 to cater to low-power applications, differentiating it from the classic Bluetooth
aimed at high data rate transmissions.
 Core Specifications: Dive into the core specifications of BLE, which include profiles,
roles, security features, and the Generic Access Profile (GAP) and Generic Attribute Profile
(GATT).

12.2. BLE Architecture

 Explore the architecture and protocol stack of BLE, including the various layers such as
the Physical Layer, Link Layer, and Host Layer. Understand how these layers interact and
enable communication between BLE devices.
 Host and Controller: Understand the division of the BLE stack into the host and
controller. The host handles the higher layers like L2CAP, ATT, and GATT, while the
controller manages the PHY and Link Layer.
 Protocol Stack: Learn about the BLE protocol stack, which includes the Physical Layer
(PHY), Link Layer (LL), Logical Link Control and Adaptation Protocol (L2CAP), Attribute
Protocol (ATT), and the Security Manager Protocol (SMP).
 GAP and GATT: Understand the roles defined in GAP (Broadcaster, Observer,
Peripheral, Central) and how GATT facilitates communication between devices using a
hierarchical data structure.

12.3. Setting Up the Development Environment

 Learn about BLE profiles and services, which define the roles and functionalities of BLE
devices. Understand how to create custom profiles and services for specific IoT applications.
 Emulators and Simulators: Use emulators and simulators provided by BLE chip vendors
to test applications before deploying on actual hardware, which can speed up development
and debugging.
 Development Boards: Explore various development boards and modules like Nordic
Semiconductor’s nRF52 series, Texas Instruments’ CC2640, and others.
 IDE and SDKs: Utilize Integrated Development Environments (IDEs) like SEGGER
Embedded Studio, Keil, or IAR Embedded Workbench, and Software Development Kits
(SDKs) provided by the chip manufacturers.

32
12.4. BLE Profiles and Services
 Dive deeper into the GATT protocol, which is used for data exchange between BLE
devices. Understand GATT attributes, services, characteristics, and descriptors.
 Interoperability: Ensure interoperability with other BLE devices by adhering to standard
profiles. Use tools like the Bluetooth SIG's Profile Tuning Suite (PTS) to test compliance.
 Standard Profiles: Familiarize yourself with standard BLE profiles such as Heart Rate,
Battery Service, and Environmental Sensing. These profiles define how specific applications
should communicate.
 Custom Profiles: Learn to create custom profiles for your specific application needs,
including defining custom services and characteristics.

12.5. Advertising and Scanning

 Explore the advertising and scanning process in BLE. Learn how BLE devices can
advertise their presence and how other devices can scan and discover them.
 Extended Advertising: Explore the use of extended advertising introduced in Bluetooth 5,
which allows for larger advertising payloads and more flexible advertising intervals.
 Advertising Data: Understand the structure of advertising packets and how to include
information like UUIDs, manufacturer-specific data, and transmit power levels.
 Scanning Parameters: Learn about the parameters that control scanning behaviour, such
as scan interval and window, and how to optimize them for power consumption and
responsiveness.

12.6. Establishing Connections

 Understand the connection establishment process in BLE and how data is transferred
between connected devices. Learn about the different methodologies for data transfer, such
as notifications, indications, and write operations.
 Connection Events: Optimize the timing of connection events to balance power
consumption and communication needs. Understand how connection events are managed
within the connection interval.
 Connection Parameters: Define and manage connection parameters like connection
interval, latency, and supervision timeout to balance between power consumption and data
throughput.
 Pairing and Bonding: Implement pairing and bonding processes to establish secure
connections and store bonding information for future reconnections.

12.7. Data Exchange

 Explore the security features provided by BLE, including encryption, authentication, and
bonding. Understand how to implement secure communication between BLE devices to
protect sensitive data.

33
 Throughput Optimization: Optimize data throughput by adjusting the Maximum
Transmission Unit (MTU) size and using Data Length Extension (DLE) features of
Bluetooth 5.
 Read/Write Operations: Perform read and write operations on characteristics,
understanding the differences between read, write, write without response, and long write.
 Notifications and Indications: Use notifications and indications to enable real-time data
updates from the peripheral to the central device.

12.8. Power Management

 Apply the knowledge gained throughout the module to build a practical BLE application.
This may involve developing firmware for BLE devices, implementing custom profiles and
services, and designing a user interface for the application.
 Event-Driven Power Management: Implement event-driven power management to wake
up the BLE device only when necessary, such as upon receiving specific advertisements or
connection requests.
 Sleep Modes: Implement various sleep modes to reduce power consumption when the
BLE device is idle. Understand how different sleep modes impact wake-up times and
responsiveness.
 Power Profiling: Use tools to profile power consumption and identify areas for
optimization. Implement strategies like adjusting connection parameters dynamically based
on activity

12.9. Security Considerations

 Learn how to test and debug a BLE application using appropriate tools and techniques.
Understand common issues and challenges that may arise during BLE implementation and
how to resolve them.
 Privacy Features: Implement BLE privacy features like resolvable private addresses
(RPA) to protect against tracking and ensure user privacy.
 BLE Security Modes: Explore BLE security modes and levels, which include Just Works,
Passkey Entry, and Out-of-Band (OOB) pairing methods.
 Encryption and Authentication: Implement encryption and authentication mechanisms
to protect data integrity and privacy. Understand the use of AES-128 encryption in BLE.

12.10. Final Application Development

 Explore best practices for optimizing power consumption, improving data transfer
reliability, and enhancing overall performance in BLE applications.
 OTA Updates: Incorporate Over-the-Air (OTA) update capabilities to allow for firmware
updates without requiring physical access to the device, ensuring security patches and
feature enhancements can be deployed easily.

34
 Production Testing: Develop and execute a comprehensive production testing plan to
validate BLE functionality, performance, and reliability in the final product.
 Prototyping and Testing: Develop prototypes and test them rigorously to ensure
reliability and performance. Use tools like nRF Connect, Light-blue Explorer, and others for
testing.
 Certification and Compliance: Understand the certification process for BLE devices,
including compliance with Bluetooth SIG standards and regulatory requirements for
different regions.

Debugging and Troubleshooting

 Sniffers and Analysers: Use BLE sniffers and protocol analysers to capture and analyse
BLE packets. Tools like the Nordic Semiconductor nRF Sniffer and Ellisys Bluetooth
analyser can help troubleshoot communication issues.
 Debugging Techniques: Implement logging and debugging techniques in firmware to
trace issues. Use JTAG/SWD interfaces for low-level debugging.

Ecosystem Integration
 Cloud Services: Integrate BLE devices with cloud services to enable remote monitoring
and control. Platforms like AWS IoT, Azure IoT Hub, and Google Cloud IoT offer robust
services for BLE devices.
 Mobile App Development: Develop companion mobile applications for iOS and Android
to interact with BLE devices. Use platform-specific libraries like Core Bluetooth for iOS and
Bluetooth Low Energy API for Android.

Market Trends and Future Directions

 Bluetooth 5.x: Stay updated with the latest advancements in Bluetooth 5.x, including
increased range, higher data rates, and improved broadcast capacity.
 Mesh Networking: Explore BLE mesh networking for creating large-scale networks of
devices, suitable for smart buildings, industrial IoT, and asset tracking applications.

Compliance and Certification

 Testing Labs: Work with certified testing labs to ensure your BLE device meets the
necessary regulatory requirements (e.g., FCC in the US, CE in Europe).
 Bluetooth Qualification: Undergo the Bluetooth Qualification Process to ensure your
device complies with Bluetooth SIG standards, which is essential for using the Bluetooth
logo and marketing your product.

35
Chapter 13: Creating a Sensor Node for Azure IoT Central

Overview: Most embedded developers are not expected to create professional cloud
applications but may need a simple application to test and demonstrate their custom sensor
data being reported to the cloud. This class will help you create a proof-of concept IoT
sensor node which connects to the Microsoft Azure Cloud.

You will learn how to use Microchip’s MPLAB X IDE to modify a baseline IoT
sensor project to incorporate your own telemetry and then use Microsoft Azure’s IoT Central
builder to create a dashboard to visualize the sensor values.

This class will use the Microchip SAM-IoT WG development board, combined with
a Microelectronic Weather Click sensor board to emulate an outdoor environmental sensor
node communicating periodic temperature, humidity, and pressure data to an IoT Central
cloud application. The hands-on lab exercises will step through the procedures needed to
provision the SAM-IoT board to connect and authenticate with Azure Cloud Services, as
well as creating the IoT Central application and then extending the cloud application further
to create queries, run jobs, and set rules.

Fig 13.1 Steps to Azure Connectivity

The "Creating a Sensor Node for Azure IoT Central" module in an Embedded Systems
Developer Virtual Internship focuses on building a sensor node that can connect to Azure
IoT Central platform. Here's an overview of what this module covers:

36
13.1. Selecting the Right Hardware
 Understand the basics of Azure IoT Central, a cloud-based platform for managing and
monitoring IoT devices. Learn about its features, benefits, and how it can be used for IoT
applications.
 MCU Selection: Choose a microcontroller that supports connectivity and has sufficient
processing power. Consider options like the ESP32, STM32, or Texas Instruments' CC3200.
 Sensors: Select sensors based on the application needs. Common sensors include
temperature (e.g., DHT22), humidity, pressure (e.g., BMP280), light (e.g., BH1750), and
motion (e.g., MPU6050).

13.2. Setting Up the Development Environment

 Design the hardware and software components required for the sensor node. This may
include selecting the appropriate microcontroller, sensors, communication modules (such as
Wi-Fi or LoRa), and designing the circuitry and PCB layout.
 IDEs and SDKs: Utilize Integrated Development Environments (IDEs) like Visual Studio
Code with Platform IO, or vendor-specific IDEs like STM32CubeIDE. Use the Azure IoT
SDKs for your chosen platform.
 Toolchains: Ensure you have the necessary toolchains installed for your development
board, such as GCC for ARM-based microcontrollers.

13.3. Connecting to Azure IoT Central

 Learn how to interface and acquire data from various sensors, such as temperature,
humidity, accelerometer, or any other relevant sensors. Understand the communication
protocols and interfaces required to connect these sensors to the microcontroller.
 Azure IoT Hub: Understand the role of Azure IoT Hub in IoT Central. It acts as the
bridge between your sensor node and the Azure IoT Central application.
 Device Provisioning: Use the Device Provisioning Service (DPS) to securely connect and
manage devices at scale. DPS helps in automating the registration of devices to IoT Hub.

13.4. Implementing Secure Communication

 Develop the firmware for the microcontroller to read sensor data, process it, and prepare it
for transmission to Azure IoT Central. Learn how to use programming languages like C or
C++ to implement the necessary functionalities.
 TLS/SSL: Ensure all communications between the sensor node and Azure IoT Central are
encrypted using TLS/SSL. This protects data integrity and confidentiality.
 Certificates and Keys: Manage device certificates and keys securely. Store them in secure
storage on the device (e.g., Secure Element, TPM).

37
13.5. Data Acquisition and Processing
 Understand how to connect the sensor node to Azure IoT Central using the appropriate
communication protocol, such as MQTT or HTTP. Learn how to create a device template in
Azure IoT Central to define the capabilities and properties of the sensor node.
 Sensor Data Acquisition: Implement efficient sensor data acquisition routines, using
appropriate libraries and drivers for your sensors.
 Data Filtering and Aggregation: Apply data filtering techniques (e.g., moving average,
Kalman filter) to improve data quality. Aggregate data if needed to reduce the amount of
data sent to the cloud.

13.6. Data Transmission

 Implement the data transmission mechanism from the sensor node to Azure IoT Central.
Learn how to send sensor data securely and reliably, and visualize the data in Azure IoT
Central's dashboard or analytics tools.
 MQTT Protocol: Use the MQTT protocol for efficient and reliable data transmission.
Azure IoT Hub supports MQTT, making it suitable for IoT applications.
 Message Formatting: Format your messages in JSON for compatibility with Azure IoT
Central. Ensure messages are lightweight to save bandwidth.

13.7. Device Management

 Explore how to manage and control the sensor node remotely using Azure IoT Central.
Understand how to send commands, update firmware, and monitor the status of the device
through the platform.
 Remote Configuration: Implement remote configuration capabilities to update device
settings over the air (OTA). This can include adjusting sensor sampling rates or changing
operational modes.
 Firmware Updates: Implement OTA firmware updates to deploy new features or security
patches. Ensure the update process is secure and failsafe.

13.8. Power Management

 Learn about the security aspects of connecting the sensor node to Azure IoT Central.
Understand how to implement secure communication protocols, device authentication, and
data encryption to protect sensitive information.
 Low Power Modes: Utilize low power modes of your microcontroller to extend battery
life. Implement sleep modes and wake-up triggers based on sensor activity or timed
intervals.
 Energy Harvesting: Consider energy harvesting techniques, such as solar power, to
supplement battery power for long-term deployments.

38
13.9. Data Analytics and Visualization
 Perform testing and debugging to ensure the proper functioning of the sensor node and its
integration with Azure IoT Central. Learn how to diagnose and resolve common issues that
may arise during the development process.
 Telemetry Data: Use Azure IoT Central's telemetry capabilities to visualize sensor data in
real-time. Create dashboards and charts to monitor device health and performance.
 Rules and Alerts: Set up rules and alerts in Azure IoT Central to trigger actions based on
specific conditions, such as temperature thresholds or device connectivity issues.

13.10. Scalability and Maintenance

 Explore the deployment options for the sensor node in real-world scenarios. Understand
how to scale the deployment to multiple devices and manage them effectively using Azure
IoT Central.
 Device Fleet Management: Use Azure IoT Central's device management features to
manage large fleets of devices. This includes grouping devices, monitoring their status, and
performing bulk operations.
 Scalability Planning: Plan for scalability from the start. Ensure your architecture can
handle an increasing number of devices and data volume without compromising
performance.

Security Best Practices

 End-to-End Encryption: Ensure data is encrypted end-to-end, from the sensor node to
Azure IoT Central.
 Access Control: Implement robust access control mechanisms to restrict unauthorized
access to your devices and data.

Edge Computing
 Edge Processing: Implement edge processing capabilities to perform data analytics and
decision-making locally on the device, reducing latency and bandwidth usage.
 Azure IoT Edge: Consider using Azure IoT Edge for deploying cloud intelligence on
edge devices. This allows for more complex processing and integration with Azure services.

Integration with Other Azure Services

 Azure Functions: Use Azure Functions for serverless compute, enabling you to process
incoming IoT data and trigger actions without managing infrastructure.
 Azure Stream Analytics: Integrate with Azure Stream Analytics for real-time data
processing and analytics.

39
Real-World Applications
 Industrial IoT: Implement sensor nodes in industrial environments for monitoring
machinery, predictive maintenance, and optimizing operations.
 Smart Agriculture: Deploy sensor nodes in agricultural fields to monitor soil moisture,
temperature, and crop health, enabling precision farming.

Community and Support

 Community Resources: Leverage community resources, forums, and GitHub repositories
for sample code, libraries, and troubleshooting.
 Microsoft Support: Utilize Microsoft’s support channels and documentation for Azure IoT
Central to resolve issues and stay updated with best practices.

40
Chapter 14: Motor Control Workshop Using dsPIC Digital
Signal Controllers (DSC) Dual Core Devices

Overview: This workshop class is for those aiming for a clear understanding of 3- phase
brushless permanent magnet motors and their control at the fundamental level. BLDC
(Brushless DC) and permanent magnet synchronous motor (PMSM) designs are reviewed
along with the classic control algorithms used for each. The material covers the dsPIC33xx
architecture and motor control peripherals, along with an in- depth look at the Microchip
demo board, MCLV-2. The workshop will also provide two hands-on labs using a
dsPIC33CH128MP508, which will cover sensored BLDC (six step) control, sensor less
BLDC (six step) control and sensor less PMSM (Field Oriented) control. An additional
introduction will be presented for using and debugging a Dual Core device. These labs will
also use a new highspeed "X2CScope" virtual oscilloscope for tuning and control purposes.
This class provides a foundation from which further motor control refinements and control
techniques can be explored with confidence.

The "Motor Control Workshop Using dsPIC Digital Signal Controllers (DSC) Dual Core
Devices" module in an Embedded Systems Developer Virtual Internship focuses on building
motor control applications using dsPIC Digital Signal Controllers (DSC) Dual Core devices.
Here's a breakdown of what this module covers:

Fig 14.1 Architecture Block Diagram

41
14.1. Introduction to Motor Control with dsPIC DSCs
 Understand the basics of dsPIC DSCs, which are specialized microcontrollers designed for
digital signal processing and motor control applications. Learn about their features,
architecture, and advantages in motor control systems.
 Overview: dsPIC DSCs are specialized microcontrollers designed for high performance
motor control applications. They combine the features of microcontrollers with digital signal
processing (DSP) capabilities.
 Advantages: These devices offer advantages such as precise control, real-time
performance, and efficient handling of complex algorithms, making them ideal for various
motor control applications.

14.2. Understanding the dsPIC DSC Architecture

 Gain a solid understanding of motor control principles, including different types of motors
(DC, AC, BLDC), motor control techniques (PWM, PID), and motor control algorithms.
 Core Features: dsPIC DSCs feature a dual-core architecture, combining a DSP core with
a traditional MCU core. This allows simultaneous execution of control algorithms and
peripheral management.
 Peripherals: Key peripherals include Pulse Width Modulation (PWM) modules, Analog-
to-Digital Converters (ADC), Quadrature Encoder Interfaces (QEI), and communication
interfaces like CAN, UART, and SPI.

14.3. Selecting the Appropriate dsPIC DSC

 Set up the hardware required for motor control experiments. This may include connecting
the dsPIC DSC to the motor driver circuit, motor, and other peripheral devices.
 Device Selection: Choose the appropriate dsPIC DSC based on the motor control
application requirements. Consider factors like processing power, memory, peripheral set,
and package type.
 Popular Models: Popular models for motor control include the dsPIC33CK and
dsPIC33CH families, which offer high performance and advanced motor control features.

14.4. Setting Up the Development Environment

 Learn how to set up the software development environment for dsPIC DSC programming.
Understand the tools, compilers, and libraries required to develop motor control
applications.
 IDE and Tools: Use MPLAB X IDE and MPLAB Code Configurator (MCC) for
development. MCC simplifies the setup of peripheral configurations and initialization code.
 Development Kits: Consider using development kits like the dsPICDEM MCLV-2
Development Board, which provides a comprehensive platform for developing and testing
motor control applications.

42
14.5. Motor Control Basics
 Develop firmware using C or assembly language to control the motor using the dsPIC
DSC. Understand how to configure and utilize the features of the dsPIC DSC, such as PWM
generation, ADC conversion, and communication interfaces.
 Types of Motors: Understand the types of motors commonly used in motor control
applications, including Brushed DC motors, Brushless DC (BLDC) motors, Permanent
Magnet Synchronous Motors (PMSM), and Stepper motors.
 Control Techniques: Familiarize yourself with basic control techniques such as openloop
control, closed-loop control, and various control algorithms like PID control, Field-Oriented
Control (FOC), and Direct Torque Control (DTC).

14.6. Implementing PWM for Motor Control

 Implement motor control algorithms, such as speed control, position control, or torque
control, using the dsPIC DSC. Understand how to tune the control parameters to achieve
desired motor performance.
 PWM Generation: Learn to configure and generate PWM signals using the dsPIC DSC’s
PWM modules. PWM is crucial for controlling motor speed and torque by adjusting the duty
cycle.
 Dead-Time Insertion: Implement dead-time insertion to prevent shoot-through in bridge
circuits. Dead-time is the brief period during which both the high-side and low side switches
are off.

14.7. Sensor less Motor Control Techniques

 Explore the dual-core architecture of dsPIC DSCs and learn how to leverage both cores for
motor control applications. Understand the benefits of running different tasks on separate
cores and how to synchronize their operation.
 Back-EMF Sensing: Implement sensor less control techniques such as Back-EMF
sensing, which eliminates the need for physical sensors by using the motor’s Back EMF to
estimate rotor position.
 Observer Algorithms: Use observer algorithms like the Extended Kalman Filter (EKF) or
Sliding Mode Observer (SMO) for accurate rotor position estimation in sensor less control
applications.

14.8. Using Quadrature Encoder Interfaces (QEI)

 Learn how to interface different sensors, such as encoders or hall-effect sensors, to the
dsPIC DSC for precise motor control feedback. Understand how to read and process sensor
data to improve motor performance.

43
 Encoder Integration: Integrate quadrature encoders for precise position and speed
feedback. QEI modules in dsPIC DSCs decode the encoder signals and provide real time
position and velocity information.
 Implementation: Configure the QEI module to read encoder signals, handle index pulses,
and implement position/speed calculation algorithms.

14.9. Implementing Field-Oriented Control (FOC)

 Gain insights into the process of tuning and optimizing motor control algorithms for
improved performance and efficiency. Learn how to analyze motor responses, identify
issues, and make necessary adjustments.
 FOC Principles: Understand the principles of Field-Oriented Control (FOC), which is
used for efficient control of AC motors like PMSMs and BLDC motors. FOC decouples
torque and flux control, allowing precise control of motor dynamics.
 Algorithm Implementation: Implement the FOC algorithm on dsPIC DSCs. This
involves transforming stator currents to a rotating reference frame (Park and Clarke
transformations), controlling the current components, and transforming back to the
stationary frame.

14.10. Real-Time Operating Systems (RTOS) for Motor Control

 Understand how to achieve real-time motor control using the dsPIC DSC. Learn about
interrupt handling, timing considerations, and synchronization techniques to ensure accurate
and responsive motor control.
 RTOS Benefits: Use a Real-Time Operating System (RTOS) to manage complex motor
control applications. An RTOS ensures deterministic behavior and efficient task scheduling.
 RTOS Integration: Integrate an RTOS like Free RTOS with your motor control
application. Implement tasks for motor control loops, communication handling, and system
monitoring.

14.11. Debugging and Optimization Techniques

 Apply your knowledge to develop specific motor control applications, such as robotics,
industrial automation, or electric vehicles. Understand the challenges and considerations
specific to each application domain.
 Debugging Tools: Use debugging tools like MPLAB X IDE’s integrated debugger,
oscilloscopes, and logic analyzers to debug motor control applications. Monitor signals such
as PWM outputs, ADC readings, and encoder signals.
 Code Optimization: Optimize your code for performance and efficiency. Use dsPIC
DSC’s DSP instructions for fast mathematical computations, and optimize ISR (Interrupt
Service Routine) execution to minimize latency.

44
Safety and Protection Mechanisms
 Overcurrent Protection: Implement overcurrent protection mechanisms to prevent
damage to the motor and drive circuitry. Use current sensing techniques and shutdown
PWM outputs in case of overcurrent conditions.
 Overtemperature Protection: Monitor temperature sensors to prevent overheating of the
motor and drive components. Implement thermal shutdown or derating strategies.

Communication Protocols
 CAN Communication: Utilize the Controller Area Network (CAN) interface for robust
communication in industrial motor control applications. Implement CANopen or other
higher-layer protocols as needed.
 Wireless Communication: Integrate wireless communication modules (e.g., Bluetooth,
Wi-Fi) for remote monitoring and control of motor systems.

Advanced Control Algorithms

 Model Predictive Control (MPC): Explore advanced control algorithms like Model
Predictive Control (MPC) for improved performance in complex motor control applications.
MPC optimizes control inputs by predicting future behavior.
 Adaptive Control: Implement adaptive control techniques that adjust control parameters
in real-time to accommodate changes in motor characteristics or operating conditions.

Power Electronics
 Inverter Design: Understand the design of inverters used in motor control applications.
Learn about different inverter topologies (e.g., H-bridge, three-phase inverters) and their
control strategies.
 Gate Drivers: Select and implement appropriate gate drivers for switching the power
devices (e.g., MOSFETs, IGBTs) in your motor drive circuit.

45
Chapter 15: Introduction to MPLAB X IDE

Overview: This class covers the basics of the MPLAB® X IDE. This class will guide you
through the steps of creating a simple "blink an LED" program using one of our popular PIC
MCU Nano development boards. You will learn how to create a project from scratch, how to
navigate the IDE, how to write and debug a simple program and then how to test your code
on an actual development board. [English and Spanish subtitles available in video player]

MPLAB X IDE is an integrated development environment (IDE) specifically designed for

embedded systems development. It is a powerful tool that facilitates the development,
debugging, and programming of embedded applications on Microchip microcontrollers and
digital signal controllers (DSCs). The MPLAB X IDE module provides a comprehensive set
of features that streamline the development process and enable efficient code creation. Some
of the key features of MPLAB X IDE include:

Fig 15.1 MPLAB X IDE Software Interface with Hardware Kit

46
15.1. Overview of MPLAB X IDE
 MPLAB X IDE allows you to create, manage, and organize projects for your embedded
applications. You can easily add and remove source files, libraries, and configuration files,
and set project properties.
 Integrated Development Environment (IDE): MPLAB X IDE is an integrated
development environment designed for developing applications for Microchip’s
microcontrollers and digital signal controllers. It provides a comprehensive suite of tools for
writing, debugging, and optimizing code.
 Cross-Platform Compatibility: MPLAB X IDE is built on the NetBeans platform,
making it compatible with Windows, macOS, and Linux operating systems. This cross
platform support ensures flexibility and accessibility for developers.

15.2. Setting Up MPLAB X IDE

 The IDE provides a code editor with syntax highlighting, code completion, and code
folding features. It supports multiple programming languages like C, C++, and Assembly,
making it versatile for different embedded development needs.
 Installation: Download and install MPLAB X IDE from Microchip’s official website.
Follow the installation instructions for your operating system. Additionally, install the
necessary compiler, such as XC8, XC16, or XC32, depending on the target microcontroller.
 First-Time Setup: Upon first launching MPLAB X IDE, configure the toolchain by
specifying the installed compilers and setting up the default project locations. The IDE may
prompt you to update plugins and components.

15.3. Creating and Managing Projects

 MPLAB X IDE integrates a powerful debugger that allowsyou to step through your code,
set breakpoints, and monitor variables in real-time. This helps in identifying and fixing
issues during the development process.
 Project Creation: Create a new project by selecting the appropriate microcontroller
family and device. MPLAB X IDE offers wizards to guide you through the setup process,
including configuration of device settings, compiler options, and project templates.
 Project Types: MPLAB X IDE supports various project types, including standalone
projects, library projects, and bootloader projects. Choose the type that best fits your
application requirements.
 Project Configuration: Configure project properties, such as compiler settings, linker
scripts, and optimization levels. Use the project properties dialog to manage build
configurations, enabling debug or release builds.

47
15.4. Writing and Editing Code
 The IDE provides an intuitive interface to configure and customize the settings of your
Microchip microcontroller or DSC. You can set clock frequencies, pin assignments, and
other device-specific parameters.
 Code Editor: The MPLAB X IDE code editor provides features like syntax highlighting,
code completion, and error highlighting. Utilize these features to write and edit your source
code efficiently.
 Code Templates and Snippets: Use code templates and snippets to insert common code
structures quickly. MPLAB X IDE allows you to create custom templates for repetitive
tasks.
 Refactoring Tools: The IDE offers refactoring tools to improve code quality and
maintainability. Use features like rename, extract method, and inline to refactor your code
effectively.

15.5. Debugging and Simulation

 MPLAB X IDE automates the build process by compiling your code and generating the
executable file. It also supports programming the microcontroller directly from the IDE,
making it easy to upload your code onto the target device.
 Debugger Integration: MPLAB X IDE integrates with various hardware debuggers, such
as MPLAB ICD 4, PIC kit 4, and REAL ICE. Connect your hardware debugger to the target
microcontroller for in-circuit debugging.
 Simulator: Use the built-in simulator to test and debug your code without physical
hardware. The simulator provides a virtual environment to execute and analyze your
application.
 Breakpoints and Watchpoints: Set breakpoints and watchpoints to halt program
execution and examine the state of variables and registers. Utilize conditional breakpoints to
trigger based on specific conditions.
 Variable Inspection: Inspect variables, memory, and peripheral registers using the
Watches and Variables windows. The IDE provides a detailed view of the current state of
your application, allowing you to diagnose issues effectively.

15.6. Advanced Features

 MPLAB X IDE supports a wide range of plugins and extensions that add additional
functionality and support for different microcontrollers, communication protocols, and
development tools.
 Plug-in System: MPLAB X IDE supports a plug-in system, allowing you to extend its
functionality with additional tools and features. Explore the available plug-ins in the
MPLAB X Plugin Manager to enhance your development environment.

48
 Code Profiling and Analysis: Use code profiling and analysis tools to optimize your
application’s performance. Analyze execution time, memory usage, and code coverage to
identify bottlenecks and optimize your code.
 Version Control Integration: Integrate version control systems like Git and Subversion
with MPLAB X IDE. Use the built-in version control tools to manage your source code
repository, track changes, and collaborate with team members.
 Code Coverage: Measure code coverage to ensure that all parts of your code are tested.
MPLAB X IDE can generate code coverage reports, highlighting untested code paths.

Project Collaboration
 Team Collaboration: Use MPLAB X IDE’s collaboration features to work with team
members. Share projects, configurations, and code through version control systems.
Leverage tools like code review and merge requests to maintain code quality.
 Documentation: Maintain comprehensive documentation within your projects. Use
comments, README files, and project notes to document code functionality, design
decisions, and usage instructions.

Custom Build Tools

 Custom Build Scripts: Create custom build scripts to automate tasks like code generation,
preprocessing, and post-processing. MPLAB X IDE allows you to integrate custom scripts
into the build process.
 External Tools: Integrate external tools and utilities with MPLAB X IDE to extend its
capabilities. Use external compilers, linkers, and analyzers to enhance your development
workflow.

Continuous Integration and Deployment

 CI/CD Pipelines: Integrate MPLAB X IDE with continuous integration and deployment
(CI/CD) pipelines. Use tools like Jenkins, GitLab CI, or Azure DevOps to automate the
build, test, and deployment processes.
 Automated Testing: Implement automated testing frameworks to ensure code quality and
reliability. Use unit tests, integration tests, and hardware-in-the-loop (HIL) testing to
validate your application.
Learning Resources and Community
 Microchip Developer Help: Utilize the Microchip Developer Help portal for
comprehensive guides, tutorials, and documentation on using MPLAB X IDE and related
tools.
 Community Forums: Engage with the Microchip developer community through forums
and discussion groups. Share knowledge, seek assistance, and collaborate with other
developers.

49
 CONCLUSION

The journey through this comprehensive guide on Embedded Systems Development has
been meticulously structured to provide an in-depth understanding of various facets of the
field. From the foundational concepts of microcontrollers to the advanced nuances of IoT
integration and motor control, this document serves as an extensive resource for both
beginners and seasoned professionals.

Key Takeaways
1. Microcontroller Fundamentals: The exploration of the PIC16 series microcontrollers
highlighted the significance of 8-bit architecture in embedded systems. Understanding
the core architecture, instruction set, and peripheral interface of PIC microcontrollers
lays the groundwork for effective system design and development.

2. Advanced C Programming: Delving into advanced C programming techniques, we

emphasized the importance of code optimization, efficient memory management, and the
use of advanced data structures. These skills are critical for developing robust and
scalable embedded applications.

3. Motor Control with dsPIC DSCs: The detailed insights into motor control using dsPIC
Digital Signal Controllers underscored the importance of precision and realtime
performance in controlling various types of motors. The dual-core architecture and
advanced peripherals of dsPIC DSCs make them ideal for complex motor control
applications.

4. IoT Integration: The sections on creating sensor nodes for Azure IoT Central and
design considerations for IoT projects provided a comprehensive overview of the steps
involved in connecting and managing devices in the cloud. Emphasizing security,
scalability, and power management ensures the reliability and longevity of IoT solutions.
5. Bluetooth® Low Energy (BLE): The exploration of BLE technology from basics to
final application demonstrated the versatility and efficiency of BLE in creating low
power, short-range wireless communication systems. Understanding the protocol stack
and application development in BLE is crucial for modern IoT applications.

6. Development Tools: The introduction to MPLAB X IDE and its features illustrated the
importance of a robust development environment in embedded systems. Efficient use of
debugging tools, simulators, and code optimization techniques significantly enhances the
development process.

50
Personal Experience and Reflection
The Embedded Systems Developer Virtual Internship has been an enriching and
fulfilling experience that has significantly enhanced my skills and knowledge in the
field. Through hands-on projects and assignments, I have gained practical experience
with the MPLAB X IDE module, allowing me to effectively develop, debug, and
program embedded applications.

This internship has provided me with a solid understanding of embedded systems

development, troubleshooting techniques, and code optimization, preparing me for a
successful career in the industry.

Collaborating with industry professionals and fellow interns during this internship has
been invaluable. The opportunity to share knowledge, exchange ideas, and learn from
others in the field has broadened my perspective and exposed me to different approaches
and best practices. This collaborative environment has not only enhanced my technical
skills but also allowed me to develop strong teamwork and communication skills, which
are vital in a professional setting.

Finally, the Embedded Systems Developer Virtual Internship has equipped me with the
necessary tools and expertise to excel in the field of embedded systems development. I
am confident in my ability to contribute to the development of innovative solutions in
industries that rely on embedded systems. This internship has been a stepping stone
towards a successful career, and I am excited to apply the skills and knowledge gained to
make a meaningful impact in the industry.

Final Thoughts
This document serves as a foundational pillar for anyone looking to delve into the world
of embedded systems. The detailed explanations, practical examples, and advanced
topics covered here provide a solid base for further exploration and innovation. As
technology continues to advance, staying abreast of the latest developments and
continuously enhancing one’s skills will be paramount.

Embedded systems are at the heart of modern technology, driving innovation across
industries. Whether you are designing a simple microcontroller-based project or a
complex IoT solution, the knowledge and insights gained from this guide will
undoubtedly aid you in achieving your goals. As we look to the future, the possibilities
within embedded systems are boundless, and the journey of learning and discovery is
just beginning.

51