Introduction to Data Types
• Definition: Data types define the type of data a variable can hold.
• Importance in embedded systems: Efficient use of memory and optimized performance.
Categories of Data Types
• Primary Data Types: char, int, float, double
• Derived Data Types: Arrays, Pointers, Structures
• Enumerated Types: enum
• Void: For functions with no return value.
Integer Types:
• int: Signed integer.
• unsigned int: Unsigned integer.
• Sizes: Typically 16 or 32 bits depending on architecture.
• Example: int count = 100;
Character Types:
• char: Represents a single character (ASCII).
• Size: 8 bits (1 byte).
• Example: char grade = 'A';
Floating-Point Types:
• float: Single precision floating-point.
• double: Double precision floating-point.
• Example: float pi = 3.14;
Integer Data Types with Modifiers:
Modifiers allow customization of the range and size of data types.
• Signed vs Unsigned:
o signed int: Can store both negative and positive values.
o unsigned int: Stores only positive values.
• Short and Long Modifiers:
o short int: Smaller range (usually 16 bits).
o long int: Larger range (usually 32 or 64 bits).
Example:
unsigned short int value = 65535;
long int distance = 100000L;
3. Floating-Point Precision:
• Float: Typically 4 bytes (32 bits).
• Double: Typically 8 bytes (64 bits).
• Use of floating-point numbers is often avoided in embedded systems for performance
reasons.
Example:
double largeNum = 123456.789;
Page 2 - Side 1: Derived and User-Defined Data Types
4. Derived Data Types:
• Arrays: Collection of elements of the same type.
Example: int numbers[10];
• Pointers: Variables that store memory addresses.
Example:
int x = 10;
int *ptr = &x;
• Structures: User-defined data types that group variables of different types.
Example:
struct Person {
char name[50];
int age;
};
• Unions: Memory-efficient data type that allows storing different data types in the same
memory location.
Example:
union Data {
int i;
float f;
};
Page 2 - Side 2: Enumerated Types and Special Types
5. Enumerated Types (Enum):
Defines named integer constants.
Example:
enum Day { MON, TUE, WED, THU, FRI };
6. Typedef and Void:
• Typedef: Allows creating new names (aliases) for existing types.
Example:
typedef unsigned int uint;
uint score = 100;
• Void: Used to indicate no value or no return type for functions.
Example:
void display();
7. Volatile and Const:
• Volatile: Tells the compiler that a variable can change at any time.
Example:
volatile int timer;
• Const: Indicates that a variable's value cannot be changed after initialization.
Example:
const int MAX = 100;
Functions in C
Introduction to Functions in Embedded C
1. What are Functions?
Functions are blocks of code designed to perform a specific task. They help in code reusability,
modularity, and readability.
2. Advantages of Using Functions in Embedded C:
• Modularity: Break complex programs into simpler, manageable parts.
• Reusability: Write once, use multiple times.
• Easier Debugging: Isolate and test individual functions.
• Memory Efficiency: Functions can be optimized for better memory usage.
3. Types of Functions:
• Standard Library Functions: Provided by C libraries (printf(), scanf(), etc.).
• User-Defined Functions: Created by the programmer to meet specific needs.
Page 1 - Side 2: Function Components and Declaration
4. Components of a Function:
• Return Type: The data type of the value the function returns. (void, int, char, etc.)
• Function Name: A unique identifier for the function.
• Parameters (Arguments): Inputs passed to the function.
• Body: The block of code that defines the function’s task.
Syntax:
return_type function_name(parameter_list) {
// Function body
Example:
int add(int a, int b) {
return a + b;
Page 2 - Side 1: Function Categories and Parameter Passing
5. Categories of Functions:
• Void Functions: Do not return a value.
Example:
void blinkLED() {
// Code to blink an LED
• Functions with Return Values: Return a result to the caller.
Example:
int multiply(int x, int y) {
return x * y;
6. Parameter Passing Methods:
• Pass by Value: Copies the actual value of the argument. Changes do not affect the original
variable.
Example:
void display(int num) {
printf("%d", num);
• Pass by Reference: Passes the address of the argument, allowing the function to modify the
original variable.
Example:
void increment(int *num) {
(*num)++;
Page 2 - Side 2: Recursive Functions and Best Practices
7. Recursive Functions:
A function that calls itself to solve smaller instances of a problem. Useful for tasks like factorial
calculation, Fibonacci series, etc.
Example:
int factorial(int n) {
if (n == 0)
return 1;
else
return n * factorial(n - 1);
8. Inline Functions (Keyword inline):
These functions are expanded at the point of call, reducing overhead but increasing code size. Useful
for small, frequently called functions.
Example:
inline int square(int x) {
return x * x;
9. Best Practices for Functions in Embedded C:
• Keep Functions Short and Focused: Each function should perform a single task.
• Use Descriptive Names: Helps in understanding code.
• Minimize Global Variables: Use parameters to pass data instead.
• Optimize for Performance: Avoid recursion and floating-point operations where possible.
• Error Handling: Use return values or status flags to indicate errors.
