Direction register vs data register in Embedded C - Hands-On Comparison

Direction Register vs Data Register

📖 Scenario: You are working with a simple microcontroller that controls LEDs connected to its pins. To turn LEDs on or off, you need to set the pin direction and then write data to the pins.Understanding the difference between the direction register and the data register is important to control the pins correctly.

🎯 Goal: Learn how to set pin directions using the direction register and control the output using the data register in embedded C.You will write code to configure pins as outputs and then turn LEDs on or off by writing to the data register.

📋 What You'll Learn

Create a variable representing the direction register with initial value 0x00

Create a variable representing the data register with initial value 0x00

Set the direction register to configure pins 0 and 1 as outputs

Write to the data register to turn on LED connected to pin 0 and turn off LED connected to pin 1

Print the final values of direction and data registers in hexadecimal format

💡 Why This Matters

🌍 Real World

Microcontrollers use direction registers to set pins as input or output and data registers to control the voltage level on output pins. This is how devices like LEDs, motors, and sensors are controlled.

💼 Career

Embedded systems engineers and firmware developers frequently work with direction and data registers to program hardware behavior at the pin level.

1

Create direction and data registers

Create two unsigned 8-bit variables called DIR_REG and DATA_REG and set both to 0x00.

Embedded C

# Create two unsigned 8-bit variables called DIR_REG and DATA_REG and set both to 0x00
// Your code here

Hint

Use unsigned char to represent 8-bit registers and assign 0x00 to both.

2

Configure pin directions

Set the variable DIR_REG to configure pin 0 and pin 1 as outputs by setting bits 0 and 1 to 1. Use hexadecimal notation.

Embedded C

unsigned char DIR_REG = 0x00;
unsigned char DATA_REG = 0x00;
// Set DIR_REG bits 0 and 1 to 1 to configure pins 0 and 1 as outputs
// Your code here

Hint

Bits 0 and 1 correspond to 0x01 and 0x02, so combined they are 0x03.

3

Write data to pins

Set the variable DATA_REG to turn on the LED connected to pin 0 and turn off the LED connected to pin 1. Set bit 0 to 1 and bit 1 to 0 using hexadecimal notation.

Embedded C

unsigned char DIR_REG = 0x03;
unsigned char DATA_REG = 0x00;
// Set DATA_REG bit 0 to 1 and bit 1 to 0 to turn on LED at pin 0 and off at pin 1
// Your code here

Hint

Bit 0 is 0x01, bit 1 is 0x02. To turn on pin 0 and off pin 1, set DATA_REG to 0x01.

4

Print register values

Print the values of DIR_REG and DATA_REG in hexadecimal format using printf. Use the format string "DIR_REG = 0x%02X, DATA_REG = 0x%02X\n".

Embedded C

unsigned char DIR_REG = 0x03;
unsigned char DATA_REG = 0x01;
// Print DIR_REG and DATA_REG values in hexadecimal format
// Your code here

Hint

Use printf with format specifier %02X to print two-digit uppercase hex values.

Practice

1. What is the primary role of a direction register in embedded C programming?

easy

A. It resets the microcontroller.

B. It stores the data value to be sent through the pin.

C. It sets whether a pin is an input or an output.

D. It controls the clock speed of the microcontroller.

Solution

1. Step 1: Understand the function of direction register

   The direction register configures each pin as either input or output.

2. Step 2: Differentiate from data register

   The data register holds the actual value sent or received, not the pin mode.

3. Final Answer:

   It sets whether a pin is an input or an output. -> Option C

4. Quick Check:

   Direction register = Pin mode control [OK]

Hint: Direction register controls pin mode, not data value [OK]

Common Mistakes:

• Confusing direction register with data register
• Thinking direction register stores data values
• Mixing up pin configuration with clock control

2. Which of the following is the correct way to set pin 3 as output using a direction register named DIR_REG in embedded C?

easy

A. DIR_REG = 1 << 3;

B. DIR_REG |= (1 << 3);

C. DIR_REG &= ~(1 << 3);

D. DIR_REG ^= (1 << 3);

Solution

1. Step 1: Understand setting a bit without affecting others

   Using |= with (1 << 3) sets bit 3 to 1, keeping other bits unchanged.

2. Step 2: Analyze other options

   DIR_REG = 1 << 3; overwrites all bits, DIR_REG &= ~(1 << 3); clears bit 3, DIR_REG ^= (1 << 3); toggles bit 3.

3. Final Answer:

   DIR_REG |= (1 << 3); -> Option B

4. Quick Check:

   Use |= to set bits safely [OK]

Hint: Use |= to set a bit without changing others [OK]

Common Mistakes:

• Using = instead of |= which overwrites all bits
• Using &=~ which clears the bit instead of setting
• Using ^= which toggles the bit unpredictably

3. Given the following code snippet, what is the final value of DATA_REG if initially it was 0x00?

DIR_REG |= (1 << 2);  // Set pin 2 as output
DATA_REG |= (1 << 2); // Set pin 2 high
DATA_REG &= ~(1 << 1); // Clear pin 1
DATA_REG ^= (1 << 2);  // Toggle pin 2

medium

A. 0x04

B. 0x06

C. 0x02

D. 0x00

Solution

1. Step 1: Trace DATA_REG changes step-by-step

   Initially DATA_REG = 0x00.
   After DATA_REG |= (1 << 2); DATA_REG = 0x04.
   After DATA_REG &= ~(1 << 1); bit 1 cleared, no change, DATA_REG = 0x04.
   After DATA_REG ^= (1 << 2); toggles bit 2, DATA_REG = 0x00.

2. Step 2: Confirm final value

   Final DATA_REG value is 0x00 after toggling bit 2 off.

3. Final Answer:

   0x00 -> Option D

4. Quick Check:

   Toggle bit 2 twice returns to 0 [OK]

Hint: Toggle a bit twice returns it to original state [OK]

Common Mistakes:

• Ignoring toggle effect and assuming bit stays set
• Confusing bit positions (bit 1 vs bit 2)
• Not tracking bit clearing correctly

4. Identify the error in the following code that tries to set pin 0 as output and set it high:

DIR_REG = DIR_REG & (1 << 0);
DATA_REG = DATA_REG | (1 << 0);

medium

A. Using & instead of | to set direction bit clears other bits.

B. DATA_REG should use &= instead of | to set pin high.

C. DIR_REG should be assigned 0, not bitwise operation.

D. No error, code works correctly.

Solution

1. Step 1: Analyze DIR_REG operation

   DIR_REG & (1 << 0) clears all bits except bit 0, overwriting other pin settings.

2. Step 2: Correct way to set bit without clearing others

   Use DIR_REG |= (1 << 0) to set bit 0 without affecting others.

3. Final Answer:

   Using & instead of | to set direction bit clears other bits. -> Option A

4. Quick Check:

   Use |= to set bits, not & [OK]

Hint: Use |= to set bits, & clears bits [OK]

Common Mistakes:

• Using & instead of |= to set bits
• Thinking |= clears bits
• Assuming DATA_REG needs &= to set bits

5. You want to configure pins 0, 2, and 4 as outputs and set pins 0 and 4 high without changing other pins. Which sequence of operations correctly achieves this?

// Initial values: DIR_REG = 0x08, DATA_REG = 0x02

hard

A. DIR_REG |= (1 << 0) | (1 << 2) | (1 << 4);
DATA_REG |= (1 << 0) | (1 << 4);

B. DIR_REG = (1 << 0) | (1 << 2) | (1 << 4);
DATA_REG = (1 << 0) | (1 << 4);

C. DIR_REG &= ~((1 << 1) | (1 << 3));
DATA_REG |= (1 << 0) | (1 << 4);

D. DIR_REG |= (1 << 1) | (1 << 3);
DATA_REG |= (1 << 2);

Solution

1. Step 1: Set pins 0, 2, 4 as outputs without clearing others

   Use DIR_REG |= (1 << 0) | (1 << 2) | (1 << 4); to set these bits safely.

2. Step 2: Set pins 0 and 4 high without affecting others

   Use DATA_REG |= (1 << 0) | (1 << 4); to set those pins high.

3. Step 3: Analyze other options

   DIR_REG = (1 << 0) | (1 << 2) | (1 << 4); DATA_REG = (1 << 0) | (1 << 4); overwrites all bits, clearing others.
   DIR_REG &= ~((1 << 1) | (1 << 3)); DATA_REG |= (1 << 0) | (1 << 4); clears pins 1 and 3 but does not set required pins.
   DIR_REG |= (1 << 1) | (1 << 3); DATA_REG |= (1 << 2); sets wrong pins.

4. Final Answer:

   DIR_REG |= (1 << 0) | (1 << 2) | (1 << 4); DATA_REG |= (1 << 0) | (1 << 4); -> Option A

5. Quick Check:

   Use |= to set multiple bits safely [OK]

Hint: Use |= with combined bits to set multiple pins safely [OK]

Common Mistakes:

• Using = which overwrites other pins
• Setting wrong pins by mistake
• Clearing pins unintentionally