Your first capture

Connect, open a demo device, capture, count the edges, close. No hardware needed: the program runs against se254, a demo device every server offers.

Make sure a server is running first: either the ScanaStudio application, or the scanastudio-server binary it installs, run on its own. Both are covered under Installation.

Python

from ikalogic_scanastudio import ScanaStudio, Trigger

with ScanaStudio.connect() as server:
    print(server.info)

    for device in server.devices():
        print(" ", device)

    workspace = server.create("se254")
    print(f"\nopened {workspace.device_name} "
          f"with {len(workspace.channels)} channels")

    last = workspace.capture.run(
        samples=1_000_000,
        sample_rate=25_000_000,
        trigger=Trigger.immediate(),
    )
    seconds = workspace.capture.seconds(last)
    print(f"captured {last} samples ({seconds:.3f} s) "
          f"at {workspace.capture.sample_rate} S/s")

    edges = sum(1 for _ in workspace.data.transitions(channel=0))
    print(f"channel 0 holds {edges} transitions")

    workspace.close()

Run it:

python first_capture.py

NodeJS

import { ScanaStudio, Trigger } from '@ikalogic/scanastudio';

const server = await ScanaStudio.connect();
try {
  console.log(server.info);

  for (const device of await server.devices()) {
    console.log(' ', device.key, device.name, device.demo ? '(demo)' : '');
  }

  const workspace = await server.create('se254');
  console.log(`opened ${workspace.device_name} `
    + `with ${workspace.channels.length} channels`);

  const last = await workspace.capture.run({
    samples: 1_000_000,
    sample_rate: 25_000_000,
    trigger: Trigger.immediate(),
  });
  console.log(`captured ${last} samples `
    + `(${workspace.capture.seconds(last).toFixed(3)} s) `
    + `at ${workspace.capture.sample_rate} S/s`);

  let edges = 0;
  for await (const _ of workspace.data.transitions(0)) edges += 1;
  console.log(`channel 0 holds ${edges} transitions`);

  workspace.close();
} finally {
  server.close();
}

Run it:

node first-capture.mjs

Rust

use std::time::Duration;

use scanastudio_client::{CaptureRequest, ScanaStudio, DEFAULT_URL, Result};

#[tokio::main]
async fn main() -> Result<()> {
    let server = ScanaStudio::connect(DEFAULT_URL).await?;
    println!("{:?}", server.info());

    for device in server.devices().await? {
        println!("  {} {}", device.key, device.name);
    }

    let workspace = server.create("se254").await?;
    println!("opened {} with {} channels",
             workspace.device_name(), workspace.channels().len());

    let last = workspace.capture()
        .run(&CaptureRequest::new(1_000_000, 25_000_000), Duration::from_secs(300))
        .await?;
    println!("captured {last} samples ({:.3} s) at {} S/s",
             workspace.capture().seconds(last), workspace.capture().sample_rate());

    let edges = workspace.data().transitions(0, 0, None).await?;
    println!("channel 0 holds {} transitions", edges.len());

    workspace.close()?;
    Ok(())
}

Run it:

cargo run

C

#include <stdio.h>
#include <stdlib.h>

#include "scanastudio.h"

static void fail(const char *what) {
    const char *reason = ss_last_error();
    fprintf(stderr, "%s: %s\n", what, reason ? reason : "no reason given");
    exit(1);
}

int main(void) {
    ss_server *server = ss_server_connect(NULL);
    if (!server) fail("connect");

    char *info = ss_server_info(server);
    if (info) { printf("%s\n", info); ss_string_free(info); }

    char *devices = ss_server_devices(server);
    if (devices) { printf("%s\n", devices); ss_string_free(devices); }

    ss_workspace *workspace = ss_server_create(server, "se254");
    if (!workspace) fail("open");

    const char *request = "{\"samples\": 1000000, \"sample_rate\": 25000000}";
    if (ss_capture_run(workspace, request, 300.0) < 0) fail("capture");
    printf("captured %lld samples at %llu S/s\n",
           (long long)ss_capture_last_sample(workspace),
           (unsigned long long)ss_capture_sample_rate(workspace));

    enum { ROOM = 4096 };
    ss_edge *edges = malloc(sizeof(ss_edge) * ROOM);
    if (!edges) return 1;
    ptrdiff_t written = ss_data_transitions(workspace, 0, 0, -1, edges, ROOM);
    if (written < 0) fail("transitions");
    printf("channel 0 holds %ld transitions (up to %d)\n", (long)written, ROOM);
    free(edges);

    ss_workspace_close(workspace);
    ss_workspace_free(workspace);
    ss_server_disconnect(server);
    return 0;
}

Build and run:

cc -I/opt/scanastudio-sdk/include first_capture.c \
   -L/opt/scanastudio-sdk/lib -lscanastudio -o first_capture
./first_capture

Adjust the two paths to wherever you unpacked libscanastudio and scanastudio.h. See Installation.

What it prints

On the se254 demo device:

ScanaStudio 6.0.13 (1a909ee), protocol 8
  se254 — SE254 (demo) (demo)
  sp209 — SP209 (demo) (demo)
  sp209i — SP209I (demo) (demo)
  sp259 — SP259 (demo) (demo)
  sp259i — SP259I (demo) (demo)
  sp1018 — SP1018 (demo) (demo)
  sp1036 — SP1036 (demo) (demo)
  sp1054 — SP1054 (demo) (demo)

opened SE254 (demo) with 4 channels
captured 1000000 samples (0.040 s) at 25000000 S/s
channel 0 holds 191 transitions

The transition count changes on every run, since a demo device generates a new pseudo-random signal each time.

What just happened

1. connect() connected to the server at ws://127.0.0.1:4911 and checked that both sides speak the same protocol version.
2. devices() listed what the server can open: your hardware, plus the demo devices.
3. create("se254") created a workspace: a session that owns the device, the capture, and everything attached to it.
4. capture.run() armed the acquisition and waited for it. It returns the index of the last sample captured.
5. transitions(0) read the edges on channel 0. Bulk data is only transferred when you read it.
6. close() ended the workspace on the server.

A demo device generates noise

se254 produces pseudo-random signals, not protocol traffic. It exercises the whole path (capture, decode, measure, export), which makes it useful for writing and testing a script, but it will not show you a real I²C address.

Closing the connection is not closing the workspace

workspace.close() ends the session on the server. Disconnecting does not: the capture keeps running and you can attach to it later. See Headless datalogger.

Next

• Core concepts: the ideas behind what you just ran.
• Decode a bus and export it: the same program, with a protocol decoder and a CSV at the end.
• API reference: every call, in four languages.