Logic analyzer for signal debugging in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of signal capture buffer code

What is the output of the following embedded C code that simulates capturing 8 digital signal samples into a buffer?

Embedded C

#include <stdio.h>
#include <stdint.h>

int main() {
    uint8_t signal_samples[8] = {1, 0, 1, 1, 0, 0, 1, 0};
    uint8_t buffer = 0;
    for (int i = 0; i < 8; i++) {
        buffer |= (signal_samples[i] << i);
    }
    printf("0x%02X\n", buffer);
    return 0;
}

A 0x4D

B 0x5B

C 0xA5

D 0x6B

💡 Hint

Remember that each bit is shifted by its index and ORed into the buffer.

The buffer accumulates bits from the signal_samples array, each shifted by its index. The bits are: 1 (bit0), 0 (bit1), 1 (bit2), 1 (bit3), 0 (bit4), 0 (bit5), 1 (bit6), 0 (bit7). This forms binary 01001101 which is 0x4D in hex.

🧠 Conceptual

intermediate

Understanding signal sampling rate importance

Why is it important to sample a digital signal at a rate higher than twice its highest frequency component when using a logic analyzer?

A To reduce the amount of data stored in the buffer

B To avoid aliasing and accurately reconstruct the signal transitions

C To increase the voltage level of the signal

D To synchronize the signal with the microcontroller clock

💡 Hint

Think about how sampling relates to signal frequency and reconstruction.

Sampling at more than twice the highest frequency (Nyquist rate) prevents aliasing, which causes distortion and incorrect signal representation.

🔧 Debug

advanced

Debugging incorrect signal capture in ISR

Given the following ISR code snippet for capturing a signal edge, what is the main bug causing incorrect signal data capture?

Embedded C

volatile uint8_t signal_buffer = 0;
volatile uint8_t bit_index = 0;

void ISR_signal_edge() {
    uint8_t signal_value = READ_SIGNAL_PIN();
    signal_buffer |= (signal_value << bit_index);
    bit_index++;
    if (bit_index >= 8) {
        bit_index = 0;
        PROCESS_SIGNAL(signal_buffer);
        signal_buffer = 0;
    }
}

A The signal_buffer is reset before processing

B The bit_index variable is not incremented

C The signal_value is not read from the correct pin

D No synchronization for shared variables between ISR and main code

💡 Hint

Consider what happens if main code reads signal_buffer while ISR modifies it.

Since signal_buffer and bit_index are shared between ISR and main code, they need atomic access or synchronization to avoid race conditions causing corrupted data.

📝 Syntax

advanced

Identify syntax error in signal capture loop

Which option contains the correct syntax for capturing 8 bits from a digital input pin into a byte variable?

Embedded C

uint8_t capture_signal() {
    uint8_t result = 0;
    for (int i = 0; i < 8; i++) {
        result |= (READ_PIN() << i)
    }
    return result;
}

A Add a semicolon after the bitwise OR operation line

B Change the for loop to while loop without braces

C Remove the shift operator <<

D Declare result as int instead of uint8_t

💡 Hint

Check each line for missing punctuation.

The line 'result |= (READ_PIN() << i)' is missing a semicolon at the end, causing a syntax error.

🚀 Application

expert

Calculate number of captured signal edges

A logic analyzer captures signal edges by storing each edge event in a 16-bit unsigned integer array of size 64. Each element stores the timestamp of an edge in microseconds. If the analyzer runs for 10 milliseconds and captures edges every 150 microseconds on average, how many edges will be stored in the array after the run?

A 66 edges

B 67 edges

C 64 edges

D 60 edges

💡 Hint

Calculate how many 150 microsecond intervals fit into 10 milliseconds, then consider array size.

10 ms = 10,000 us. 10,000 / 150 ≈ 66.66 edges, but array size is 64, so only 64 edges can be stored.

Practice

1. What is the main purpose of a logic analyzer in embedded C programming?

easy

A. To increase the clock speed of the microcontroller

B. To capture and display digital signal changes for debugging

C. To compile the embedded C code faster

D. To store large amounts of data permanently

Solution

1. Step 1: Understand the role of a logic analyzer

   A logic analyzer is a tool used to observe digital signals and their timing to find bugs in hardware or software.

2. Step 2: Match the purpose with the options

   Only To capture and display digital signal changes for debugging describes capturing and displaying digital signals for debugging, which matches the logic analyzer's purpose.

3. Final Answer:

   To capture and display digital signal changes for debugging -> Option B

4. Quick Check:

   Logic analyzer = signal capture and debugging [OK]

Hint: Logic analyzers show signals, not speed or storage [OK]

Common Mistakes:

• Confusing logic analyzer with compiler tools
• Thinking it increases microcontroller speed
• Assuming it stores data permanently

2. Which of the following code snippets correctly reads a digital input pin for logic analysis in embedded C?

easy

A. int signal = digitalRead(PIN);

B. int signal = PIN.read();

C. int signal = readDigital(PIN);

D. int signal = digital_input(PIN);

Solution

1. Step 1: Identify standard embedded C syntax for reading pins

   In embedded C, reading a digital pin often uses a function like digitalRead(pin) returning the pin state.

2. Step 2: Compare options to common embedded C functions

   Only int signal = digitalRead(PIN); uses the correct function digitalRead with the pin as argument.

3. Final Answer:

   int signal = digitalRead(PIN); -> Option A

4. Quick Check:

   digitalRead(pin) is standard pin read [OK]

Hint: Look for standard function digitalRead(pin) syntax [OK]

Common Mistakes:

• Using object-oriented syntax not valid in C
• Inventing non-standard function names
• Missing parentheses in function calls

3. Given the code below, what will be the content of the buffer after execution?

int buffer[4];
for(int i = 0; i < 4; i++) {
    buffer[i] = (i % 2) ? 1 : 0;
}

medium

A. [0, 1, 0, 1]

B. [1, 0, 1, 0]

C. [0, 0, 0, 0]

D. [1, 1, 1, 1]

Solution

1. Step 1: Analyze the loop and condition

   The loop runs i from 0 to 3. For each i, buffer[i] is set to 1 if i is odd (i % 2 == 1), else 0.

2. Step 2: Calculate values for each i

   i=0: 0%2=0 -> buffer[0]=0
   i=1: 1%2=1 -> buffer[1]=1
   i=2: 2%2=0 -> buffer[2]=0
   i=3: 3%2=1 -> buffer[3]=1

3. Final Answer:

   [0, 1, 0, 1] -> Option A

4. Quick Check:

   Odd i -> 1, Even i -> 0 [OK]

Hint: Remember i%2 is 0 for even, 1 for odd [OK]

Common Mistakes:

• Mixing up odd and even conditions
• Misreading the loop range
• Assuming all values are 1 or 0

4. Identify the error in the following embedded C code snippet intended to sample a digital signal into a buffer:

int buffer[5];
for(int i = 0; i <= 5; i++) {
    buffer[i] = digitalRead(PIN);
}

medium

A. digitalRead function is not declared

B. The loop variable i should start at 1

C. Buffer size should be 6 instead of 5

D. The loop condition causes buffer overflow

Solution

1. Step 1: Check loop bounds against buffer size

   The buffer has 5 elements indexed 0 to 4. The loop runs i from 0 to 5 inclusive, which means i=5 is out of bounds.

2. Step 2: Identify the consequence of out-of-bounds access

   Accessing buffer[5] causes buffer overflow, which can crash or corrupt memory.

3. Final Answer:

   The loop condition causes buffer overflow -> Option D

4. Quick Check:

   Loop i <= 5 with size 5 causes overflow [OK]

Hint: Loop index must be less than buffer size [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Ignoring array index limits
• Assuming digitalRead is missing declaration

5. You want to capture a digital signal's state every 10 microseconds for 100 samples using embedded C. Which approach correctly implements this logic analyzer sampling?

hard

A. Use a recursive function calling digitalRead(PIN) without delay

B. Use a while loop without delay and store digitalRead(PIN) continuously

C. Use a for loop with delayMicroseconds(10) and store digitalRead(PIN) in an array

D. Use a for loop with delay(10) and store analogRead(PIN) in an array

Solution

1. Step 1: Understand timing and sampling requirements

   Sampling every 10 microseconds means a precise short delay between reads. delayMicroseconds(10) provides microsecond delay.

2. Step 2: Match code approach to requirements

   Use a for loop with delayMicroseconds(10) and store digitalRead(PIN) in an array uses a for loop for 100 samples, calls delayMicroseconds(10), and stores digitalRead(PIN) which is correct for digital signal sampling.

3. Final Answer:

   Use a for loop with delayMicroseconds(10) and store digitalRead(PIN) in an array -> Option C

4. Quick Check:

   Precise delay + digitalRead + loop = correct sampling [OK]

Hint: Use delayMicroseconds for microsecond timing [OK]

Common Mistakes:

• Using delay() which is milliseconds, not microseconds
• Reading analog instead of digital signals
• Missing delay causing too fast sampling