Clock gating for power saving in Embedded C - Mini Project: Build & Apply

Clock gating for power saving

📖 Scenario: In embedded systems, saving power is very important. One way to save power is to stop the clock signal to parts of the circuit that are not in use. This is called clock gating. In this project, you will write simple C code to control clock gating for two peripherals: a timer and a UART.

🎯 Goal: You will create variables to represent clock enable signals for the timer and UART. Then you will write code to turn these clocks on or off based on whether the peripherals are needed. Finally, you will print the clock status to see if clock gating is working.

📋 What You'll Learn

Create two variables to represent clock enable signals for timer and UART

Create a configuration variable to decide if UART is needed

Write code to enable timer clock always and enable UART clock only if needed

Print the status of timer and UART clock enable signals

💡 Why This Matters

🌍 Real World

Clock gating is used in real embedded devices like microcontrollers and SoCs to save battery life by stopping clocks to unused parts.

💼 Career

Understanding clock gating helps embedded engineers optimize power consumption in hardware designs and firmware.

1

Create clock enable variables

Create two integer variables called timer_clk_enable and uart_clk_enable. Set both to 0 initially to represent clocks off.

Embedded C

// Create two integer variables called timer_clk_enable and uart_clk_enable and set both to 0
// Your code here

Hint

Use int to create variables and set them to 0.

2

Create UART needed configuration variable

Create an integer variable called uart_needed and set it to 1 to mean UART is needed.

Embedded C

int timer_clk_enable = 0;
int uart_clk_enable = 0;

// Create an integer variable uart_needed and set it to 1
// Your code here

Hint

Use int uart_needed = 1; to create the variable.

3

Enable clocks based on configuration

Set timer_clk_enable to 1 to always enable timer clock. Use an if statement to set uart_clk_enable to 1 only if uart_needed is 1. Otherwise, set uart_clk_enable to 0.

Embedded C

int timer_clk_enable = 0;
int uart_clk_enable = 0;
int uart_needed = 1;

// Enable timer clock
// Enable UART clock only if uart_needed is 1
// Your code here

Hint

Use if (uart_needed == 1) to check the condition and set uart_clk_enable accordingly.

4

Print clock enable status

Use printf to print the values of timer_clk_enable and uart_clk_enable in the format: "Timer clock: %d, UART clock: %d\n".

Embedded C

int timer_clk_enable = 0;
int uart_clk_enable = 0;
int uart_needed = 1;

timer_clk_enable = 1;
if (uart_needed == 1) {
    uart_clk_enable = 1;
} else {
    uart_clk_enable = 0;
}

// Print the clock enable status
// Your code here

Hint

Use printf("Timer clock: %d, UART clock: %d\n", timer_clk_enable, uart_clk_enable); inside main.

Practice

1. What is the main purpose of clock gating in embedded systems?

easy

A. To enable all hardware modules simultaneously

B. To increase the clock speed of the processor

C. To reset the microcontroller

D. To save power by turning off clocks to unused modules

Solution

1. Step 1: Understand clock gating concept

   Clock gating disables the clock signal to parts of a chip that are not in use.

2. Step 2: Identify the main benefit

   Disabling clocks reduces power consumption and heat generation.

3. Final Answer:

   To save power by turning off clocks to unused modules -> Option D

4. Quick Check:

   Clock gating = power saving [OK]

Hint: Clock gating means stopping clocks to save power [OK]

Common Mistakes:

• Thinking clock gating speeds up the processor
• Confusing clock gating with resetting hardware
• Assuming clock gating enables all modules

2. Which of the following is the correct way to enable clock gating for a peripheral in embedded C?

easy

A. CLK_GATE_REG |= (1 << PERIPHERAL_BIT);

B. CLK_GATE_REG &= ~(1 << PERIPHERAL_BIT);

C. CLK_GATE_REG = 0;

D. CLK_GATE_REG ^= (1 << PERIPHERAL_BIT);

Solution

1. Step 1: Understand bit setting for enabling clock gating

   Setting a bit (using |=) enables clock gating for that peripheral.

2. Step 2: Analyze each option

   CLK_GATE_REG |= (1 << PERIPHERAL_BIT); sets the bit; CLK_GATE_REG &= ~(1 << PERIPHERAL_BIT); clears it; CLK_GATE_REG = 0; clears all bits; CLK_GATE_REG ^= (1 << PERIPHERAL_BIT); toggles bits.

3. Final Answer:

   CLK_GATE_REG |= (1 << PERIPHERAL_BIT); -> Option A

4. Quick Check:

   Set bit to enable clock gating [OK]

Hint: Use |= to set bits for enabling clock gating [OK]

Common Mistakes:

• Using &=~ which clears bits instead of setting
• Assigning 0 clears all bits
• Using ^= toggles bits unpredictably

3. Given the code snippet:

uint32_t CLK_GATE_REG = 0x0;
#define PERIPH1_BIT 2
CLK_GATE_REG |= (1 << PERIPH1_BIT);
CLK_GATE_REG &= ~(1 << PERIPH1_BIT);

What is the final value of CLK_GATE_REG?

medium

A. 0x4

B. 0x0

C. 0x2

D. 0x6

Solution

1. Step 1: Set bit 2 in CLK_GATE_REG

   CLK_GATE_REG |= (1 << 2) sets bit 2, so value becomes 0x4.

2. Step 2: Clear bit 2 in CLK_GATE_REG

   CLK_GATE_REG &= ~(1 << 2) clears bit 2, so value returns to 0x0.

3. Final Answer:

   0x0 -> Option B

4. Quick Check:

   Set then clear bit 2 = 0x0 [OK]

Hint: Set then clear same bit results in zero [OK]

Common Mistakes:

• Forgetting that clearing bit resets value
• Confusing bit positions
• Assuming bits accumulate without clearing

4. Identify the error in this clock gating code snippet:

uint32_t CLK_GATE_REG = 0xFF;
#define PERIPH2_BIT 3
CLK_GATE_REG = (1 << PERIPH2_BIT);

medium

A. It toggles bit 3 instead of setting it

B. It correctly enables clock gating for peripheral 2

C. It clears all bits except bit 3, disabling other clocks

D. It causes a syntax error due to missing semicolon

Solution

1. Step 1: Analyze the assignment operation

   Assigning CLK_GATE_REG = (1 << 3) overwrites previous bits, clearing all except bit 3.

2. Step 2: Understand impact on clock gating

   This disables clock gating for other peripherals unintentionally.

3. Final Answer:

   It clears all bits except bit 3, disabling other clocks -> Option C

4. Quick Check:

   Direct assignment clears other bits [OK]

Hint: Use |= to set bits, not = to avoid clearing others [OK]

Common Mistakes:

• Using = instead of |= to set bits
• Ignoring impact on other bits
• Thinking this toggles bits

5. You want to save power by gating clocks to peripherals only when they are idle. Which approach correctly implements this in embedded C?

void update_clock_gating(bool peripheral_active) {
    if (peripheral_active) {
        CLK_GATE_REG &= ~(1 << PERIPH_BIT); // Disable gating
    } else {
        CLK_GATE_REG |= (1 << PERIPH_BIT);  // Enable gating
    }
}

hard

A. This code correctly enables gating when peripheral is idle

B. This code enables gating when peripheral is active, which wastes power

C. This code disables gating in both cases, no power saving

D. This code causes syntax errors due to missing variable declarations

Solution

1. Step 1: Understand gating logic in code

   When peripheral_active is true, gating is disabled (clock runs). When false, gating is enabled (clock off).

2. Step 2: Confirm power saving behavior

   Enabling gating only when peripheral is idle saves power correctly.

3. Final Answer:

   This code correctly enables gating when peripheral is idle -> Option A

4. Quick Check:

   Gating enabled when idle = power saving [OK]

Hint: Enable gating only when peripheral is idle [OK]

Common Mistakes:

• Reversing active and idle logic
• Forgetting to use |= and &=~ correctly
• Assuming code has syntax errors without checking