> ## Documentation Index
> Fetch the complete documentation index at: https://docs.embedder.com/llms.txt
> Use this file to discover all available pages before exploring further.

# PicoScope

> Capture analog waveforms and MSO digital signals, and drive the signal generator, on a supported USB PicoScope.

Use a PicoScope for an analog capture, an MSO digital capture, or a stimulus-and-response test from one USB device. Analog results appear in the Monitor's **Oscilloscope** tab, and MSO results appear in **Logic**. Available inputs, triggers, and generator functions depend on the model and its Pico driver.

Start analog PicoScope captures by asking Embedder or from a [hardware script](https://docs.embedder.com/debug-mode/hardware-scripts.md). MSO digital captures can also start from the Monitor; see [Capture from the Monitor](#capture-from-the-monitor). The **Oscilloscope** tab shows analog results, but its **Auto**, **Single**, and **Run** controls work only with [LAN bench scopes](https://docs.embedder.com/debug-mode/scpi-oscilloscopes.md).

## Prepare

1. Install Pico Technology's drivers: PicoScope 7 or the PicoSDK from [Pico's downloads page](https://www.picotech.com/downloads). On Linux, install the `libps*` driver packages from Pico's package repository. Embedder sets up Pico's Python package for you, but not the drivers.
2. Connect the PicoScope over USB.
3. Quit the PicoScope app and other Pico software. The device accepts one application at a time.
4. Ask Embedder to check the PicoScope, and approve the setup prompts: **Install Python 3?** if Python is missing, **Create Embedder Python environment?**, and **Install picosdk?**.

In Debug mode, when a PicoScope is connected and isn't set up yet, Embedder asks about **PicoScope support** before it sends your message. Choose **Install PicoScope support now** to run the same setup, or **Continue without PicoScope**.

If the drivers are missing, Embedder reports that it can't find the PicoScope driver libraries. Install them, then ask again.

Embedder detects the driver family when it connects. Give Embedder more detail in these cases:

* **Legacy model not found:** Embedder recognizes most `ps2000` and `ps3000` scopes by their USB ID. If it doesn't find one, tell Embedder the driver family.
* **Several scopes connected:** give the serial number of the one to use.
* **Flexible-resolution model:** ask for the resolution you need, from 8 to 16 bits.

PicoScope support, including advanced triggering, is verified on hardware with the PicoScope 2205A MSO. The first time you use another family, check a capture against a known signal.

## Capture analog inputs

Channel 1 is input A, channel 2 is input B, and so on.

```text theme={"theme":"css-variables"}
Capture input A with DC coupling at 1 V/div and 1 ms/div. Trigger when A rises
through 1.5 V and open the waveform in the Oscilloscope tab.
```

Set the probe attenuation to match the probe's switch. PicoScope drivers have no probe setting, so with a ×10 probe, state the factor explicitly. Embedder then treats scale, offset, and trigger levels as volts at the probe tip.

The vertical window is four divisions above and below center (±4 × V/div). Embedder rounds a requested scale up to the next input range, so leave enough headroom to avoid clipping. Coupling is DC or AC; PicoScope inputs have no ground coupling. A horizontal delay setting is ignored.

Check the achieved sample rate, voltage range, and duration in the result. They can differ from what you asked for.

For a sequence that must arm before another operation, ask Embedder to arm one acquisition, perform the operation, then wait for the trigger and read that acquisition. In a hardware script, use `scope_arm_single()`, `scope_wait_trigger()`, and `scope_capture_waveform(arm=False)` for this sequence.

## Choose a trigger

Give the source, voltage levels, edge or condition, and time bounds. Levels are probe-tip volts, so set the channel first.

| Mode | Fires when | In a script, call `scope_set_trigger()` with |
| - | - | - |
| Edge | A channel crosses a level, rising or falling. | `mode="edge"` (the default) and `edge="rising"` or `"falling"` |
| Level | A channel goes above or below a level. | `mode="edge"` and `edge="above"` or `"below"`. There is no `level` mode. |
| Window | The signal enters or exits a voltage band. | `mode="window"`, `level`, `level2`, and `edge="enter"` or `"exit"` |
| Pulse width | A pulse is shorter or longer than a width, or inside or outside a width range. | `mode="pulse_width"`, `width_s`, and `width_condition` |
| Runt | A pulse clears one level but never reaches the second. | `mode="runt"`, `level`, and `level2` |
| Dropout | The signal stops toggling for longer than a set time. | `mode="dropout"` and `width_s` |
| Interval | The time between successive edges leaves a window. | `mode="interval"`, `width_s`, and `width_condition` |
| Logic | Conditions on several analog channels combine with AND or OR. | `mode="logic"`, `conditions`, and `combine` |
| Digital | An MSO pattern matches, optionally combined with an analog condition. | `mode="digital"` and `pattern` |

```text theme={"theme":"css-variables"}
Capture input A when a positive pulse above 1.5 V is shorter than 200 ns.
Wait at most ten seconds and report the applied trigger and achieved sample rate.
```

The same trigger in a [hardware script](https://docs.embedder.com/debug-mode/hardware-scripts.md):

```python theme={"theme":"css-variables"}
scope_set_trigger(source="C1", mode="pulse_width", level=1.5, edge="rising",
                  width_condition="less_than", width_s=200e-9)
```

A PicoScope takes the trigger type in `mode`. [Siglent scopes](https://docs.embedder.com/debug-mode/siglent.md#choose-a-trigger) take it in `type`, so a trigger call written for one doesn't run on the other.

Every mode also accepts these options:

* **Hysteresis**, as a percentage of full scale, to steady a noisy threshold.
* **Delay** to start the capture a set time after the trigger.
* **Auto timeout** to capture anyway if the trigger never fires.
* **External source** (`EXT`, fixed ±5 V range) on models with an external trigger input. On models with an `AUX` input, use it as a condition in a logic trigger; it takes no level.

PicoScope drivers have no holdoff. Use a delay or an interval trigger instead.

A trigger fires on the transition into its condition, not while the condition is already true. A line that already sits above the level waits for the next crossing, so a quiet input never triggers without an auto timeout.

Widths and delays are counted in sample periods. A width shorter than one sample period is rounded up to one sample. To catch a narrow glitch, raise the sample rate by shortening the time per division.

Ask Embedder to read back the trigger if it's rejected or doesn't fire. The readback shows the resolved levels and timing the driver received. In a script, `scope_get_trigger()` returns it.

## Use MSO inputs

An MSO model needs its digital pod connected.

```text theme={"theme":"css-variables"}
Capture D0, D1, and D2 for 5 ms at 5 MS/s with a 1.65 V threshold. Trigger on
D0 rising while D1 is high and show raw transitions in Logic.
```

Digital inputs are grouped in eight-channel ports (D0–D7 and D8–D15), and the threshold applies per port. Without a threshold in your request, Embedder uses 1.8 V. Unconnected inputs idle high and can affect pattern triggers, so include only the lines you've connected.

PicoScope digital captures run for a fixed duration. They don't support manual (open-ended) capture or built-in protocol decoding. Use [Saleae](https://docs.embedder.com/debug-mode/saleae.md) or [Digilent](https://docs.embedder.com/debug-mode/digilent.md) when you need decoding. To export a capture, ask for raw digital CSV; saving a Saleae `.sal` file isn't available.

### Capture from the Monitor

You can also capture MSO inputs from the Monitor's **Logic** tab without asking Embedder.

1. In the Monitor, select **+**, then select the PicoScope MSO under **On the bench**. Or open **Logic Analyzer** under **Views** and choose it from the device chip.
2. If the toolbar shows **Set up & connect** or **Connect**, select it. Selecting **Set up & connect** approves setup.
3. Select the **Logic setup** chip, the settings summary next to the device chip, to open the **Logic analyzer setup** panel.
4. Under **Channels**, choose the digital channels. Under **Acquisition**, set the **Sample rate**, the **Duration** (up to 60 seconds), and the **Threshold**, from -5 to 5 V. A Monitor capture that doesn't fit the capture buffer is refused, not shortened. If the tab reports that the capture exceeds the analyzer's buffer, lower the sample rate or the duration.
5. Under **Trigger**, keep **Immediate**, or choose **Edge** and set the **Channel** and **Edge**. With an edge trigger, **Duration** becomes **After trigger**, the time captured after the edge.
6. Select **Single** to capture once, or **Run** to capture repeatedly until you select **Stop**.

Each capture's raw transitions open in the waveform view and in **Capture history**. To zoom, pan, or jump to a sample range, see [Navigate the waveform](https://docs.embedder.com/debug-mode/logic-analyzer.md#navigate-the-waveform). For pattern triggers or analog triggers, ask Embedder.

**Disconnect**, **Rename device**, and **Rescan devices** are in the **⋯** (**Device actions**) menu, with **Forget device** for a saved PicoScope that isn't currently detected.

## Generate a waveform

On a model with a generator, specify the waveform, frequency, amplitude, offset, and output limits. Supported waveforms are sine, square, triangle, ramp up, ramp down, and DC. Output limits vary by model and the driver rejects out-of-range settings.

```text theme={"theme":"css-variables"}
Use the PicoScope generator for a 1 kHz sine wave, 1 V peak-to-peak, with
zero offset. Capture the connected circuit's response on A for 10 ms, then
return the generator to 0 V, including if acquisition fails.
```

In a hardware script, `la_wavegen_setup()` configures the generator, `la_wavegen_start()` starts it, and `la_wavegen_stop()` returns it to 0 V. Its `amplitude` argument is peak volts: use `0.5` for 1 V peak-to-peak. PicoScopes have one generator output. Square-wave duty cycles other than 50% and phase settings are ignored.

`la_wavegen_setup()` doesn't accept arbitrary samples. For a device-specific arbitrary waveform or another driver function beyond these helpers, ask Embedder to prepare a script that uses `pico_sdk()` and the installed driver's programmer guide. Review the exact model's buffer, timing, and output limits before you run it.

PicoScope doesn't accept SCPI commands and has no screenshot function.

## Save and inspect

Ask Embedder to show the analog waveform in **Oscilloscope** or the MSO transitions in **Logic**, and to save the raw CSV you need for comparison. Keep channel names, probe factors, trigger settings, and the achieved sample rate with the result.

A capture you stop before it completes has no partial data to export. Start a new capture instead.

## Fit the capture to the device

Enabled channels and digital ports share one capture buffer. On a 2205A MSO, the buffer holds 48 kS, so a 1 MS/s digital capture lasts about 48 ms. Embedder shortens a request that doesn't fit instead of failing, so a recording can cover less time than you asked for.

To record a longer window, disable unused channels, lower the sample rate, or shorten the required window. Headline sample rates apply to a single channel; more channels lower the fastest rate. Verify the actual result before you compare runs.

Some driver families have fixed limits:

| Driver family | Limits |
| - | - |
| `ps2000`, `ps3000` | Found by USB ID only; give the driver family if Embedder doesn't find the scope. Can't select a scope by serial number. No auxiliary input or digital triggering. `ps3000` has no generator. |
| `ps4000`, `ps5000`, `ps6000` | No MSO digital inputs. |
| `ps3000`, `ps4000`, `ps5000`, `ps6000` on Apple silicon Macs | The drivers are Intel-only. Use an Intel Mac, Windows, or Linux. |

## Troubleshoot

* **Device missing:** check the USB cable and connection, the driver installation, and other Pico software that may hold the device.
* **Driver libraries not found:** install PicoScope 7 or the PicoSDK, then ask Embedder to check again.
* **Clipping:** increase the range or adjust the offset.
* **Amplitude off by a factor of ten:** check the physical probe switch and the configured attenuation.
* **Trigger never fires:** check the input, threshold, sample rate, and enabled channels. Remember that the trigger waits for a transition into its condition.
* **Narrow window trigger refused:** widen the window or lower the hysteresis.
* **Recording shorter than requested:** the capture buffer is full. See [Fit the capture to the device](#fit-the-capture-to-the-device).
* **Legacy driver fails:** confirm that the driver supports the host operating system and architecture.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.