https://blog.implrust.com • This is a web feed, also known as an Atom feed. Subscribe by copying the URL from the address bar into your newsreader. Visit About Feeds to learn more and get started. It's free. Visit website Recent posts Updated on $DATE date debugging impl Rust Blog Posts Zola2026-01-28T00:00:00+00:00https://blog.implrust.com/tags/debugging/atom.xml 2026-01-28T00:00:00+00:00 2026-01-28T00:00:00+00:00 implFerris https://blog.implrust.com/posts/2026/01/analyze-uart-embedded-rust-with-usb-logic-analyzer/ <p>In my <a href="https://blog.implrust.com/posts/2026/01/using-logic-analyzer-embedded-rust-pico-esp32/">previous blog post</a>, I introduced the USB logic analyzer, showed how to set up the software, and used a simple GPIO toggle to get familiar with how a logic analyzer works. In this post, we look at UART and see how serial data appears on the wire by analyzing the transmit (TX) signal and understanding how bytes are sent.</p> <p>I initially planned to explain I2C right after the introduction, but I felt that UART is much simpler to start with and provides a gentler introduction to using protocol decoders in PulseView.</p> <h2 id="what-is-uart"><a class="header-anchor no-hover-padding" href="#what-is-uart" aria-label="Anchor link for: what-is-uart"><span class="link-icon" aria-hidden="true"></span></a> What is UART?</h2> <p>You might already be familiar with UART. Still, let me give a short introduction.</p> <p>UART stands for Universal Asynchronous Receiver-Transmitter. It is a simple serial communication method used to send data between two devices. Data is sent one bit at a time, rather than in parallel.</p> <p>UART typically uses two signal lines: one for transmitting data (TX) and one for receiving data (RX). The TX pin of one device is connected to the RX pin of the other, so data sent on TX is received on RX.</p> <p>Unlike some other protocols, UART does not use a clock signal. So a natural question is how the receiver knows when data starts, when it ends, and how to interpret the bits correctly.</p> <p>Let us look at a simple UART signal to understand this.</p> <img src="/img/2026/01/uart-data-transmission.png" alt="uart data transmission" style="width:400px; height:auto; display:block; margin:auto;"/> <p>We can assign LOW state to 0 and HIGH to 1, but this alone is not enough. For example, suppose we want to transmit the value 0x52 (binary 0101_0010). If two or more bits in a row have the same value, such as two consecutive zeros, how does the receiver know whether it is seeing one long zero or multiple zeros?</p> <p>This is where three important UART things come into play: the data length, the start and stop bits, and the transmission speed (baud rate). These three define how many bits make up a byte, and how the beginning and end of a byte are identified, how fast the data is sent.</p> <h3 id="baud-rate-transmission-speed"><a class="header-anchor no-hover-padding" href="#baud-rate-transmission-speed" aria-label="Anchor link for: baud-rate-transmission-speed"><span class="link-icon" aria-hidden="true"></span></a> Baud Rate (Transmission Speed)</h3> <p>The baud rate defines how fast bits are transmitted on the wire. It specifies how many bits are sent per second. For example, a baud rate of 115200 means that 115200 bits are transmitted every second.</p> <p>Both the transmitter and receiver must use the same baud rate. If the baud rate does not match, the receiver will sample the signal at the wrong times and decode incorrect data.</p> <h3 id="data-length"><a class="header-anchor no-hover-padding" href="#data-length" aria-label="Anchor link for: data-length"><span class="link-icon" aria-hidden="true"></span></a> Data Length</h3> <p>The data length specifies how many data bits are sent for each character. The most common configuration is 8 data bits, but other values like 5 to 9 bits are also possible.</p> <p>If the data length is set to 8 bits, then exactly 8 data bits are transmitted for each byte, one after another, starting with the least significant bit.</p> <h3 id="start-and-stop-bits"><a class="header-anchor no-hover-padding" href="#start-and-stop-bits" aria-label="Anchor link for: start-and-stop-bits"><span class="link-icon" aria-hidden="true"></span></a> Start and Stop Bits</h3> <p>When the UART line is idle, it stays in the HIGH state. A transmission always begins with a start bit, which is a transition from HIGH to LOW. This LOW level tells the receiver that a new byte is starting. Once the receiver detects the start bit, it uses the baud rate to time when to read the following data bits.</p> <p>After all data bits are transmitted, the sender adds one or more stop bits. A stop bit is simply the line returning to the HIGH state for a fixed duration.</p> <p>The stop bit marks the end of the byte and gives the receiver time to finish processing the current byte before the next one begins.</p> <h3 id="example"><a class="header-anchor no-hover-padding" href="#example" aria-label="Anchor link for: example"><span class="link-icon" aria-hidden="true"></span></a> Example</h3> <img src="/img/2026/01/uart-data-transmission-with-details.png" alt="uart data transmission with details" style="width:400px; height:auto; display:block; margin:auto;"/> <p>The above diagram shows the transmission of a single UART data byte. Before any data is sent, the signal stays in the idle state, which is HIGH.</p> <p>The transmission begins with the start bit. The start bit is represented by pulling the signal LOW for exactly one bit duration. This transition from HIGH to LOW tells the receiver that a new byte is about to start.</p> <p>Immediately after the start bit, the actual data bits are transmitted. In this example, the byte being sent is 0x52, which in binary is 0101_0010. UART sends data least significant bit first, so the first data bit sent is 0.</p> <p>Because the start bit is LOW and the first data bit is also 0, the signal stays LOW for two consecutive bit periods. From the waveform alone, these two consecutive LOW levels appear as one continuous LOW signal. The receiver does not get confused because it does not rely on signal edges to count bits. Instead, it relies on timing.</p> <p>This is where the baud rate comes in. The baud rate defines how long one bit lasts. For example, at a baud rate of 115200, each bit lasts for about 8.68 microseconds. The receiver measures time from the start bit and samples the signal at fixed intervals, once per bit period. By sampling at these precise times, it knows when one bit ends and the next bit begins, even if the signal level does not change.</p> <p>After all data bits are transmitted, the signal returns to HIGH for the stop bit. The stop bit marks the end of the byte and brings the line back to the idle state. If another byte is sent, the process repeats with another start bit.</p> <p>As long as both sides agree on the baud rate and data format, the receiver can correctly interpret a continuous stream of HIGH and LOW levels as individual bits and bytes.</p> <div class="admonition tip"> <div class="admonition-icon admonition-icon-tip"></div> <div class="admonition-content"> <strong class="admonition-title">TIP</strong> <p>I intentionally avoided many details of UART in this post. I only covered what is necessary for our purpose here and skipped other topics such as parity bits and other. If you want to go deeper, I recommend reading more about UART separately.</p> </div> </div> <h2 id="hardware-setup"><a class="header-anchor no-hover-padding" href="#hardware-setup" aria-label="Anchor link for: hardware-setup"><span class="link-icon" aria-hidden="true"></span></a> Hardware Setup</h2> <p>For this post, I am focusing only on the transmit (TX) pin. The receive (RX) pin works in the same way, just in the opposite direction.</p> <p>Once again, I am using a Raspberry Pi Pico. I will use one of the UART TX pins available on the Pico. In this example, I am using GPIO16 as the UART TX pin. You are free to use a different UART TX pin if you prefer, but you will need to adjust the code accordingly.</p> <p>Connect CH1 of the logic analyzer to GPIO16 on the Pico. Also connect the logic analyzer ground to any ground pin on the Pico.</p> <table><thead><tr><th>Logic Analyzer</th><th>Raspberry Pi Pico</th></tr></thead><tbody> <tr><td>GND</td><td>GND</td></tr> <tr><td>CH1</td><td>GPIO16</td></tr> </tbody></table> <h2 id="code-snippet"><a class="header-anchor no-hover-padding" href="#code-snippet" aria-label="Anchor link for: code-snippet"><span class="link-icon" aria-hidden="true"></span></a> Code Snippet</h2> <p>Flash the program onto the Pico, then power up the board and connect the USB logic analyzer to the computer.</p> <pre data-lang="rust" class="language-rust z-code"><code class="language-rust" data-lang="rust"><span class="z-source z-rust"><span class="z-meta z-annotation z-rust"><span class="z-punctuation z-definition z-annotation z-rust">#</span><span class="z-punctuation z-section z-group z-begin z-rust">[</span><span class="z-variable z-annotation z-rust">embassy_executor</span>::<span class="z-variable z-annotation z-rust">main</span><span class="z-punctuation z-section z-group z-end z-rust">]</span></span> </span><span class="z-source z-rust">async <span class="z-meta z-function z-rust"><span class="z-meta z-function z-rust"><span class="z-storage z-type z-function z-rust">fn</span> </span><span class="z-entity z-name z-function z-rust">main</span></span><span class="z-meta z-function z-rust"><span class="z-meta z-function z-parameters z-rust"><span class="z-punctuation z-section z-parameters z-begin z-rust">(</span><span class="z-variable z-parameter z-rust">_spawner</span><span class="z-punctuation z-separator z-rust">:</span> Spawner</span><span class="z-meta z-function z-rust"><span class="z-meta z-function z-parameters z-rust"><span class="z-punctuation z-section z-parameters z-end z-rust">)</span></span></span></span><span class="z-meta z-function z-rust"> </span><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"><span class="z-punctuation z-section z-block z-begin z-rust">{</span> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> <span class="z-storage z-type z-rust">let</span> p <span class="z-keyword z-operator z-assignment z-rust">=</span> <span class="z-meta z-path z-rust">embassy_rp<span class="z-punctuation z-accessor z-rust">::</span></span>init<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span><span class="z-support z-type z-rust">Default</span><span class="z-meta z-path z-rust"><span class="z-punctuation z-accessor z-rust">::</span></span>default<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> <span class="z-storage z-type z-rust">let</span> <span class="z-storage z-modifier z-rust">mut</span> uart_config <span class="z-keyword z-operator z-assignment z-rust">=</span> <span class="z-meta z-path z-rust">UartConfig<span class="z-punctuation z-accessor z-rust">::</span></span>default<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> <span class="z-comment z-line z-double-slash z-rust"><span class="z-punctuation z-definition z-comment z-rust">//</span> This is default baud rate in the embassy-rp, i just want to explicitly show </span></span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> uart_config<span class="z-punctuation z-accessor z-dot z-rust">.</span>baudrate <span class="z-keyword z-operator z-assignment z-rust">=</span> <span class="z-constant z-numeric z-integer z-decimal z-rust">115200</span><span class="z-punctuation z-terminator z-rust">;</span> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> <span class="z-storage z-type z-rust">let</span> <span class="z-storage z-modifier z-rust">mut</span> uart_tx <span class="z-keyword z-operator z-assignment z-rust">=</span> <span class="z-meta z-path z-rust">UartTx<span class="z-punctuation z-accessor z-rust">::</span></span>new_blocking<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span>p<span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-constant z-other z-rust">UART0</span><span class="z-punctuation z-separator z-rust">,</span> p<span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-constant z-other z-rust">PIN_16</span><span class="z-punctuation z-separator z-rust">,</span> uart_config</span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"> <span class="z-keyword z-control z-rust">loop</span> <span class="z-meta z-block z-rust"><span class="z-punctuation z-section z-block z-begin z-rust">{</span> </span></span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"><span class="z-meta z-block z-rust"> uart_tx </span></span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"><span class="z-meta z-block z-rust"> <span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-support z-function z-rust">blocking_write</span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span><span class="z-string z-quoted z-double z-rust"><span class="z-punctuation z-definition z-string z-begin z-rust">&quot;</span>Rust<span class="z-punctuation z-definition z-string z-end z-rust">&quot;</span></span><span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-support z-function z-rust">as_bytes</span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span> </span></span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"><span class="z-meta z-block z-rust"> <span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-support z-function z-rust">expect</span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span><span class="z-string z-quoted z-double z-rust"><span class="z-punctuation z-definition z-string z-begin z-rust">&quot;</span>unable to write into uart<span class="z-punctuation z-definition z-string z-end z-rust">&quot;</span></span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span></span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"><span class="z-meta z-block z-rust"> <span class="z-meta z-path z-rust">Timer<span class="z-punctuation z-accessor z-rust">::</span></span>after_secs<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span><span class="z-constant z-numeric z-integer z-decimal z-rust">1</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-accessor z-dot z-rust">.</span>await<span class="z-punctuation z-terminator z-rust">;</span> </span></span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"><span class="z-meta z-block z-rust"> </span><span class="z-meta z-block z-rust"><span class="z-punctuation z-section z-block z-end z-rust">}</span></span> </span></span></span><span class="z-source z-rust"><span class="z-meta z-function z-rust"><span class="z-meta z-block z-rust"></span><span class="z-meta z-block z-rust"><span class="z-punctuation z-section z-block z-end z-rust">}</span></span></span> </span></code></pre> <h2 id="number-of-samples-and-sample-rate"><a class="header-anchor no-hover-padding" href="#number-of-samples-and-sample-rate" aria-label="Anchor link for: number-of-samples-and-sample-rate"><span class="link-icon" aria-hidden="true"></span></a> Number of Samples and Sample Rate</h2> <p>In our example, the UART baud rate is 115200. To capture the signal reliably, we use a sample rate of 1 MHz, which is comfortably higher than the baud rate and works well with PulseView.</p> <p>The program sends the string “Rust” once every second and then stays idle in between. Because of this, the capture window must be long enough to include at least one transmission.</p> <p>Using 5 million samples at a 1 MHz sample rate gives a capture duration of about 5 seconds. This ensures that several UART transmissions are captured without having to worry about timing the capture manually.</p> <img src="/img/2026/01/uart-number-of-samples-sample-rate.png" alt="sample rate and number of samples" style="width:400px; height:auto; display:block; margin:auto;"/> <h2 id="start-the-capture"><a class="header-anchor no-hover-padding" href="#start-the-capture" aria-label="Anchor link for: start-the-capture"><span class="link-icon" aria-hidden="true"></span></a> Start the Capture</h2> <p>Since the program transmits the text “Rust” once every second, the capture contains multiple UART transmissions spread across the entire capture window. Because we are viewing several seconds of data at once, the waveform is zoomed out by default.</p> <p>At first glance, it might look like nothing happened. The signal appears mostly flat, with a few thin vertical-looking shapes. These vertical shapes are not single lines. Each one represents a short burst of UART activity where the “Rust” string was transmitted.</p> <img src="/img/2026/01/uart-logic-analyzer-multiple-samples.png" alt="uart sample with logic analyzer" style="width:400px; height:auto; display:block; margin:auto;"/> <p>To see what is actually happening, zoom in horizontally on one of these regions (you can use the mouse scroll wheel while the cursor is over the signal). Once you zoom in far enough , the individual signal transitions become visible. At this level, you can see the structure of each UART transmission, but not the meaning of individual bits. To make sense of the data, we will use the protocol decoder feature.</p> <h2 id="protocol-decoder"><a class="header-anchor no-hover-padding" href="#protocol-decoder" aria-label="Anchor link for: protocol-decoder"><span class="link-icon" aria-hidden="true"></span></a> Protocol Decoder</h2> <p>Looking at the raw UART signal helps confirm that data is being transmitted, but it does not tell us what the data actually is.</p> <p>PulseView provides protocol decoders for many common digital protocols such as UART, I2C, and SPI. These decoders interpret raw signals and display the data in a readable form.</p> <img src="/img/2026/01/logic-analyzer-protocl-decoder.png" alt="pulseview protocol decoder" style="width:400px; height:auto; display:block; margin:auto;"/> <p>To add a protocol decoder, click the small decoder icon next to the “sample rate” selection, as highlighted in the image above. This opens the Decoder selector. In the search box, type <code>UART</code> and double-click the UART decoder. This adds a new UART decoder row to the main window.</p> <p>After adding it, you will see a message saying that no channels are assigned to the decoder. At this point, PulseView knows which protocol to use, but it does not yet know which signal line to decode.</p> <img src="/img/2026/01/uart-pulseview-protocol-decoder.png" alt="pulseview UART decoder" style="width:400px; height:auto; display:block; margin:auto;"/> <p>Click on the UART label on the left side to open the decoder settings. Here, we need to configure the decoder to match our UART setup. Set the baud rate to 115200. The default values for data bits, parity, and stop bits are fine for this example.</p> <img src="/img/2026/01/uart-pulseview-protocol-decoder-options.png" alt="pulseview UART decoder" style="width:400px; height:auto; display:block; margin:auto;"/> <p>By default, the decoded data format is shown in hexadecimal. Since we are transmitting ASCII text, change the data format to ASCII.</p> <p>Finally, assign the signal channel to the decoder. We have connected the UART TX pin to CH1, which corresponds to D0 in PulseView. Select D0 from the dropdown next to the TX option.</p> <p>Once this is done, PulseView will decode the captured UART signal and display the transmitted data.</p> <h2 id="decoded-data"><a class="header-anchor no-hover-padding" href="#decoded-data" aria-label="Anchor link for: decoded-data"><span class="link-icon" aria-hidden="true"></span></a> Decoded Data</h2> <p>PulseView decodes the captured UART signal and displays the data in a readable form. Along with the decoded characters (in ASCII, as we configured), it also shows the individual data bits as 0 and 1.</p> <img src="/img/2026/01/uart-logic-analyzer-decoded-data.png" alt="pulseview UART decoder" style="width:400px; height:auto; display:block; margin:auto;"/> <p>PulseView also highlights the start bit with an “S” label (shown in yellow) and the stop bit with a “T” label.</p>

In this post, we analyze UART signals from an embedded Rust project using a cheap USB logic analyzer and PulseView. We capture UART data, look at the raw signal on the wire, and use protocol decoding to understand how bytes are transmitted.

2026-01-26T00:00:00+00:00 2026-01-26T00:00:00+00:00 implFerris https://blog.implrust.com/posts/2026/01/using-logic-analyzer-embedded-rust-pico-esp32/ <p>I am a hobbyist embedded Rust developer. While researching and learning, I often came across people using oscilloscopes to analyze signals. I might have used one during my college lab days, but honestly, I do not remember much about it anymore. It has been a long time.</p> <p>I was curious to try one again, but I did not want a large oscilloscope sitting on my desk. At least for now, it felt unnecessary. At some point, while looking for simpler ways to inspect digital signals, I came across USB logic analyzers. I do not remember exactly where I first saw one, but it immediately felt like a practical alternative. They are small, inexpensive, and much easier to keep around.</p> <p>There are already plenty of tutorials and videos showing how to use logic analyzers, mostly with Arduino-based examples that you can follow step by step. I decided to write this post for my usual reason: the more I write and explain something, the more I understand it myself. Hopefully, you will find it useful too.</p> <div class="admonition info"> <div class="admonition-icon admonition-icon-info"></div> <div class="admonition-content"> <strong class="admonition-title">INFO</strong> <p>The Rust code is only a small part of this blog post. Most of the content focuses on understanding the logic analyzer, setting up the software, and learning how to capture and analyze digital signals.</p> </div> </div> <h2 id="what-is-a-logic-analyzer"><a class="header-anchor no-hover-padding" href="#what-is-a-logic-analyzer" aria-label="Anchor link for: what-is-a-logic-analyzer"><span class="link-icon" aria-hidden="true"></span></a> What is a Logic Analyzer?</h2> <p>A logic analyzer is a tool used to capture and inspect digital signals. It records whether a signal is in a logical HIGH or LOW state over time and how different signal lines, such as clock and data wires, relate to each other during communication.</p> <p>For embedded development, this is especially useful when working with digital protocols such as I2C, SPI, or UART. Instead of relying on assumptions or print-based debugging, a logic analyzer lets you inspect the actual signal behavior on the wire.</p> <p>Unlike an oscilloscope, which focuses on the exact voltage shape of a signal, a logic analyzer treats signals as digital values. It does not care about the precise voltage level or waveform details, only whether the signal is interpreted as a zero or a one. For most protocol-level debugging, this level of detail is sufficient and much easier to work with.</p> <h2 id="meet-the-hardware-8-channel-usb-logic-analyzer"><a class="header-anchor no-hover-padding" href="#meet-the-hardware-8-channel-usb-logic-analyzer" aria-label="Anchor link for: meet-the-hardware-8-channel-usb-logic-analyzer"><span class="link-icon" aria-hidden="true"></span></a> Meet the Hardware: 8-Channel USB Logic Analyzer</h2> <p>The logic analyzer I am using is a small 8-channel USB logic analyzer with a maximum sampling frequency of 24 MHz. You should be able to find one on online marketplaces for under 400 INR (under $10).</p> <img src="/img/2026/01/8-channel-usb-logic-analyzer.png" alt="8 ch USB Logic Analyzer" style="width:400px; height:auto; display:block; margin:auto;"/> <p>As the name implies, the analyzer allows capturing up to eight digital signals at the same time, which makes it possible to observe how multiple related signals change together.</p> <h2 id="how-a-logic-analyzer-captures-data"><a class="header-anchor no-hover-padding" href="#how-a-logic-analyzer-captures-data" aria-label="Anchor link for: how-a-logic-analyzer-captures-data"><span class="link-icon" aria-hidden="true"></span></a> How a Logic Analyzer Captures Data</h2> <p>A logic analyzer repeatedly checks the state of each connected signal and records whether it is HIGH or LOW. These checks happen at regular intervals, based on the selected sampling rate(will see it later).</p> <p>The logic analyzer itself does not understand protocols or signal meaning. It only records state changes. Interpreting those changes and decoding protocols is done later using software on the computer.</p> <h2 id="channels"><a class="header-anchor no-hover-padding" href="#channels" aria-label="Anchor link for: channels"><span class="link-icon" aria-hidden="true"></span></a> Channels</h2> <p>A logic analyzer has multiple input channels. Each channel is a separate input that can be connected to a signal wire or a microcontroller pin. When the analyzer captures data, it records the state of each channel independently.</p> <p>When connecting the analyzer, each channel should be connected to one signal of interest, such as a data line or a clock line. The exact choice of signals depends on what you are trying to observe. For now, the important point is that each channel corresponds to one physical wire or pin.</p> <h2 id="software-setup"><a class="header-anchor no-hover-padding" href="#software-setup" aria-label="Anchor link for: software-setup"><span class="link-icon" aria-hidden="true"></span></a> Software Setup</h2> <p>I am on Linux, so I will describe the setup steps for Linux here. If you are using a different operating system, you can follow similar steps using the appropriate tools and packages for your OS.</p> <p>There are two commonly mentioned software options when working with USB logic analyzers. Which one makes sense depends on the hardware you are using.</p> <h3 id="option-1-pulseview-sigrok-open-source"><a class="header-anchor no-hover-padding" href="#option-1-pulseview-sigrok-open-source" aria-label="Anchor link for: option-1-pulseview-sigrok-open-source"><span class="link-icon" aria-hidden="true"></span></a> Option 1: PulseView (sigrok, Open Source)</h3> <p>For inexpensive 8-channel USB logic analyzers like the one I am using, the most practical software is PulseView, which is part of the open-source sigrok project. PulseView supports many generic logic analyzers and provides the basic tools needed to view captured signals and decode common digital protocols.</p> <p>On Debian or Ubuntu-based systems, you can install PulseView using the package manager:</p> <pre data-lang="sh" class="language-sh z-code"><code class="language-sh" data-lang="sh"><span class="z-source z-shell z-bash"><span class="z-meta z-function-call z-shell"><span class="z-variable z-function z-shell">sudo</span></span><span class="z-meta z-function-call z-arguments z-shell"> apt install pulseview sigrok</span> </span></code></pre> <p>Official documentation for sigrok and PulseView is available here: <a href="https://sigrok.org/wiki/Main_Page">https://sigrok.org/wiki/Main_Page</a></p> <p>You can also refer to the PulseView user manual for more details: <a href="https://sigrok.org/doc/pulseview/unstable/manual.html">https://sigrok.org/doc/pulseview/unstable/manual.html</a></p> <p>I will be using PulseView throughout this blog post.</p> <h3 id="option-2-saleae-logic-software-proprietary"><a class="header-anchor no-hover-padding" href="#option-2-saleae-logic-software-proprietary" aria-label="Anchor link for: option-2-saleae-logic-software-proprietary"><span class="link-icon" aria-hidden="true"></span></a> Option 2: Saleae Logic Software (Proprietary)</h3> <p>Saleae provides software specifically designed for their logic analyzers, though it may also work with some compatible devices.</p> <p>You can download the Linux AppImage from the Saleae website: <a href="https://www.saleae.com/downloads/">https://www.saleae.com/downloads/</a></p> <p>Make it executable and run:</p> <pre data-lang="sh" class="language-sh z-code"><code class="language-sh" data-lang="sh"><span class="z-source z-shell z-bash"><span class="z-meta z-function-call z-shell"><span class="z-variable z-function z-shell">chmod</span></span><span class="z-meta z-function-call z-arguments z-shell"> +x Logic-<span class="z-keyword z-operator z-regexp z-quantifier z-shell">*</span>.AppImage</span> </span><span class="z-source z-shell z-bash"><span class="z-meta z-function-call z-shell"><span class="z-variable z-function z-shell">./Logic-*.AppImage</span></span> </span></code></pre> <h2 id="toggling-a-gpio-test-signal"><a class="header-anchor no-hover-padding" href="#toggling-a-gpio-test-signal" aria-label="Anchor link for: toggling-a-gpio-test-signal"><span class="link-icon" aria-hidden="true"></span></a> Toggling a GPIO (Test Signal)</h2> <p>Let’s start by generating a very simple test signal by toggling a GPIO pin. This helps confirm that the logic analyzer, software, and wiring are all working correctly before moving on to more complex signals.</p> <p>I will be using a Raspberry Pi Pico here, but any other board will work.</p> <p>We will flash a small program that toggles a GPIO pin between high and low states with a delay of 500 milliseconds.</p> <p>For the HAL, I will be using Embassy. You are free to use any other HAL, such as rp-hal. The choice of HAL does not matter here, as long as you can toggle a GPIO pin at a known interval and observe the change on the logic analyzer.</p> <h3 id="code-snippet"><a class="header-anchor no-hover-padding" href="#code-snippet" aria-label="Anchor link for: code-snippet"><span class="link-icon" aria-hidden="true"></span></a> Code snippet</h3> <pre data-lang="rust" class="language-rust z-code"><code class="language-rust" data-lang="rust"><span class="z-source z-rust"><span class="z-storage z-type z-rust">let</span> p <span class="z-keyword z-operator z-assignment z-rust">=</span> <span class="z-meta z-path z-rust">embassy_rp<span class="z-punctuation z-accessor z-rust">::</span></span>init<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span><span class="z-support z-type z-rust">Default</span><span class="z-meta z-path z-rust"><span class="z-punctuation z-accessor z-rust">::</span></span>default<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span><span class="z-source z-rust"><span class="z-storage z-type z-rust">let</span> <span class="z-storage z-modifier z-rust">mut</span> pin <span class="z-keyword z-operator z-assignment z-rust">=</span> <span class="z-meta z-path z-rust">Output<span class="z-punctuation z-accessor z-rust">::</span></span>new<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span>p<span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-constant z-other z-rust">PIN_15</span><span class="z-punctuation z-separator z-rust">,</span> <span class="z-meta z-path z-rust">Level<span class="z-punctuation z-accessor z-rust">::</span></span>Low</span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span><span class="z-source z-rust"> </span><span class="z-source z-rust"><span class="z-keyword z-control z-rust">loop</span> <span class="z-meta z-block z-rust"><span class="z-punctuation z-section z-block z-begin z-rust">{</span> </span></span><span class="z-source z-rust"><span class="z-meta z-block z-rust"> pin<span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-support z-function z-rust">set_high</span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span></span><span class="z-source z-rust"><span class="z-meta z-block z-rust"> <span class="z-meta z-path z-rust">Timer<span class="z-punctuation z-accessor z-rust">::</span></span>after_millis<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span><span class="z-constant z-numeric z-integer z-decimal z-rust">500</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-accessor z-dot z-rust">.</span>await<span class="z-punctuation z-terminator z-rust">;</span> </span></span><span class="z-source z-rust"><span class="z-meta z-block z-rust"> </span></span><span class="z-source z-rust"><span class="z-meta z-block z-rust"> pin<span class="z-punctuation z-accessor z-dot z-rust">.</span><span class="z-support z-function z-rust">set_low</span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-terminator z-rust">;</span> </span></span><span class="z-source z-rust"><span class="z-meta z-block z-rust"> <span class="z-meta z-path z-rust">Timer<span class="z-punctuation z-accessor z-rust">::</span></span>after_millis<span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-begin z-rust">(</span><span class="z-constant z-numeric z-integer z-decimal z-rust">500</span></span><span class="z-meta z-group z-rust"><span class="z-punctuation z-section z-group z-end z-rust">)</span></span><span class="z-punctuation z-accessor z-dot z-rust">.</span>await<span class="z-punctuation z-terminator z-rust">;</span> </span></span><span class="z-source z-rust"><span class="z-meta z-block z-rust"></span><span class="z-meta z-block z-rust"><span class="z-punctuation z-section z-block z-end z-rust">}</span></span> </span></code></pre> <div class="admonition tip"> <div class="admonition-icon admonition-icon-tip"></div> <div class="admonition-content"> <strong class="admonition-title">TIP</strong> <p>If you are not familiar with creating a project or flashing embedded Rust code onto a board, you may want to go through the basics first. I recommend starting with the <a href="https://pico.implrust.com/">Pico Pico book</a> or the <a href="https://esp32.implrust.com/">impl Rust for ESP32</a> book.</p> </div> </div> <h3 id="connecting-pico-with-logic-analyzer"><a class="header-anchor no-hover-padding" href="#connecting-pico-with-logic-analyzer" aria-label="Anchor link for: connecting-pico-with-logic-analyzer"><span class="link-icon" aria-hidden="true"></span></a> Connecting Pico with Logic Analyzer</h3> <p>First, connect the ground wire of the logic analyzer to one of the ground pins on the Raspberry Pi Pico. The logic analyzer and the Pico must share a common ground for the signals to be interpreted correctly.</p> <p>Next, connect one channel (lets say CH1) of the logic analyzer to GPIO15 on the Pico. For this test, I am using GPIO15, but you can use any other GPIO pin.</p> <table><thead><tr><th>Logic Analyzer</th><th>Raspberry Pi Pico</th></tr></thead><tbody> <tr><td>GND</td><td>GND</td></tr> <tr><td>CH1</td><td>GPIO15</td></tr> </tbody></table> <p>Power the Pico, then connect the logic analyzer to the computer.</p> <h2 id="opening-pulseview-and-detecting-the-logic-analyzer"><a class="header-anchor no-hover-padding" href="#opening-pulseview-and-detecting-the-logic-analyzer" aria-label="Anchor link for: opening-pulseview-and-detecting-the-logic-analyzer"><span class="link-icon" aria-hidden="true"></span></a> Opening PulseView and Detecting the Logic Analyzer</h2> <p>Now lets open PulseView and make sure the logic analyzer is detected correctly.</p> <p>Start PulseView after connecting the logic analyzer to your computer. When PulseView opens, it should automatically try to detect connected devices. If the logic analyzer is detected, you should see it selected as the active device in the toolbar.</p> <img src="/img/2026/01/pulseview-logic-analyzer-detected.png" alt="Pulseview detected the logic analyzer" style="width:400px; height:auto; display:block; margin:auto;"/> <p>If no device is selected, open the device selection menu and choose the generic logic analyzer entry, which usually appears as fx2lafw (generic driver). Once selected, PulseView should show the available channels for that device.</p> <h2 id="configuring-sampling-rate-and-number-of-samples"><a class="header-anchor no-hover-padding" href="#configuring-sampling-rate-and-number-of-samples" aria-label="Anchor link for: configuring-sampling-rate-and-number-of-samples"><span class="link-icon" aria-hidden="true"></span></a> Configuring Sampling Rate and Number of Samples</h2> <p>Once the logic analyzer is detected in PulseView, the next step is to configure how data will be captured. Two important settings here are the “sample rate” and the “number of samples to capture”.</p> <p>To understand these settings, it helps to know what a sample actually is.</p> <p>A sample is a single recorded value of the signal. At that moment, the logic analyzer simply reads the wire and records whether the signal is HIGH or LOW. Each recorded HIGH or LOW value is one sample.</p> <img src="/img/2026/01/number-of-samples-sampel-rate-logic-analyzer-pulseview.png" alt="Number of Samples - Sample Rate" style="width:400px; height:auto; display:block; margin:auto;"/> <h3 id="number-of-samples"><a class="header-anchor no-hover-padding" href="#number-of-samples" aria-label="Anchor link for: number-of-samples"><span class="link-icon" aria-hidden="true"></span></a> Number of Samples</h3> <p>The number of samples tells the logic analyzer how many samples to record in total before stopping.</p> <p>For example, if you set this to 100k, the logic analyzer will record 100,000 values (each value being either HIGH or LOW) and then stop automatically. Increasing this value makes the recording last longer. Decreasing it makes the recording shorter.</p> <h3 id="sample-rate"><a class="header-anchor no-hover-padding" href="#sample-rate" aria-label="Anchor link for: sample-rate"><span class="link-icon" aria-hidden="true"></span></a> Sample Rate</h3> <p>The sample rate tells the logic analyzer how many samples to take every second.</p> <p>For example, a sample rate of 20 kHz means the logic analyzer records 20,000 samples every second. That means it reads the signal 20,000 times per second and saves each result.</p> <p>A higher sample rate means the signal is read and recorded more frequently. This is important when the signal changes quickly. A lower sample rate means the signal is read less often, which is usually fine for slow signals.</p> <div class="admonition tip"> <div class="admonition-icon admonition-icon-tip"></div> <div class="admonition-content"> <strong class="admonition-title">TIP</strong> <p><strong>From the Manual:</strong> The sample rate you choose must at least be twice that of the highest frequency you want to capture - ideally 3 to 5 times as much so that you have some margin. That way, a jittering signal won’t ruin your measurements.</p> </div> </div> <h3 id="how-they-work-together"><a class="header-anchor no-hover-padding" href="#how-they-work-together" aria-label="Anchor link for: how-they-work-together"><span class="link-icon" aria-hidden="true"></span></a> How They Work Together</h3> <p>These two settings answer two different questions:</p> <ul> <li>“The sample rate” answers how fast samples are taken</li> <li>“The number of samples” answers how many samples are taken</li> </ul> <p>Together, they decide how long the signal is recorded.</p> <p>PulseView shows this relationship using the capture duration:</p> <pre data-lang="sh" class="language-sh z-code"><code class="language-sh" data-lang="sh"><span class="z-source z-shell z-bash"><span class="z-meta z-function-call z-shell"><span class="z-variable z-function z-shell">capture</span></span><span class="z-meta z-function-call z-arguments z-shell"> duration = number of samples / sample rate</span> </span></code></pre> <p>Suppose you set the sample rate to 20 kHz and the number of samples to 100k. At a 20 kHz sample rate, the logic analyzer records 20,000 samples every second. With 100,000 samples in total, the recording will last for about 5 seconds before stopping.</p> <pre data-lang="sh" class="language-sh z-code"><code class="language-sh" data-lang="sh"><span class="z-source z-shell z-bash"><span class="z-meta z-function-call z-shell"><span class="z-variable z-function z-shell">capture</span></span><span class="z-meta z-function-call z-arguments z-shell"> duration = 100,000 / 20,000 = 5 seconds</span> </span></code></pre> <p>We will use this setting only for our test. It is sufficient here because we are just toggling the GPIO every 500 milliseconds.</p> <h2 id="starting-the-capture-and-verifying-the-signal"><a class="header-anchor no-hover-padding" href="#starting-the-capture-and-verifying-the-signal" aria-label="Anchor link for: starting-the-capture-and-verifying-the-signal"><span class="link-icon" aria-hidden="true"></span></a> Starting the Capture and Verifying the Signal</h2> <p>With the logic analyzer connected and the capture settings configured, we can now start the capture.</p> <p>In PulseView, click Run in the top bar (next to the Session label). The logic analyzer will begin recording samples and will automatically stop once it reaches the configured number of samples.</p> <img src="/img/2026/01/logic-analyzer-signal-captured.png" alt="Logic Analyzer Signal Captured" style="width:400px; height:auto; display:block; margin:auto;"/> <p>After the capture stops, you should see a waveform on the enabled channel. In our program, the GPIO state is toggled every 500 milliseconds. As shown in the capture, the signal stays HIGH for 500 ms, then LOW for 500 ms, repeating this pattern consistently.</p> <p>Since the total capture duration is 5 seconds, this results in 5 HIGH periods and 5 LOW periods across the entire waveform.</p> <p>Even though the waveform shows only a few visible transitions, the logic analyzer actually recorded all 100,000 samples. Each HIGH or LOW section in the waveform represents many individual samples taken during that time. PulseView automatically zooms out to show the overall shape of the signal rather than displaying every sample at once.</p> <p>If you zoom in horizontally, you will see that each flat HIGH or LOW region is made up of many samples. This confirms that the GPIO toggling, sampling configuration, and capture duration are all working together as expected.</p> <h2 id="what-s-next"><a class="header-anchor no-hover-padding" href="#what-s-next" aria-label="Anchor link for: what-s-next"><span class="link-icon" aria-hidden="true"></span></a> What’s Next</h2> <p>In this post, we focused on getting familiar with the logic analyzer and basic signal capture. I am planning to write a follow-up post focused on analyzing I2C signals, and later cover other protocols as well.</p>

In this post, we take a practical look at using a logic analyzer when working on embedded Rust projects. We cover what a logic analyzer does, how to interpret captured signals, and how it can be used to debug common protocols like I2C, SPI, and UART.