EMBEDDED SYSTEM DEVELOPMENT

A TRAINING REPORT

Submitted in partial fulfillment for the award of the degree

Of

BACHELOR OF ENGINEERING
IN
ELECTRICAL AND ELECTRONICS

Submitted by

ANURAG KUMAR
Roll Number: UE214014

UNIVERSITY INSTITUTE OF ENGINEERING AND

TECHNOLOGY

PANJAB UNIVERSITY, CHANDIGARH

160014

MARCH 2025
 CANDIDATE’S DECLARATION

I hereby certify that the work which is being presented in this training report titled “EMBEDDDED
SYSTEM DEVLOPMENT” in partial fulfillment of the requirement for the award of degree of
“Bachelor of Engineering in Electrical and Electronics” submitted in University Institute of
Engineering and Technology, Panjab University, Chandigarh, is an authentic record of my own work.

The matter embodied in this training report has not previously been submitted for the award of any
other degree of this or any other university.

Name of the Student : Anurag kumar

Branch/Stream : EEE
Roll No. : UE214014

2
 TABLE OF CONTENTS

CANDIDATE’S DECLARATION 2
TABLE OF CONTENTS 3
INDEX 4
CHAPTER-1 6
CHAPTER-2 11
CHAPTER-3 25
CHAPTER-4 26
REFERENCES 27
DAILY ATTENDENCE RECORD 30

3
 INDEX

CHAPTER NO. TITLE PAGE NO.

1. INTRODUCTION TO COMPANY’S PORTFOLIO 5-6

2. INTRODUCTION TO EMBEDDED SYSTEM DEVLOPMENT 7-11
AND TOOLS USED.
2.1 Different Phases of Embedded System Lifecycle Development:
2.2 Tools for Embedded System Lifecycle Management:
3. WORK ACCOMPLISED TILL NOW 12-25
3.1 Getting started with STM32 Programming.
3.2 Study and Testing of devices used in company.
3.3 PCB designing
4. WEEKLY WORK AT INTERNSHIP 26
REFRENCES 27
DAILY ATTENDENCE RECORD 28-30

4
 CHAPTER 1:

Introduction to Company’s Portfolio

FleetSafe India Private Limited is a pioneering company focused on leveraging

advanced technologies to enhance vehicle safety, optimize fleet management, and
improve road efficiency. Established in Mohali, Punjab, FleetSafe India has developed
state-of-the-art solutions using Artificial Intelligence (AI), Machine Learning (ML),
Internet of Things (IoT), and Advanced Driving Assistance Systems (ADAS) to create
a safer and more reliable transportation ecosystem.
The company specializes in real-time vehicle tracking, predictive analytics, and high-
precision GNSS (Global Navigation Satellite System) modules to ensure seamless fleet
operations. With a robust infrastructure and a dedicated research and development team,
FleetSafe India has made significant contributions to the domain of intelligent
transportation systems.
FleetSafe’s mission is to provide innovative fleet monitoring, analytics, and security
solutions to help businesses and government agencies ensure safer roads and more
efficient logistics. Their cutting-edge platforms cater to various industries, including
logistics, public transportation, law enforcement, and emergency response.
Some of Our Services :

• Vehicle Tracking and Fleet Management :

Real-time GPS tracking enables continuous monitoring of vehicle
locations, ensuring efficient route optimization for timely deliveries. Fuel
consumption monitoring and driver behavior analysis help improve
efficiency and reduce operational costs. Geofencing alerts and
unauthorized movement notifications enhance security by detecting any
deviations from designated areas. Additionally, predictive maintenance
alerts based on vehicle usage prevent unexpected breakdowns, ensuring
5
 optimal fleet performance.
• Weigh Bridge Automation
Weighbridge automation refers to the process of automating weighing operation
and related processes at weighbridges or weigh stations. A weighbridge is a
heavy-duty scale used to measure the weight of vehicles and their loads,
commonly found at industrial sites, ports, logistics hubs, and other locations
where weight verification is necessary. By implementing automation
technologies, the weighing process becomes more efficient, accurate, and
streamlined. Here are some key aspects of weighbridge automation:
• Weighbridge Platforms:
Automated weighbridge systems typically consist of a weighing platform or
scale, load cells or sensors to measure the weight, and a control system to
manage the weighing process. These systems can handle various types of
vehicles, from small trucks to large freight vehicles and even railway wagons.
The weighing platform may be surface-mounted or pit-mounted, depending
on the design and requirements.
• Vehicle Identification:
Automation often involves integrating the weighbridge system with vehicle
identification technologies such as RFID (Radio Frequency Identification) or
barcode systems. This enables quick and accurate identification of vehicles
entering the weighbridge, allowing for seamless tracking and record-keeping
of weight data.
• Weighbridge Software:
Automation includes the use of specialized software that manages the
weighbridge operations. The software collects weight data, stores it in a
database, and generates reports for analysis and record-keeping. It can also
integrate with other enterprise systems such as logistics, inventory
management, and billing systems to streamline operations and data sharing.
6
 CHAPTER 2:

INTRODUCTION TO EMBEDDED SYSTEM DEVLOPMENT

AND TOOLS USED

2.1) Different Phases of Embedded System Lifecycle Development:

Embedded systems play a crucial role in the proper functioning and easy access to
modern devices and solutions. If you are planning an intelligent architecture with
IoT at its core, you need a suitable embedded system that can operate the IoT
architecture. They are engineered to automate the processes and streamline the
business operations, thus improving productivity. To develop the appropriate
embedded system, you need to follow a development lifecycle that goes through the
following stages:

1) Requirement Analysis:

The embedded system lifecycle development begins with requirement analysis, where
the needs and specifications of the system are identified. This involves understanding
the purpose of the system, the environment it will operate in, and the desired
functionalities. Stakeholder consultations and market research play a crucial role in this
phase to ensure that the final product meets the expectations and demands of the target
audience.

2) Designing:
Once the requirements are gathered, the next phase involves designing the architecture
and components of the embedded system. This includes defining the hardware
components such as microcontrollers, sensors, actuators, and interfaces, as well as the
software architecture including the operating system, drivers, and application software.
The design phase aims to create a blueprint that outlines how the system will function
7
and interact with its environment. Appropriate embedded controllers, peripherals,
sensors and modules are searched and compared to produce a list of most compatible
and cheap options that will satisfy the requirement.

3) Development:
In the development phase, the designed system is translated into code and hardware
components are integrated to create a working prototype. This involves writing
firmware for microcontrollers, developing device drivers, implementing algorithms,
producing PCB layouts, producing working PCBs and testing individual components to
ensure they meet the specified requirements. Collaboration between hardware and
software is crucial in this phase to ensure seamless integration and functionality.
Oftentimes the minor details presented in datasheets could be the reason for major errors
that will stall work for weeks. Thus this stage also involves obtaining complete
knowledge of the devices, peripherals, controllers, logic devices etc. and how to make
them work together.

4) Implementation:
Once the prototype is developed, it undergoes rigorous testing and validation to identify
and rectify any defects or issues. This involves both functional testing to ensure that the
system performs as intended, as well as non-functional testing to evaluate factors such
as reliability, performance, and security. Any necessary modifications or optimizations
are made during this phase to ensure that the final product meets quality standards.
Common testing methodology includes the commonplace
1)Continuity testing,
2)Sending AT commands to Bluetooth/Wi-Fi/Mobile ICs to configure and check their
working
3)Ensuring good Serial Communication such as UART and SPI
4)Firmware debugging
5)Durability Testing
8
5) Commercial Launch:
After successful testing and validation, the embedded system is ready for commercial
launch. This involves mass production of the hardware components, packaging, and
distribution to customers. Marketing and sales strategies are also implemented to
promote the product and attract potential buyers. The commercial launch marks the
culmination of the development process and the beginning of the product's lifecycle in
the market.

2.2) Tools for Embedded System Lifecycle Management:

Development of Embedded Systems are aided by several tools both Hardware and
Software that cater to specific needs of the process. The Software tools are used to
develop Firmware, Check Serial Communications for responsiveness, develop the
hardware layout to be printed on a PCB, program the Pick and Place machines, produce
the 3D models of casings and managing inventory. Whereas the hardware tools such as
CRO, multi-meters, Pick and Place Machine, are used in the testing and assembly of
the embedded system.
Following is a short description of the various software and hardware tools used in
Embedded Systems Development:

• Altium Designer:
Altium Designer is a powerful PCB design software that is widely used in the
development of embedded systems. It provides a comprehensive suite of tools for
schematic capture, PCB layout, and component management, allowing engineers to
design high-quality and reliable hardware components.

9
 • STMCUBEIDE:
STM32CubeIDE is an integrated development environment created by
STMicroelectronics specifically for their STM32 microcontrollers and
microprocessors. This free, comprehensive tool combines the STM32CubeMX
configurator with the Eclipse IDE to provide developers with everything needed to
design, program, debug, and optimize embedded applications. It offers a streamlined
workflow from initial hardware configuration (including pins, clocks, peripherals, and
middleware) through to code generation, editing, compilation, and debugging with ST-
LINK hardware. The IDE supports the entire STM32 portfolio and includes advanced
features like trace capabilities, code analysis, and profiling tools, making it a powerful
yet accessible solution for embedded developers working with STM32 devices across
Windows, macOS, and Linux platforms.

• STM MICROCONTROLLERS:
STM32 microcontrollers are 32-bit ARM Cortex-M based MCUs from
STMicroelectronics. They range from ultra-low-power to high-performance variants,
featuring rich peripherals like ADCs, timers, and communication interfaces. Known for
power efficiency and comprehensive development support through the STM32Cube
ecosystem, these MCUs are widely used in various applications from IoT devices to
industrial systems.

• SERIAL INTERPRETERS SUCH AS MOBAXTERM:

Serial interpreters like MobaXTerm are software tools used for serial communication
and debugging in embedded systems development. They provide a graphical interface
for monitoring and interacting with serial ports, allowing engineers to send and receive
data, view logs, and execute commands on connected devices. Serial interpreters
support various protocols such as UART, SPI, and I2C, enabling seamless
communication between embedded systems and external peripherals or host computers.
Additionally, they offer features like script automation, session management, and
10
remote access, enhancing productivity and efficiency during development and testing
phases.

• GitHub:
GitHub is a web-based platform that provides version control and collaboration tools
for software development projects. It is widely used in embedded system development
for managing source code, tracking changes, and facilitating collaboration among team
members.

• Multi-meters:
Multi-meters are essential tools for testing and troubleshooting electrical circuits in
embedded systems. They are capable of measuring various parameters such as voltage,
current, resistance, and continuity, allowing engineers to verify the integrity and
functionality of electronic components and connections. Multi-meters come in both
analog and digital formats, with digital multi-meters offering additional features such
as auto-ranging and data logging for more precise measurements and analysis.

11
 CHAPTER:3

WORK ACCOMPLISED TILL NOW

3.1) Getting started with STM32 Microcontroller programming.

I am working on programming the STM32 Nucleo-G431RBT6 development board,

which features the STM32G431RBT6 microcontroller based on the Arm® Cortex®-
M4 core with FPU running at up to 170 MHz. The board includes an integrated ST-
LINK/V2-1 debugger, Arduino Uno V3 and ST morpho headers for expandability, and
rich peripherals such as USART, I2C, SPI, ADC, and DAC, making it ideal for
embedded development and prototyping.
Assignment 1: To Toggle onboard LED on the NUCLEO-G431RB board.
Code:
Concept to learn: concept of HAL(Hardware Abstraction Layer)
Library in STM32.
#include "main.h" {
COM_InitTypeDef BspCOMInit; Error_Handler();
void SystemClock_Config(void); }
static void MX_GPIO_Init(void);
int main(void) while (1)
{ {
HAL_Init(); HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
SystemClock_Config(); HAL_Delay(500);
MX_GPIO_Init(); }
BSP_LED_Init(LED_GREEN); }
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI);
BspCOMInit.BaudRate = 115200; void SystemClock_Config(void)
BspCOMInit.WordLength = COM_WORDLENGTH_8B; {
BspCOMInit.StopBits = COM_STOPBITS_1; RCC_OscInitTypeDef RCC_OscInitStruct = {0};
BspCOMInit.Parity = COM_PARITY_NONE; RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
BspCOMInit.HwFlowCtl = COM_HWCONTROL_NONE;
if (BSP_COM_Init(COM1, &BspCOMInit) != HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLT
BSP_ERROR_NONE) AGE_SCALE1_BOOST);
12
RCC_OscInitStruct.OscillatorType = Error_Handler();
RCC_OSCILLATORTYPE_HSI; }
RCC_OscInitStruct.HSIState = RCC_HSI_ON; }
RCC_OscInitStruct.HSICalibrationValue =
RCC_HSICALIBRATION_DEFAULT; static void MX_GPIO_Init(void)
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON; {
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI; GPIO_InitTypeDef GPIO_InitStruct = {0};
RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV4; __HAL_RCC_GPIOC_CLK_ENABLE();
RCC_OscInitStruct.PLL.PLLN = 85; __HAL_RCC_GPIOF_CLK_ENABLE();

RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2; __HAL_RCC_GPIOA_CLK_ENABLE();

RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2; __HAL_RCC_GPIOB_CLK_ENABLE();

HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin,
RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
GPIO_PIN_RESET);
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
GPIO_InitStruct.Pin = LED_Pin;
{
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
Error_Handler();
GPIO_InitStruct.Pull = GPIO_NOPULL;
}
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
RCC_ClkInitStruct.ClockType =
HAL_GPIO_Init(LED_GPIO_Port, &GPIO_InitStruct);
RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK|RCC_CLOC
}
KTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = void Error_Handler(void)
RCC_SYSCLKSOURCE_PLLCLK; {
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; __disable_irq();
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; while (1)
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; {
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, }

FLASH_LATENCY_4) != HAL_OK) }

RESULT:

LED ON LED OFF

13
Assignment 2: To turn on onboard LED when Push button is pressed and Turn it
off when Push button is again pressed.
Concept to learn : Concept of Debouncing.
Code:(only Main Function)

int main(void) {
{ If(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_13)==GPIO_PIN_SET)
HAL_Init(); {
SystemClock_Config(); HAL_Delay(500);
MX_GPIO_Init(); i=i+1;
BSP_LED_Init(LED_GREEN); }
BSP_PB_Init(BUTTON_USER, BUTTON_MODE_EXTI); int p=i%2;
BspCOMInit.BaudRate = 115200; switch(p)
BspCOMInit.WordLength = COM_WORDLENGTH_8B; {
BspCOMInit.StopBits = COM_STOPBITS_1; case 0:
BspCOMInit.Parity = COM_PARITY_NONE;
BspCOMInit.HwFlowCtl = COM_HWCONTROL_NONE; HAL_GPIO_WritePin(GPIOA,GPIO_PIN_5,GPIO_PIN_RESET);
if (BSP_COM_Init(COM1, &BspCOMInit) != break;
BSP_ERROR_NONE) default:
{ HAL_GPIO_WritePin(GPIOA,GPIO_PIN_5,GPIO_PIN_SET);
Error_Handler(); }
} }
int i=0; }
while (1)

Assignment 3: To print “HELLO WORLD” on Serial Terminal by STM32 MCU.

Concept to learn: Concept of UART communication.
Code:(only main function)
int main(void)
{ while (1)
HAL_Init(); {
SystemClock_Config(); HAL_UART_Transmit(&hlpuart1, tx_buffer, 40, 10);
MX_GPIO_Init(); HAL_Delay(1000);
MX_LPUART1_UART_Init(); }
}
uint8_t tx_buffer[40] = "HELLO WORLD\n\r";

14
RESULT:(ON MOBAXTERM
SERIAL TERMINAL)

Assignment 4:
To control onboard LED using serial terminal.

15
Code: (Major sections)
#include "main.h"

UART_HandleTypeDef hlpuart1;

uint8_t tx_buffer[40] = "PRESS 1 TO ON

AND 0 TO OFF LED\n\r";
uint8_t rx_indx;
uint8_t rx_data[1];
uint8_t rx_buffer[100];
uint8_t transfer_cplt = 0;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_LPUART1_UART_Init(void);

int main(void)
{
HAL_Init();
SystemClock_Config();

MX_GPIO_Init();
MX_LPUART1_UART_Init();
HAL_UART_Transmit(&hlpuart1,
tx_buffer, 40, 10);
HAL_UART_Receive_IT(&hlpuart1,
rx_data, 1);

while (1)
{
process_command();
}
}

void
HAL_UART_RxCpltCallback(UART_Handle
TypeDef *huart)
{
UNUSED(huart);

if (huart->Instance == LPUART1) {
HAL_UART_Transmit(&hlpuart1, rx_data,
1, 100);

if (rx_data[0] != '\r') {
rx_buffer[rx_indx++] = rx_data[0];
} else {

16
 rx_buffer[rx_indx] = '\0';
rx_indx = 0;
transfer_cplt = 1;
}

HAL_UART_Receive_IT(&hlpuart1,
rx_data, 1);
}
}

void process_command(void)
{
if (transfer_cplt) {
transfer_cplt = 0;

if (strcmp((char *)rx_buffer, "1") == 0) {

HAL_GPIO_WritePin(GPIOA,
GPIO_PIN_5, GPIO_PIN_SET);
HAL_UART_Transmit(&hlpuart1,
(uint8_t *)"\n\rLED ON\n\r", 11, 100);
} else if (strcmp((char *)rx_buffer, "0") ==
0) {
HAL_GPIO_WritePin(GPIOA,
GPIO_PIN_5, GPIO_PIN_RESET);
HAL_UART_Transmit(&hlpuart1,
(uint8_t *)"\n\rLED OFF\n\r", 12, 100);
} else {
HAL_UART_Transmit(&hlpuart1,
(uint8_t *)"\n\rINVALID INPUT\n\r", 17,
100);
}
}
}

17
RESULT:

18
3.2) TESTING AND STUDY OF DIFFERENT DEVICES USED IN
COMPANY:

1) RFID READER:

An RFID reader is a device that reads and processes data stored on RFID tags using
radio frequency signals. It consists of a transmitter (to send signals) and a receiver (to
capture responses from RFID tags). RFID readers can be handheld or fixed and operate
at different frequencies (LF, HF, UHF) depending on the application.

RFID cards are Tested using Company’s build software by connecting it with Ethernet
and setting Parameters as show below:

19
CONNECTION AND RESULT:

Connection Result

2) VTS(vehicle tracking system):

A VTS (Vehicle Tracking System) device is a GPS-based system used to monitor and
track vehicles in real-time. It collects data like location, speed, route, fuel consumption,

20
and engine status, transmitting it to a central server via GSM/GPRS. VTS devices are
widely used for fleet management, logistics, theft prevention, and route optimization,
helping businesses and individuals enhance security, efficiency, and operational control
over their vehicles.

The VTS device is connected to Computer via a RS232 to USB connector and sends its
output output to any serial terminal(Here using MobaXterm). The lights indicates the
signal of GSM, GPS, Server and power.
Result (on Mobaxterm):

3) IOT CONTROLLER:

An IoT controller is a device that manages and controls connected IoT (Internet of
Things) devices in a network. It collects data from sensors, processes it, and sends
21
commands to actuators or cloud servers for automation and remote monitoring. IoT
controllers often support Wi-Fi, Bluetooth, Zigbee, LoRa, or cellular communication.
They are widely used in smart homes, industrial automation, healthcare, and agriculture
to enhance efficiency, reduce costs, and enable real-time decision-making.

This smart iot controller has built-in web server that allows users to configure and
control them via a web-based interface. When you enter device IP in a browser, your
request is sent to the IoT controller, which responds by serving the login page. This
login page is for configuring network settings, user access, and device testing.The Login
and testing page for the device is shown below.

FIG: LOGIN PAGE

22
FIG: TESTING PAGE

23
3.3) GETTING STARTED WITH PCB DESIGNING:
PCB (Printed Circuit Board) designing is the process of creating a layout for electronic
circuits on a board that connects components using conductive pathways. It involves
schematic design, component placement, routing, and layer management using software
like Altium Designer, KiCad, or Eagle.
Here I am using Altium Designer software.
Assignment 1: PCB Design of FULL BRIDGE RECTIFIER CIRCUIT
Schematic:

2D View:

24
3D VIEW:

25
 CHAPTER 4:
Weekly work at Internship

• The following table summarises the work that has been done in the
past 2 months

Week 1 Basics of PCB Designing, Inventory

Management.

Week 2-3 Study of different devices present in company,

Studied C programming , IOT controller

testing.

Week 4-5 Starting with STM32 programming, RFID card

testing, Inventory management.

Week 5-6 RFID card schematic study, RFID card

Repairment, Works on MT100 GPS device,
STM32 programming(Load cell control using
STM32 MCU).

Week 7-8 VTS device Firmware Update, VTS device

testing, IAP(In application programming ) for
STM32 MCU, Inventory management.

26
 REFERENCES

[1] https://en.wikipedia.org/wiki/Texas_Instruments

[2] STM32G431RBT6 - https://www.st.com/resource/en/datasheet/stm32g431c6.pdf

[5] STMCubeide- https://www.st.com/content/st_com/en/stm32cubeide.html

[6] MobaXTerm - https://mobaxterm.mobatek.net/

[7] Altium Designer - https://www.altium.com/altium-designer

[8] Brushless DC Motor - https://www.renesas.com/us/en/support/engineer-

school/brushless-dc-motor-01-overview

27