C programes

10 Tips to Accelerate Your Engineering Career in Embedded System

10 Tips to Accelerate Your Engineering Career in embedded system_

10 Tips to Accelerate Your Engineering Career in Embedded System

Now a days, there are many ways to build our carrier. But when it comes to ECE/EEE/EE/ student then we are having very less options. For Us we are having few top choises are VLSI/SCADA-PLC/ and Embedded system. Here VLSI is having very limited scope in India, while SCADA is not in much trand now a day, while are having one of the best and core field is Embedded system. I will discuss with you how to build your successful career in Embedded system. Before I move on I will introduce my self so that you can relies on the information which I am providing here.
I am Yogesh Kumar Sharma from founder of Professional Training Institute, having 15+ years of industrial experience in embedded development. Okay so let’s start your journey in the embedded world.
As of my past experience I will explain the 10 most important tips to accelerate your engineering career in embedded systems.

1. Practical Working Knowledge in Embedded Devices:

If we wanna to make our career in embedded system then first we need to know about all the embedded devices used in the projects development. Every companies will use different types of controllers based on project. So, we need to have some knowledge on different controllers because if we are working in any company they will give project and the requirements only and there is your job to make that complete project and you need to study which controller is suitable to that requirement. If we want to design any project we need a knowledge on embedded devices which we are using for our requirements. So, firstly, we need to learn the embedded components, the controllers, the protocols, tools, programming language etc,. you should gain some practical knowledge in embedded system, you should do some hands on experiment with the latest technologies to make them use correctly. Here in Embedded Training Institute in Bangalorewe give directly projects to the students and they gains hands on knowledge on embedded system from us.

2. Embedded Development Life Cycle:

By knowing the Embedded development life cycle will helps a lot in your career. you can only make the project by own without anyone help. Normally process is depends upon individual company but normally we follow SDLC with some changes. For complete embedded development cycle involves different steps.
First, the market team will give a requirement for their application and based on their application R&D engineer need to analyze the project for feasibility of project, technology required, past experience within organization etc.
Following are the steps normally followed in organization
a) Requirement
b) Feasibility
c) specification
d) Design
e) Implementation
f) Testing and validation

Then R&D team will start the design and implementation.
The above steps are part of SDLC – software development life cycle. After implementation complete product testing is started. once you should know the above steps.

3. Command Over C Language is Very Important:

In my life i know only C language, till now i don’t have any other requirement to learn other language. C is the programming language for embedded system. Mainly C language is working more closely hardware. it is most widely used programming in the world. While you are setting in any interview you should have complete knowledge of C language. In any embedded system interview 90% questions will come from C language. you should have control over C language. In Interview company is expecting very deep understanding of C, normally they ask higher end of C language like, function pointer, structure, union, pointer, array of structure pointer etc. In order to achieve control over interview you should go complete understanding of C language.
When you work in company, you have to design an embedded product and you need to use C language. We need to know Advance knowledge in C language. As deeper understanding you will have in C language that much good code you can write. We are the professional training institute in Bangalore, we give training in C completely hands on, it will make our student knowledge more stronger than any experience student.

4. Understanding of Hardware Component, Their Use and Datasheet Reading Skills:

As an Embedded Engineer, we need to know all the hardware components which we are used in the Embedded projects. Normally component used in Embedded is Resistance, capacitor, inductance, diode, transistor we should be aware of these components, how to use them, limitation etc. We may also need have knowledge of ICs like RTC DS1307, EEPROM – 24c04, ADC 0804, RS232, ULN2003 etc we should know what all types of ics are available and where we can use them. Although many types are ICs are available in the marketing, but we should be aware of all main ICs. When we know that how the hardware components will work and how to interface with other components then we can easily complete the projects with less help with others.
During training our student do lot of experiments with the above ic and gets hands on understanding of that. during experiment student read data sheet and use the information mentioned in that. you also must know what all are the important parameter we need to check in data sheet.

5) Debugging skills of software – Embedded firmware.

If your writing code for running hardware then if you are lucky then your code will work as it is. but in most of the case, I won’t. Firmware won’t work as it is, And if firmware not working then we have to make it work. We have to find out what is the mistake we did, for that we need debugging skills. But the difficult part is how to learn to debug, here in the Professional Training Institute we ensure that during training student face enough problems so that he/she can develop debugging skills. However, when we got an error we need to go through the ocean and solve the problem faced. We need a lot of analytical skills to overcome the possible cause of the error, to narrow down the scope of error. Still, there is a possibility that some error will solve in 10 min, some error will solve in a few days, but some may take months or years. But it will surely be having a root cause. Sometimes, we are written the firmware code correctly but we are getting errors because of there is a malfunction in the hardware circuit(we don’t know that), so with how many times if you check also you won’t found the answer for that error. Because of these, we need to have good debugging skills while working on Embedded products.

6) Unit testing, Component Testing, System Testing skills:

This is the one more skill to need to establish the embedded systems developer, it is used for testing the complete hardware products. when we make firmware we need to check that it is working or not, this is called unit testing. In unit testing, we ensure whatever functionality we had developed that has to be working correctly. if we found any bug then we need to correct them. once unit testing is done then we give our component for testing, this testing may be done by some other team.
We are having another level of testing that is called component testing- in the component testing, we ensure the individual component is working correctly. This individual component can include hardware, software. To test components we may need to give some dummy input for testing. Once the independent component is working correctly then we can go for integration testing. In this, we check full system functionality. If we found some issue then we have solved them at individual level.

7) Hardware Debugging is a Requirement While Working:

when you are working on any project many times system is not working, you have to debug and diagnose the problem. To debugging an embedded device we must know the art of debugging hardware. As an embedded engineer we should know where is the problem located, why device not working. For firmware, we are having a debugger, but hardware we are not having the debugger. we need to check signal one by one and find the problem.
You should have hands-on knowledge of the tool used to debug hardware like logic analyzer, CRO, multimeter etc. When are testing an embedded hardware part for an errors first we need to check individually and then the whole system.
The following point may help in hardware debugging
• We need to check first all the equipment are working or not individually.
• Next, we need to check the input requirements to all the devices.
• Next, we need to analyze the errors occurs and we need to check is there any short circuit or not.
• If there is an error occurs when we need to rearrange that product without any of errors.

So, we need to aware of hardware debugging also. We are professional training institutes in Bangalore and we will focus on the student’s knowledge and we will train you on Hardware debugging also. We will teach you how to build a hardware part in the project and how to rectify if any error occurs on the hardware part.

8) Component Review – Firmware Review Skills:

If we are doing any projects and we need to make that project should be run exactly. While creating any firmware code that must meet all requirements. But in many times development is done by the junior member of the team, and he may have a full understanding of the system. so there is a possibility that he may make some mistake which is working currently but later it may give some problem or may in component level it is working bust system level it will not work. This point needs to check and must be review by a senior member of the team. To check the code for its functionality is called code review. normally it is done by a senior member in the team. But you should also have the same skills so that while writing code itself you come to know what mistake is possible and you can make correct firmware

9) Master the Tools of the Trade:

When you’re doing any project on Embedded System we need to know compulsory on tools which will use to work on projects that make to accelerate a career is to master the tools of the trade. The tools which will be used to work on the Embedded projects are Keil, Proteus, Flash Magic, Mp Lab, MATLAB, Kicad, Altium Designer, Eagle, OrCad, STM32 CubeMax, Arduino, Rasbian etc., By using these tools based on controllers like Arduino is used to write firmware in Arduino and Node Mcu ESP8266 etc,. Keil is used to writing a C code or Assembly code and for compilation process. Proteus is used for a schematic of the hardware section and checking the code as well as hardware project is working or not. Flash Magic is used to dump the code into a microcontroller(8051MC, LPC21XX, etc) and Kicad, Altium Designer, Eagle, OrCad are used for Pcb designing purpose. Rasbian is used to work on the Raspberry pi Controller.
So, in every company, they will use different controllers and based on the controller we need to work on different IDE tolls. That’s why we need to know about the IDE tools, then only we can do any type of projects.

10) Documentation Skill Needed:

When your working on any project, it is necessary to make documentation also. When so many peoples are working on the same project then documentation is required. When you start designing a project then you need to make a design document, we also need to make testing documents. When some candidate is leaving the company then what activity he did all those things need to capture so that in future it can be used in case of any problem. when any customer buys our product he needs to know about how it will work and he requires manual, to operate that product. When you have completed your project and you need to submit a project for review and release, that time you need to have all document completed.

These are the 10 tips to accelerate your career in an Embedded System and you need to aware of these tips then you can service in any where in the company. And we are the Professional Training Institute in Bangalore, we will mainly focus on the embedded Course in Bangalore which will helpful their carrier and we will help you how to make individual projects also which makes you as an experienced person. So, first please join in any top embedded training institute in Bangalore that is Professional Training Institute.

If Statement

Control Statements:

There are different types of control statements. It is also called as Flow control statements i.e, we can execute the block of program based on the conditions. There are different types of Flow Control Statements. They are

Decision Statement

1. If Statement.
2. If…else and if…else…if statements
3. nested if else statement
4. switch case

Looping Statements

1. for loop
2. while loop
3. do…while loop
4. Nested loop

Jump Statements

1. Break Statement
2. Continue statement
3. goto Statement

If Statement:

If statement is used in c to control the flow of program with conditional expression. If condition is true, then the block of statement will be executed


if( condition)
statement 1; // The block of statement which would be executed
statement 2; // when condition is true, then execute this block of statements
statement n;
If the condition is true, then the statement inside the body of “if” only executed. If the condition is false, then the statement inside the body of “if” will be skipped.

How it works:

if statement

Flow Chart:

flow chat of control statement

Now, we can see the example with a program.
int main()
int a=5, b=8;
if(a<b) // if the condition is true then it will execute the if block statement
{ // if condition is false then it ends the program
printf(“The number a=%d is lessthan b= %d”, a,b);
return 0;


The number a=5 is lessthan b=8.
So now we discussed the If statement and the remaining flow control statements will be explain on the following documents. If you want to establish a good carrier then we need to have good knowledge on the basic language . This language is very useful to the Embedded Systems and to get more knowledge we need join in the top embedded training institutes in Bangalore and we are the Professional Training institute in Bangalore and we will focus on the good knowledge for the students.



Variable is a name that can be used to store the values or data. Here, A data type is associated with each variable. The data type of variable decides what value it can take. The data which is stored in the variables exist upto program’s execution, One’s program execution is completed then variables data also expires. The rules of naming a variables are same as that for naming identifiers.

Declaration of a variable:

we need to declare a variable before using in the program.Here, Declaration of a variable defines the name and datatype.The type and range of a value in the variable decides can store depends upon its datatype. The syntax of a variable declaration is shown below


int x; // Used to hold an integer.
float salary; //Used to hold a float value.
char grade; //Can hold/store a character in it.
Where the datatype may be int, char,float double etc,. Here, x is a variable of type int, salary is a
variable of type float, grade is a variable of type char.
we can also declare a more than one variable in a single declaration. For example
int x,y,z,temp;
Here, x,y,z,temp are all variables of int type.

Rules to name a variable:

* Keywords are not allowed as a variable name.
* Variable name is not allowed start with a digit or numbers.
* Variable name can consist of alphabets, digits and special symbols like underscore _.
* Blank or spaces are not allowed in variable name.
Let’s write a program in which we will use some variables :
#include <stdio.h>
int main ()
/* variable definition: */
int x, y,z; // x,y,z are the int datatype variables
/* Initialization a valve in variable */
x = 5; // 5 value is stored into the x variable
y = 2; // 2 value is stored into the y variable
/* using addition operator */
z = x + y; // the sum of two variables x and y will stored into the z variable
/* display the result */
printf(“Sum is : %d \n”, z); // displaying the z variable
return 0;


Sum is 7
Here, if we consider the program we are declaring the variables in the main program that to it has been declared before used. In the program, x,y,z are the int datatype variable and which the system will allocates the seperate memories for each variables. Later, in the program we are initialized the values to the variables I.e, x=5 and y=2. So here the value 5 is stored in the variable x memory location. Similarly, the value 2 is stored in the variable y memory location. So after performing the addition operation the sum value is stored in the z(z=5+2).
If a student is very ambitious about the career in embedded systems industry. They should have a very deep knowledge in the basics . There are lot of famous institutes for embedded systems training institutes in this field. We are the Professional training institute, in Bangalore are focusing on student’s deepest understanding in this field from its basics.

Storage Classes in C

Storage Classes in C

To describe the features of the variable we use storage classes in c programming. Storage classes are used to track the variable during the run time of the program. Storage class describes the lifetime, scope of the variable in a program.
There are four storage classes in c program. They are auto, register, static and extern.
Storage classes in C


The variable normally declared inside block or function is of auto type i.e auto is a default storage class for all the variables which are declared inside the block or function.
The scope of auto variables are within the block or functions means Auto variables can be only accessed within the block/function they have been declared and not outside them.
Int a;
auto int a;
Above we declared two variable of the same type.


The register storage class is used to define local variables that should be stored in a register instead of RAM.
register int c;
The register should only be used for variables that require quick access such as counters. It should be noted that describing ‘register’ it does not mean that the variable will be stored in a register. It means it might be stored in a register depending on hardware and implementation restrictions.

Static Variable

The static storage class notifies the compiler to keep a local variable in existence during the lifetime of the program instead of creating and destroying it each time it comes into and goes out of scope. Therefore, making local variables static allows them to maintain their values between function calls.
The static variable can be external or internal, its depends on the place of declaration.
void foo();
int main(void)
Void foo()
Static int x=1;

Output: 1,2,3.


The keyword extern is used with a variable to notify the compiler that the declaration of a variable is done somewhere else. The declaration of extern does not allocate storage for variables.
File1.c //
int x=3; //global declaration of variable
void foo()
#include”file1.c”                   //including the file1
Extern int x; // global variable from file1 is extracted so x=3.
So the global variable which is declared in one file can be used in other file using the extern.



An array is a collection of similar data which is stored in sequential order in the memory. For example, if we save one integer variable into memory it will occupy 4 bytes. If we make another variable then it also occupies 4 bytes, but this memory of two variable may be consecutive or maybe not. This type of variable declaration method is alright until we are having less number of variables.
Once we have to handle the number of variables, it’s maybe 50, 100 then making 50 variable is very difficult.
                int a,b;
We have a solution, we can make an array of N number of the element. In the array, all variable will be saved into consecutive memory locations.

Declaration of array

datatype arrayname[sizeofarray];
Ex:int array[50];
array stored in memory.
array program example
This will reserve 50th places each of size 4 bytes int memory and the good part is all are consecutive in memory locations.
You can initialize an array in C either one by one or using a single statement as follows
Or marks[5];
marks[0]=47;, marks[1]=48; marks[2]=45;, marks[3]=44;,marks[4]=49.
How to access this element? This is very simple,
We can access each element individually by showing their place value.
E.g. array[1], array[0], array[24] etc.
Keep remember array always starts from 0, means the first element is always array[0] and last-element is one less than the maximum number element, in our case array[49].

Let’s see the program using the array which explains the declaration, assignment and accessing the array;

Int main(void)
Int a [12]; /* a is array of 12 integers*/
Int I,j; /* I and j are integers*/
/*initializing the values to array elements a */.
a[i]=i+10; /* assigning value i+10 to ith element*/
/* printing the values of elements of array a*/
Return 0;



Passing array to function

We can pass array elements to function in two ways. One is bypassing a single value or by passing the full array.
Passing single value to array
Void foo(int a)
Int main (void)
Int array[]={1,2,3};
foo(array[1]); // array[1] is passed to the called function foo
Return 0;



Passing Entire Array to Function

Int main(void)
Int a[5]={1,2,3,4,5};
Sum=add(a); // passing full array to called function
return 0;
Int add(int a[])
Int sum=0, i;
return sum;// return sum to main function.



Pointers and Function Arguments

Pointers and Function Arguments

In call by reference method for a function call, we are using pointers in function as arguments. Pointers as arguments in function are used to hold the address of variables passed from calling the function. If a function is called by reference and any change made to the reference variable will affect the original variable.

Let us consider a program for more detailed study

#include <stdio.h>
#include <stdlib.h>
int main()
int m = 10, n = 20;
printf(“Before swapping:\n\n”);
printf(“m = %d\n”, m);
printf(“n = %d\n\n”, n);
swap(&m, &n); //passing address of m and n to the swap function
printf(“After Swapping:\n\n”);
printf(“m = %d\n”, m);
printf(“n = %d”, n);
return 0;
pointer ‘a’ and ‘b’ holds and
points to the address of ‘m’ and ‘n’
void swap(int *a, int *b)
// pointers as the function arguments
int temp;
temp = *a;
*a = *b;
*b = temp;


Before swapping:


After swapping:

Let’s check the detailed explanation of the program. We initialized two integer variables m,n and we printed its value before swapping that is 10,20.
Now we are calling a function by passing the address of the arguments to the called function. When we are calling a function current status of the program execution will be saved in the stack and the program counter will jump to the called function. In the called function swap pointers are used as the function arguments and denoted as int *a, int *b. with these arguments, we can hold the address of the integer variables m and n. pointer variable *a have the address of m and b have the address of n.
In the called function we declared an integer variable temp. The de-referenced value of *a is assigned to temp ie, 10 De-referenced value of b is assigned to pointer a. Now a became 20 Finally value in the variable temp is assigned to *b, so b became 10 When we were assigning values to the pointers all these values were got stored directly in the memory location. The memory locations which were held by the pointers. *a have the address of m and the value 10 in the beginning so after the swapping to that memory location 20 came and overwritten the 10 Same things happened to *b.
Let’s see the picture below for the clarification.
 Also, Learn Embedded System Click Here

Conditional Operators

Conditional Operators:

Conditional operators also called ternary operators. Because it has three sets of expressions. Conditional operators return one value if the condition is true and returns another value if the condition is wrong.
The syntax of the expression and example is given below.




Let’s consider a program for the detailed understanding,
Int main()
Int a=10;
Int b=20;
Int c;
Printf(“The value after conditional operation is %d”,c=(a>b?a,b));
Return 0;


The value after conditional operation is 20
So in this program, We are initializing two integers a, b as 10 and 20 And another variable c. we are took
use of printf to print the output of conditional operator.
Conditional operator comparing the values of a and b. if a is greater than b. it will print the value of a or
b. In our example b is greater than a. so the conditional operators will print the variable b value.

Arithmetic Operators in C

Arithmetic Operators in C

These operators give the ability to do the arithmetical operations like

a. Addition

By using this operator it will allow the user to add two or more operands and to get the sum.
Ex: Please consider the bellow mentioned program
/*Addition operator Explanation*/
#include<stdio.h> // Preprocessor to include the stdio.h
int main()
// Main function which will return integer value
// Starting of the program/ function
int a=10;
// Initializing the variables a,b and declaring variable c
int b=20;
//Addition of a and b
printf(“Addition of the two numbers is c=%d\n”,c);
// Subtraction of a from b
printf(“Difference of the two numbers is c=%d\n”,c);
//Product of a and b
printf(“Product of the two numbers is c=%d\n”,c);
//Dividing b by a
printf(“Division of the two numbers is c=%d\n”,c);
// finding the modulus of b by a
printf(“Modulus of the two numbers is c=%d\n”,c);
printf(“Pre-increment of the two numbers is ++a=%d\n”,++a); //Pre-incrementing the value by 1
printf(“Pre-decrement of the two numbers is –a=%d\n”,–a); // Pre-decrementing the value by 1
printf(“Post-increment of the two numbers is a++=%d\n”,a++); // Post-incrementing the value by 1
printf(“Post-decrement of the two numbers is a–=%d\n”,a–); // Post-decrementing the value by 1
return 0;
Addition of the two numbers is c=30
Difference of the two numbers is c=10
Product of the two numbers is c=200
Division of the two numbers is c=2
Modulus of the two numbers is c=0
Pre-increment of the two numbers is ++a=11
Pre-decrement of the two numbers is –a=10
Post-increment of the two numbers is a++=10
Post-decrement of the two numbers is a–=11

Explanation :

In the above program we are trying to explain the working of arithmetic operators. There are 7 diffent types of arithmetic operators.
In this program after including the standard input /output header file to the program by using #include preprocessor, we are initializing the variables a,b and declaring the variable C. All these variables are integer data types. Next line onwards we are executing the operation.


Adding the two values which are stored in the two variables a and b and saving the sum value to variable c. Using printf function we printing the value on the console (output screen).


We are finding the difference between two values which are stored in the two variables a and b saving the difference value to variable c. Using printf function we printing the value on the console (output screen).


Dividing one value with another which are stored in the two variables a and b and saving the quotient value to variable c. Using printf function we printing the value on the console (output screen).


Dividing one value with another which are stored in the two variables a and b and saving the remainder value to variable c. Using printf function we printing the value on the console output screen)


This increment operator first increments the value stored in variable ‘ a’ by 1 and store it back in the same variable.


This decrement operator first decrements the value stored in variable ’ a’ by 1 and store it back in the same variable.


This increment operator increments the value stored in the variable ‘a’ by 1 and stores it back in the same variable. But it will get in effect in the next instruction only.


This decrement operator increments the value stored in the variable ‘a’ by 1 and stores it back in the same variable. But it will get in effect in the next instruction only.
After the execution of the program, it will return 0 back to the main function (Because we used int main (), the return type of main() is an integer type only).

Operators in C

Operators in C :

There are a lot of symbols in C. One set of them we can call as operators. Operators are symbols which tell the computer to do some specific task. C is Rich with operators. They are mentioned below.
Before we proceed further consider A+B=C
Here A, B, C are the operands and ‘+’ is the operator. A+B=C is the operation.

a) Arithmetic Operators

All the arithmetic operations we can do with the arithmetic operators.

b) Relational Operators

These operators will check the relation between the two operands. Its output will come as true or false. If it is true it will execute the following code otherwise not.

c) Logical Operators

It will check the logical relationship between the two cases. Depending upon the logical operators we used and its condition it will give the result.

d) Bitwise Operators

As the name suggests bitwise operators work on bits and will do the operations on the bits.

e) Assignment Operators

Assignment operators will assign the value of an operand to another operand after the operation.

f) Misc Operators

These also called as special purpose operators. They also have a special function to complete.
All these operators above mentioned will explain in detailed in the next topics.

Pointers and Addresses

Pointers and Addresses:

When we are talking about the program and its execution we will come up with addresses. All the variables, functions, arrays, etc like whatever we are using to write and execute a program all are saved in memory. Memory will be starting and ending with some memory address. The accessibility to these memories we can do only with memory addresses only. It will give the privilege to the programmer to make changes from a very base level.


It is the information about the data, where it is saved in memory. If you want the address of a variable
you can use the ’&’ address of the operator.


It is the ability of the variable to hold the address of another variable(Points to the address of another variable). The pointer is denoted ‘*’ Asteric symbol. One of the major advantages of the pointer is it will give direct access to the memory address of the variables, functions, arrays, strings, linked list etc..
The size of the pointer is depending upon the size of the memory. For eg, if the memory is 8-bit memory the pointer size will be 8 bit. If it is 16 bit then the pointer will be 16-bit memory.
Let us check an example program.
Int main()
Int a=90;
//integer variable definition
Int *p;
// pointer declaration
// Assigning the address of a to the pointer p.
Printf(“Value of integer a =%d”,a);
Printf(“Value of integer pointer p =%d”,p);
Printf(“Address of integer a =%d”,&a);
Printf(“Address of integer pointer p =%d”,&p);
Printf(“De-referenced value of integer pointer p =%d”,*p);
Return 0;


Your Name*
Phone Number*
Email Address*