Foxglove

https://docs.foxglove.dev/docs
Admin
Foxglove is a platform for recording, uploading, organizing, and visualizing multimodal log data...
Tokens:173,093
Snippets:2,214
Trust Score:9.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### C++ Foxglove SDK Quickstart Example

Source: https://docs.foxglove.dev/docs/sdk/example?lang=cpp

This example demonstrates initializing the Foxglove C++ SDK, setting up an MCAP writer and a WebSocket server, and logging data to custom JSON and SceneUpdate channels. It includes signal handling for graceful shutdown. Use this to get started with real-time data streaming and recording.

```cpp
#include <foxglove/foxglove.hpp>
#include <foxglove/context.hpp>
#include <foxglove/error.hpp>
#include <foxglove/mcap.hpp>
#include <foxglove/server.hpp>
#include <foxglove/channel.hpp>
#include <foxglove/messages.hpp>

#include <atomic>
#include <chrono>
#include <cmath>
#include <thread>
#include <iostream>
#include <csignal>
#include <functional>

using namespace std::chrono_literals;

int main(int argc, const char *argv[])
{
  foxglove::setLogLevel(foxglove::LogLevel::Debug);

  static std::function<void()> sigint_handler;

  std::signal(SIGINT, [](int) {
    if (sigint_handler) {
      sigint_handler();
    }
  });

  foxglove::McapWriterOptions mcap_options = {};
  mcap_options.path = "quickstart-cpp.mcap";
  auto writer_result = foxglove::McapWriter::create(mcap_options);
  if (!writer_result.has_value())
  {
    std::cerr << "Failed to create writer: " << foxglove::strerror(writer_result.error()) << '\n';
    return 1;
  }
  auto writer = std::move(writer_result.value());

  // Start a server to communicate with the Foxglove app.
  foxglove::WebSocketServerOptions ws_options;
  ws_options.host = "127.0.0.1";
  ws_options.port = 8765;
  auto server_result = foxglove::WebSocketServer::create(std::move(ws_options));
  if (!server_result.has_value())
  {
    std::cerr << "Failed to create server: " << foxglove::strerror(server_result.error()) << '\n';
    return 1;
  }
  auto server = std::move(server_result.value());
  std::cerr << "Server listening on port " << server.port() << '\n';

  // Create a schema for a JSON channel for logging {size: number}
  foxglove::Schema schema;
  schema.encoding = "jsonschema";
  std::string schema_data = R"({  
        "type": "object",  
        "properties": {  
        "size": { "type": "number" }  
        }
    })";
  schema.data = reinterpret_cast<const std::byte *>(schema_data.data());
  schema.data_len = schema_data.size();
  auto channel_result = foxglove::RawChannel::create("/size", "json", std::move(schema));
  if (!channel_result.has_value())
  {
    std::cerr << "Failed to create channel: " << foxglove::strerror(channel_result.error()) << '\n';
    return 1;
  }
  auto size_channel = std::move(channel_result.value());

  // Create a SceneUpdateChannel for logging changes to a 3d scene
  auto scene_channel_result = foxglove::messages::SceneUpdateChannel::create("/scene");
  if (!scene_channel_result.has_value())
  {
    std::cerr << "Failed to create scene channel: " << foxglove::strerror(scene_channel_result.error()) << '\n';
    return 1;
  }
  auto scene_channel = std::move(scene_channel_result.value());

  std::atomic_bool done = false;
  sigint_handler = [&]
  {
    done = true;
  };

  while (!done)
  {
    auto sec_since_epoch = std::chrono::duration_cast<std::chrono::duration<double>>(
        std::chrono::system_clock::now().time_since_epoch()).count();
    double size = abs(sin(sec_since_epoch)) + 1.0;
    std::string msg = "{\"size\": " + std::to_string(size) + "}";
    size_channel.log(reinterpret_cast<const std::byte *>(msg.data()), msg.size());

    foxglove::messages::CubePrimitive cube;
    cube.size = foxglove::messages::Vector3{size, size, size};
    cube.color = foxglove::messages::Color{1, 0, 0, 1};

    foxglove::messages::SceneEntity entity;
    entity.id = "box";
    entity.cubes.push_back(cube);

    foxglove::messages::SceneUpdate scene_update;
    scene_update.entities.push_back(entity);

    scene_channel.log(scene_update);

    std::this_thread::sleep_for(33ms);
  }

  return 0;
}

```

--------------------------------

### Advertise Server Capabilities (Python)

Source: https://docs.foxglove.dev/docs/sdk/websocket-server

Start a WebSocket server and advertise capabilities such as Time and ClientPublish. The `foxglove` library must be installed.

```python
from foxglove import start_server  
from foxglove.websocket import Capability  
  
server = start_server(capabilities=[Capability.Time, Capability.ClientPublish])  

```

--------------------------------

### Build and Run C++ Example

Source: https://docs.foxglove.dev/docs/getting-started/cpp

Instructions for building the C++ example using CMake and running the compiled program.

```bash
cd build
cmake ..
cmake --build .
./my_program

```

--------------------------------

### C++: Live Visualization and MCAP Logging

Source: https://docs.foxglove.dev/docs/sdk/example?lang=cpp

This C++ example initializes an MCAP writer and starts a WebSocket server for live visualization in the Foxglove application. Error handling is included for server and writer creation.

```cpp
#include <foxglove/foxglove.hpp>
#include <foxglove/context.hpp>
#include <foxglove/error.hpp>
#include <foxglove/mcap.hpp>
#include <foxglove/server.hpp>
  
#include <iostream>
  
int main(int argc, const char* argv[]) {
  foxglove::setLogLevel(foxglove::LogLevel::Debug);
  
  foxglove::McapWriterOptions mcap_options = {};
  mcap_options.path = "quickstart-cpp.mcap";
  auto writer_result = foxglove::McapWriter::create(mcap_options);
  if (!writer_result.has_value()) {
    std::cerr << "Failed to create writer: " << foxglove::strerror(writer_result.error()) << '\n';
    return 1;
  }
  auto writer = std::move(writer_result.value());
  
  // Start a server to communicate with the Foxglove app.
  foxglove::WebSocketServerOptions ws_options;
  ws_options.host = "127.0.0.1";
  ws_options.port = 8765;
  auto server_result = foxglove::WebSocketServer::create(std::move(ws_options));
  if (!server_result.has_value()) {
    std::cerr << "Failed to create server: " << foxglove::strerror(server_result.error()) << '\n';
    return 1;
  }
  auto server = std::move(server_result.value());
  std::cerr << "Server listening on port " << server.port() << '\n';
  
  return 0;
}


```

--------------------------------

### Install Python SDK Dependencies

Source: https://docs.foxglove.dev/docs/getting-started/hardware/rgb-camera

Installs the necessary Python dependencies for the Foxglove SDK RGB camera example using Poetry or pip. Ensure you have Poetry or pip installed.

```bash
poetry install
```

```bash
pip install foxglove-sdk>=0.9.0 opencv-python>=4.5.0 numpy>=1.20.0
```

--------------------------------

### Start Minikube

Source: https://docs.foxglove.dev/docs/visualization/connecting/cloud-data/remote-data-loader/development-guide

Starts a local Kubernetes cluster using Minikube. This is the first step in setting up the local development environment.

```bash
minikube start  

```

--------------------------------

### Install Extensions

Source: https://docs.foxglove.dev/docs/embed/typescript-sdk

Manually install Foxglove extensions for a self-hosted setup.

```APIDOC
## Install Foxglove Extensions

### Description
Manually install Foxglove extensions for a fully self-hosted setup. Like the Foxglove app, the Foxglove embedded viewer will automatically install all your organization's published extensions. This method is for custom installations.

### Method
`installExtensions(extensions: Extension[])`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **extensions** (Extension[]) - Required - An array of extension objects to install.

### Request Example
```typescript
// Assuming 'extensions' is an array of Extension objects
viewer.installExtensions(extensions);
```

### Response
None
```

--------------------------------

### Manifest Endpoint Request Example

Source: https://docs.foxglove.dev/docs/visualization/connecting/cloud-data/remote-data-loader

Example GET request to a manifest endpoint, including user-defined query arguments.

```http
GET /manifest?recording=first-recording  

```

--------------------------------

### Run ZED SDK installer for Ubuntu

Source: https://docs.foxglove.dev/docs/getting-started/hardware/stereolabs-depth-cameras

Make the ZED SDK installer executable and run it on Ubuntu. Replace XX, YY.Y, and Z.Z.Z with your specific version numbers.

```bash
chmod +x ZED_SDK_UbuntuXX_cudaYY.Y_vZ.Z.Z.zstd.run  
./ZED_SDK_UbuntuXX_cudaYY.Y_vZ.Z.Z.zstd.run  
```

--------------------------------

### Start WebSocket Server (Python)

Source: https://docs.foxglove.dev/docs/sdk/websocket-server?lang=cpp

Starts a WebSocket server with default options. This is a synchronous call.

```python
import foxglove  
server = foxglove.start_server()  
```

--------------------------------

### Navigate to SO-100 Example Directory

Source: https://docs.foxglove.dev/docs/getting-started/robots/so-100

Ensures the user is in the correct directory within the LeRobot environment to run the SO-100 visualization examples.

```bash
conda activate lerobot # Ensure you're still in the lerobot environment
cd foxglove-sdk/python/foxglove-sdk-examples/so100-visualization
```

--------------------------------

### Install LeRobot and System Dependencies

Source: https://docs.foxglove.dev/docs/getting-started/robots/so-100

Installs necessary system packages, clones the LeRobot repository, sets up a conda environment, and installs LeRobot with SO-100 support.

```bash
sudo apt-get install cmake build-essential python-dev pkg-config \
    libavformat-dev libavcodec-dev libavdevice-dev libavutil-dev \
    libswscale-dev libswresample-dev libavfilter-dev 

git clone https://github.com/huggingface/lerobot.git
cd lerobot

conda create -y -n lerobot python=3.10
conda activate lerobot
conda install ffmpeg -c conda-forge

pip install -e ".[feetech]"
```

--------------------------------

### Install foxglove-sdk with pip

Source: https://docs.foxglove.dev/docs/getting-started/python

Install the foxglove-sdk package from PyPI using pip.

```bash
pip install foxglove-sdk  
```

--------------------------------

### Start Gateway with Capabilities (Rust)

Source: https://docs.foxglove.dev/docs/sdk/remote-access-gateway

Construct and start a remote access gateway in Rust, advertising the `ClientPublish` capability and supporting JSON encoding.

```rust
use foxglove::remote_access::{Capability, Gateway};  
  
let handle = Gateway::new()  
    .capabilities([Capability::ClientPublish])  
    .supported_encodings(["json"])  
    .start()  
    .expect("Failed to start remote access gateway");  

```

--------------------------------

### Start WebSocket Server (Rust)

Source: https://docs.foxglove.dev/docs/sdk/websocket-server?lang=cpp

Starts a WebSocket server with default options. Use `.start_blocking()` for synchronous contexts. For async contexts, use `.start().await`.

```rust
let server = foxglove::WebSocketServer::new()  
    .start_blocking()  
    .expect("Server failed to start");  
```

--------------------------------

### Build C++ Example with OpenCV

Source: https://docs.foxglove.dev/docs/getting-started/hardware/rgb-camera

Builds the C++ example for RGB camera visualization, enabling OpenCV support. This command is run from the cpp directory of the Foxglove SDK.

```bash
make BUILD_OPENCV_EXAMPLE=ON build
```

--------------------------------

### Start Gateway with Capabilities (Python)

Source: https://docs.foxglove.dev/docs/sdk/remote-access-gateway

Initialize and start the Foxglove gateway in Python, specifying `ClientPublish` capability and JSON encoding support.

```python
import foxglove  
from foxglove.remote_access import Capability  
  
gateway = foxglove.start_gateway(  
    capabilities=[Capability.ClientPublish],  
    supported_encodings=["json"],  
)  

```

--------------------------------

### Install Foxglove-SDK

Source: https://docs.foxglove.dev/docs/getting-started/frameworks/lerobot

Installs the Foxglove-SDK for streaming data to Foxglove. Ensure the 'lerobot' conda environment is active.

```bash
pip install foxglove-sdk  

```

--------------------------------

### Run ZED SDK installer for NVIDIA Jetson

Source: https://docs.foxglove.dev/docs/getting-started/hardware/stereolabs-depth-cameras

Make the ZED SDK installer executable and run it on NVIDIA Jetson. Replace XX.X and Y.Y.Y with your specific version numbers.

```bash
chmod +x ZED_SDK_Tegra_L4TXX.X_vY.Y.Y.zstd.run  
./ZED_SDK_Tegra_L4TXX.X_vY.Y.Y.zstd.run  
```

--------------------------------

### Install Dependencies and Package Extension

Source: https://docs.foxglove.dev/docs/extensions/guides/create-data-loader

Install project dependencies and build the Foxglove extension using npm. This command generates a .foxe file ready for installation.

```bash
npm install # install dependencies
npm run package # build the extension and package
```

--------------------------------

### Install and Launch Foxglove Bridge

Source: https://docs.foxglove.dev/docs/getting-started/frameworks/ros1?modality=live

Install the Foxglove Bridge package and launch the bridge node to make ROS topics available for live visualization.

```bash
sudo apt install ros-$ROS_DISTRO-foxglove-bridge
roslaunch --screen foxglove_bridge foxglove_bridge.launch

```

--------------------------------

### Install Python Foxglove SDK

Source: https://docs.foxglove.dev/docs/sdk?lang=python

Use pip to install the foxglove-sdk package from PyPI.

```python
pip install foxglove-sdk  
```

--------------------------------

### Install Foxglove Primary Site with Helm

Source: https://docs.foxglove.dev/docs/data/primary-sites/installation

Installs the Foxglove Primary Site using Helm, applying configurations from a local values.yaml file and creating the 'foxglove' namespace if it doesn't exist.

```bash
helm repo add foxglove https://helm-charts.foxglove.dev
helm repo update
helm upgrade --install foxglove-primary-site foxglove/primary-site \
    --values ./values.yaml \
    --namespace foxglove \
    --create-namespace  

```

--------------------------------

### Install Specific Primary Site Version

Source: https://docs.foxglove.dev/docs/data/primary-sites/upgrading

To install a particular version, specify the desired version number using the --version flag with the upgrade command.

```bash
helm upgrade foxglove-primary-site foxglove/primary-site \ 
    --namespace foxglove \ 
    --version 0.0.44  

```

--------------------------------

### Install and Launch Foxglove Bridge

Source: https://docs.foxglove.dev/docs/getting-started/frameworks/ros2

Install the Foxglove Bridge ROS package and launch the node to enable live visualization of ROS 2 topics.

```bash
sudo apt install ros-$ROS_DISTRO-foxglove-bridge  
ros2 launch foxglove_bridge foxglove_bridge_launch.xml  
```

--------------------------------

### Install LeRobot Actuator SDKs

Source: https://docs.foxglove.dev/docs/getting-started/frameworks/lerobot

Installs specific SDKs for different LeRobot actuator types. Choose the appropriate command based on your robot's hardware.

```bash
pip install -e ".[feetech]"  

```

```bash
pip install -e ".[dynamixel]"  

```

```bash
pip install -e ".[lekiwi]"  

```

--------------------------------

### Install and Launch Foxglove Bridge

Source: https://docs.foxglove.dev/docs/connecting-to-data/frameworks/ros2

Install the Foxglove Bridge ROS package and launch the bridge node to make ROS 2 topics available for live visualization.

```bash
sudo apt install ros-$ROS_DISTRO-foxglove-bridge
```

```bash
ros2 launch foxglove_bridge foxglove_bridge_launch.xml
```

--------------------------------

### Install and Launch Foxglove Bridge

Source: https://docs.foxglove.dev/docs/connecting-to-data/frameworks/ros1

Install the Foxglove Bridge package and launch the node to enable live ROS 1 data visualization in Foxglove. Ensure your ROS_DISTRO is set correctly.

```bash
sudo apt install ros-$ROS_DISTRO-foxglove-bridge  
roslaunch --screen foxglove_bridge foxglove_bridge.launch  
```

--------------------------------

### Basic FoxgloveViewer Setup

Source: https://docs.foxglove.dev/docs/embed/react-sdk

Basic setup of the FoxgloveViewer component. Provide the orgSlug prop to ensure the user is signed into the correct organization. The component is built on top of the @foxglove/embed package.

```jsx
import { FoxgloveViewer } from "@foxglove/embed-react";  
  
function BasicExample() {  
  return (  
    <div style={{ height: "100vh" }}>  
      <FoxgloveViewer orgSlug="my-org-slug" />  
    </div>  
  );  
}  


```

--------------------------------

### Set up C++ Project with CMake and Foxglove SDK

Source: https://docs.foxglove.dev/docs/sdk/example

Commands to create a directory for a C++ project and set up the CMakeLists.txt file to fetch and build the Foxglove SDK.

```bash
mkdir quickstart
cd quickstart

```

```cmake
cmake_minimum_required(VERSION 3.20)
project(quickstart LANGUAGES CXX)

# Set C++ standard
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Fetch the Foxglove SDK release archive.
include(FetchContent)
FetchContent_Declare(
    foxglove_sdk
    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
    # See available releases and builds here: https://github.com/foxglove/foxglove-sdk/releases?q=sdk%2F&expanded=true
    URL https://github.com/foxglove/foxglove-sdk/releases/download/sdk%2Fv0.24.0/foxglove-v0.24.0-cpp-x86_64-unknown-linux-gnu.zip
    URL_HASH SHA256=4381e1759f08b76f3bb2bf27ac4ab480caeb5cd71b8119221866c469534490c4
)
FetchContent_MakeAvailable(foxglove_sdk)

# Load the SDK's CMake package config (shipped under lib/cmake/foxglove-sdk/).
# It defines IMPORTED targets for the prebuilt C libraries and the
# foxglove_sdk_add_cpp_library() helper used below.
find_package(foxglove-sdk CONFIG REQUIRED HINTS "${foxglove_sdk_SOURCE_DIR}")

# Compile the SDK's C++ wrapper sources against our toolchain.
foxglove_sdk_add_cpp_library(foxglove_cpp TYPE STATIC)

# Add executable
add_executable(quickstart main.cpp)
target_link_libraries(quickstart PRIVATE foxglove_cpp)

```

--------------------------------

### Install Foxglove SO-100 Visualization Dependencies

Source: https://docs.foxglove.dev/docs/getting-started/robots/so-100

Clones the Foxglove SDK and installs additional dependencies required for the SO-100 visualization example within the LeRobot conda environment.

```bash
# Make sure you're in the lerobot environment
conda activate lerobot

# Clone the Foxglove SDK
git clone https://github.com/foxglove/foxglove-sdk
cd foxglove-sdk/python/foxglove-sdk-examples/so100-visualization
# Install additional dependencies for this example
pip install -r requirements.txt
```

--------------------------------

### Set up C++ Project Directory

Source: https://docs.foxglove.dev/docs/sdk/example?lang=cpp

Commands to create a new directory for a C++ project.

```bash
mkdir quickstart
cd quickstart
```

--------------------------------

### Install Prometheus Custom Metrics Adapter

Source: https://docs.foxglove.dev/docs/data/primary-sites/monitoring

Install the Prometheus adapter for the Kubernetes custom metrics API using Helm. This allows Kubernetes to use Prometheus metrics for autoscaling. Ensure the Prometheus URL is correct for your setup.

```bash
helm install prometheus-custom-metrics-adapter prometheus-community/prometheus-adapter -n prometheus --set prometheus.url=http://prometheus-server.prometheus.svc.cluster.local
```

--------------------------------

### Start Gateway with Capabilities (C++)

Source: https://docs.foxglove.dev/docs/sdk/remote-access-gateway

Create a remote access gateway instance in C++ using options to specify the `ClientPublish` capability and supported encodings.

```cpp
foxglove::RemoteAccessGatewayOptions options;  
options.capabilities = foxglove::RemoteAccessGatewayCapabilities::ClientPublish;  
options.supported_encodings = {"json"};  
auto gateway = foxglove::RemoteAccessGateway::create(std::move(options)).value();  

```

--------------------------------

### Initialize Foxglove C++ SDK and Set Up Logging

Source: https://docs.foxglove.dev/docs/sdk/example?lang=cpp

This snippet shows the basic setup for the Foxglove C++ SDK, including setting the log level, creating a context, and initializing an MCAP writer for data logging. It also includes error handling for writer creation.

```cpp
#include <foxglove/foxglove.hpp>
#include <foxglove/context.hpp>
#include <foxglove/error.hpp>
#include <foxglove/mcap.hpp>
#include <foxglove/server.hpp>
#include <foxglove/channel.hpp>
#include <foxglove/messages.hpp>

#include <chrono>
#include <thread>
#include <iostream>

using namespace std::chrono_literals;

int main(int argc, const char *argv[])
{
    foxglove::setLogLevel(foxglove::LogLevel::Debug);

    foxglove::Context context;

    foxglove::McapWriterOptions mcap_options = {};
    mcap_options.path = "quickstart-cpp.mcap";
    mcap_options.context = context;
    auto writer_result = foxglove::McapWriter::create(mcap_options);
    if (!writer_result.has_value())
    {
        std::cerr << "Failed to create writer: " << foxglove::strerror(writer_result.error()) << '\n';
        return 1;
    }
    auto writer = std::move(writer_result.value());

    // Start a server to communicate with the Foxglove app.
    foxglove::WebSocketServerOptions ws_options;
    ws_options.host = "127.0.0.1";
    ws_options.port = 8765;
    ws_options.context = context;
    auto server_result = foxglove::WebSocketServer::create(std::move(ws_options));
    if (!server_result.has_value())
    {
        std::cerr << "Failed to create server: " << foxglove::strerror(server_result.error()) << '\n';
        return 1;
    }
    auto server = std::move(server_result.value());
    std::cerr << "Server listening on port " << server.port() << '\n';

    // Create a schema for a JSON channel for logging {size: number}
    foxglove::Schema schema;
    schema.encoding = "jsonschema";
    std::string schema_data = R"({
        "type": "object",
        "properties": {
        "size": { "type": "number" }
        }
    })";
    schema.data = reinterpret_cast<const std::byte *>(schema_data.data());
    schema.data_len = schema_data.size();
    auto channel_result = foxglove::RawChannel::create("/size", "json", std::move(schema), context);
    if (!channel_result.has_value())
    {
        std::cerr << "Failed to create channel: " << foxglove::strerror(channel_result.error()) << '\n';
        return 1;
    }
    auto size_channel = std::move(channel_result.value());

    // Create a SceneUpdateChannel for logging changes to a 3d scene
    auto scene_channel_result = foxglove::messages::SceneUpdateChannel::create("/scene", context);
    if (!scene_channel_result.has_value())
    {
        std::cerr << "Failed to create scene channel: " << foxglove::strerror(scene_channel_result.error()) << '\n';
        return 1;
    }
    auto scene_channel = std::move(scene_channel_result.value());

    return 0;
}

```

--------------------------------

### AWS Ingress Annotations for HTTPS

Source: https://docs.foxglove.dev/docs/data/primary-sites/installation

Example ingress configuration for AWS, including annotations required for HTTPS certificates. Ensure the 'certificate-arn' is valid for your AWS setup.

```yaml
ingress:
  annotations:
    kubernetes.io/ingress.class: "alb"
    alb.ingress.kubernetes.io/scheme: internet-facing
    alb.ingress.kubernetes.io/target-type: ip
    alb.ingress.kubernetes.io/backend-protocol: HTTP
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS":443}]'
    alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:us-west-1:xxxxxxxxxxxx:certificate/EXAMPLE-xxxx-xxxx-xxxx-xxxxxxxxxxxx  

```

--------------------------------

### Run the Rust example

Source: https://docs.foxglove.dev/docs/getting-started/rust

Execute the Rust project from the command line using `cargo run`.

```bash
cargo run  
```

--------------------------------

### Send Log Messages in Python

Source: https://docs.foxglove.dev/docs/sdk?lang=python

This Python example shows how to initiate a Foxglove server and periodically send log messages. It requires the foxglove Python library to be installed.

```python
import foxglove
import time

from foxglove.messages import Log, LogLevel, Timestamp

server = foxglove.start_server()

while True:
    foxglove.log(
        "/hello",
        Log(
            timestamp=Timestamp.now(),
            level=LogLevel.Info,
            message="Hello, Foxglove!",
        )
    )

    time.sleep(0.033)

```

--------------------------------

### Rust: Setup Context, Channels, and Sinks

Source: https://docs.foxglove.dev/docs/sdk/example

Demonstrates setting up a lazy context, defining channels for different message types (Foxglove specific and raw JSON), and initializing an MCAP writer and WebSocket server. Ensure logger is initialized for debug output.

```rust
use foxglove::messages::{Color, CubePrimitive, SceneUpdate, Vector3};
use foxglove::{LazyContext, LazyChannel, LazyRawChannel, McapWriter, WebSocketServer};

const FILE_NAME: &str = "quickstart-rust.mcap";

static CTX_A: LazyContext = LazyContext::new();

// Our example logs data on a couple of different topics, so we'll create a
// channel for each. We can use a channel like Channel<SceneUpdate> to log
// Foxglove message types, or a generic RawChannel to log custom data.
static SCENE: LazyChannel<SceneUpdate> = CTX_A.channel("/scene");
static SIZE: LazyRawChannel = CTX_A.raw_channel("/size", "json");

fn main() {
    let env = env_logger::Env::default().default_filter_or("debug");
    env_logger::init_from_env(env);

    // We'll log to both an MCAP file, and to a running Foxglove app via a server.
    // This will be closed when the reference is dropped.
    let mcap = CTX_A.mcap_writer()
        .create_new_buffered_file(FILE_NAME)
        .expect("Failed to start mcap writer");

    // Start a server to communicate with the Foxglove app.
    // This will run indefinitely even if references are dropped.
    CTX_A.websocket_server()
        .start_blocking()
        .expect("Server failed to start");
}

```

--------------------------------

### Send Log Messages in C++

Source: https://docs.foxglove.dev/docs/sdk?lang=python

This C++ example illustrates starting a WebSocket server and emitting log messages. It utilizes the foxglove C++ library for server and message handling.

```cpp
#include <foxglove/server.hpp>
#include <foxglove/messages.hpp>

#include <thread>

int main(int argc, const char *argv[])
{
  foxglove::WebSocketServerOptions ws_options;
  auto server = foxglove::WebSocketServer::create(std::move(ws_options)).value();

  auto channel = foxglove::messages::LogChannel::create("/hello").value();

  while (true)
  {
    const auto now = std::chrono::system_clock::now();
    const auto nanos_since_epoch = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
    const auto seconds_since_epoch = nanos_since_epoch / 1000000000;
    const auto remaining_nanos = nanos_since_epoch % 1000000000;

    foxglove::messages::Log log;
    log.level = foxglove::messages::Log::LogLevel::INFO;
    log.message = "Hello, Foxglove!";
    log.timestamp = foxglove::Timestamp{
        static_cast<uint32_t>(seconds_since_epoch),
        static_cast<uint32_t>(remaining_nanos)};

    channel.log(log);

    std::this_thread::sleep_for(std::chrono::milliseconds(33));
  }

  return 0;
}

```

--------------------------------

### Example Settings Tree Structure

Source: https://docs.foxglove.dev/docs/extensions/extension-api/type-aliases/SettingsTree

Illustrates a sample settings tree with nested children and fields, demonstrating the path structure.

```json
root: {
  children: {
    a: {
      children: {
        b: {
          fields: {
            toggleMe: {
              label: "Toggle me",
              input: "boolean",
              value: false,
            },
          },
        },
      },
    },
  },
}
```

--------------------------------

### Send Log Messages in Rust

Source: https://docs.foxglove.dev/docs/sdk?lang=cpp

This Rust example demonstrates how to start a WebSocket server and continuously send INFO level log messages to the '/hello' topic. Ensure the Foxglove app is running and has a Log panel open to view these messages.

```rust
use foxglove::WebSocketServer;
use foxglove::{log, messages::{Log, Timestamp, log::Level}};
use std::{thread, time::Duration};

fn main() {
    WebSocketServer::new()
        .start_blocking()
        .expect("Server failed to start");

    loop {
        log!(
            "/hello",
            Log {
                level: Level::Info.into(),
                timestamp: Some(Timestamp::now()),
                message: "Hello, Foxglove!".to_string(),
                ..Default::default()
            }
        );
        thread::sleep(Duration::from_millis(100));
    }
}

```

--------------------------------

### Install zstd package

Source: https://docs.foxglove.dev/docs/getting-started/hardware/stereolabs-depth-cameras

Install the zstd package required for ZED SDK installation on Ubuntu.

```bash
sudo apt install zstd  
```

--------------------------------

### Initialize a New Foxglove Extension Project

Source: https://docs.foxglove.dev/docs/extensions

Use this command to set up a new extension project with the necessary directory structure and configuration. Ensure you have Node.js 14+ installed.

```bash
npm init foxglove-extension@latest my-extension-name  

```

--------------------------------

### Install OpenCV on macOS

Source: https://docs.foxglove.dev/docs/getting-started/hardware/rgb-camera

Installs the OpenCV library on macOS using Homebrew. This command assumes Homebrew is already installed and configured.

```bash
brew install opencv
```

--------------------------------

### Install OpenCV on Ubuntu/Debian

Source: https://docs.foxglove.dev/docs/getting-started/hardware/rgb-camera

Installs the OpenCV development library on Ubuntu or Debian-based systems. Ensure your package list is up-to-date before installing.

```bash
sudo apt update
sudo apt install libopencv-dev
```

--------------------------------

### Install @foxglove/embed with yarn

Source: https://docs.foxglove.dev/docs/embed/typescript-sdk

Install the @foxglove/embed package using yarn.

```bash
yarn add @foxglove/embed  

```

--------------------------------

### Install @foxglove/embed with npm

Source: https://docs.foxglove.dev/docs/embed/typescript-sdk

Install the @foxglove/embed package using npm.

```bash
npm install --save @foxglove/embed  

```

--------------------------------

### Set up WebSocket Server with Playback Control (C++)

Source: https://docs.foxglove.dev/docs/sdk/websocket-server?lang=cpp

Creates a Foxglove WebSocket server in C++, configuring it with PlaybackControl and Time capabilities and a specified playback time range. Error handling for server creation is included. This is for initializing the server for data replay.

```cpp
// ... Load your data and determine its time bounds ...
uint64_t start_time_ns = 0ULL;
uint64_t end_time_ns = 1000000000ULL;

foxglove::WebSocketServerOptions ws_options;
ws_options.capabilities = {
  foxglove::WebSocketServerCapabilities::PlaybackControl |
  foxglove::WebSocketServerCapabilities::Time};
ws_options.playback_time_range = std::make_pair(start_time_ns, end_time_ns);
ws_options.callbacks.onPlaybackControlRequest = onPlaybackControlRequest;

auto server_result = foxglove::WebSocketServer::create(std::move(ws_options));
if (!server_result.has_value()) {
  std::cerr << "Error in creating Foxglove WebSocketServer: "
  << foxglove::strerror(server_result.error()) << std::endl;
  exit(1);
}
auto server = std::move(server_result.value());

```

--------------------------------

### Install @foxglove/embed-react with yarn

Source: https://docs.foxglove.dev/docs/embed/react-sdk

Install the @foxglove/embed-react package using yarn.

```bash
yarn add @foxglove/embed-react  

```

--------------------------------

### Configure System Info Publisher (ROS 2)

Source: https://docs.foxglove.dev/docs/fleet/bridge

Launch the foxglove_bridge with system information collection enabled. Configure the topic name and refresh interval for system metrics.

```bash
ros2 launch foxglove_bridge foxglove_bridge_launch.xml \
  sysinfo:=true \
  sysinfo_topic:=/foxglove_bridge/sysinfo \
  sysinfo_refresh_interval:=500  

```

--------------------------------

### Install @foxglove/embed-react with npm

Source: https://docs.foxglove.dev/docs/embed/react-sdk

Install the @foxglove/embed-react package using npm.

```bash
npm install --save @foxglove/embed-react  

```

--------------------------------

### Set up WebSocket Server with Playback Control (Rust)

Source: https://docs.foxglove.dev/docs/sdk/websocket-server?lang=cpp

Constructs a WebSocket server, enabling PlaybackControl and Time capabilities. It configures the playback time range and sets a listener. Use this to initialize the server for replaying data.

```rust
use foxglove::websocket::Capability;
use std::sync::Arc;

let listener = Arc::new(ExampleListener {
    start_time_ns: 0,
    end_time_ns: 10000000000,
});

let server = foxglove::WebSocketServer::new()
    .capabilities([Capability::PlaybackControl, Capability::Time])
    .playback_time_range(listener.start_time_ns, listener.end_time_ns)
    .listener(listener)
    .start_blocking()
    .expect("Server failed to start");

```

--------------------------------

### Install Extensions for Self-hosted Viewer

Source: https://docs.foxglove.dev/docs/embed/self-hosted

Install extensions for the self-hosted embedded viewer by opening a file picker, selecting a `.foxe` file, and then installing it. This method is used because extensions hosted on Foxglove's servers are not accessible.

```javascript
window
  .showOpenFilePicker({
    multiple: false,
    types: [
      {
        description: ".foxe",
        accept: {
          "application/zip": [".foxe"],
        },
      },
    ],
  })
  .then(async (handles) => {
    const file = await handles[0]!.getFile();
    viewer.installExtensions([file]);
  });

```

--------------------------------

### Enable Automatic Agent Startup

Source: https://docs.foxglove.dev/docs/fleet/agent/installation

Configure the Fleet Agent to start automatically on system boot.

```bash
sudo systemctl enable foxglove-agent
```

--------------------------------

### Install LeRobot Package

Source: https://docs.foxglove.dev/docs/getting-started/frameworks/lerobot

Installs the LeRobot library in editable mode within the activated conda environment.

```bash
pip install -e .  

```

--------------------------------

### Instantiate SO100 Robot and Connect

Source: https://docs.foxglove.dev/docs/getting-started/frameworks/lerobot

Initializes the SO100 robot configuration and connects to the robot. Ensure hardware is set up and calibrated. Adjust 'port' and 'id' as needed.

```python
from lerobot.common.robots.so100_follower import SO100FollowerConfig, SO100Follower  
from lerobot.common.cameras.opencv.configuration_opencv import OpenCVCameraConfig  
from lerobot.common.cameras.opencv.camera_opencv import OpenCVCamera  
from lerobot.common.cameras.configs import ColorMode  
  
RobotConfig = SO100FollowerConfig  
Robot = SO100Follower  
config = RobotConfig(port="/dev/ttyUSB0", id="foxglove_so100", use_degrees=True)  
follower = Robot(config)  
follower.connect(calibrate=False)  

```

--------------------------------

### Manifest Endpoint Response Example

Source: https://docs.foxglove.dev/docs/visualization/connecting/cloud-data/remote-data-loader

Example JSON response from a manifest endpoint, detailing data sources and schemas.

```json
{
  "name": "first-recording",
  "sources": [
    {
      "topics": [
        {
          "name": "/cos",
          "messageEncoding": "protobuf",
          "schemaId": 1
        }
      ],
      "schemas": [
        {
          "id": 1,
          "name": "point.Point",
          "encoding": "protobuf",
          "data": "CjQKC1BvaW50LnByb3RvEgVwb2ludCIWCgVQb2ludBINCgV2YWx1ZRgBIAIoAWIGcHJvdG8z"
        }
      ],
      "url": "/data?recording-id=first-recording",
      "id": "first-recording",
      "startTime": "1970-01-01T00:00:00Z",
      "endTime": "1970-01-01T00:00:10Z"
    }
  ]
}

```

--------------------------------

### Initialize Foxglove Extension

Source: https://docs.foxglove.dev/docs/extensions/guides/create-custom-panel

Run this command in your terminal to create a new Foxglove extension project with example source code.

```bash
npm init foxglove-extension@latest myExtensionName  

```

--------------------------------

### Install WASM Target for Rust

Source: https://docs.foxglove.dev/docs/extensions/guides/create-data-loader

Install the `wasm32-unknown-unknown` target for Rust using rustup. This is required for building WASM extensions.

```bash
rustup add target wasm32-unknown-unknown
```

--------------------------------

### Instantiate LeKiwi Robot and Connect

Source: https://docs.foxglove.dev/docs/getting-started/frameworks/lerobot

Initializes the LeKiwi robot configuration and connects to the robot. Ensure hardware is set up and calibrated. Adjust 'port' and 'id' as needed.

```python
from lerobot.common.robots.lekiwi import LeKiwiConfig, LeKiwi  
from lerobot.common.cameras.opencv.configuration_opencv import OpenCVCameraConfig  
from lerobot.common.cameras.opencv.camera_opencv import OpenCVCamera  
from lerobot.common.cameras.configs import ColorMode  
  
RobotConfig = LeKiwiConfig  
Robot = LeKiwi  
config = RobotConfig(port="/dev/ttyUSB0", id="foxglove_lekiwi", use_degrees=True)  
follower = Robot(config)  
follower.connect(calibrate=False)  

```

--------------------------------

### Helm Installation Command

Source: https://docs.foxglove.dev/docs/visualization/connecting/cloud-data/remote-data-loader/deployment

Install or upgrade the Foxglove Remote Data Loader using Helm, specifying a values file and namespace.

```bash
helm repo add foxglove https://helm-charts.foxglove.dev
helm repo update
helm upgrade --install foxglove-remote-data-loader foxglove/remote-data-loader \
    --values ./values.yaml \
    --namespace foxglove \
    --create-namespace

```

--------------------------------

### List all devices using CLI

Source: https://docs.foxglove.dev/docs/data/devices

View all devices registered within your organization using this command.

```bash
foxglove devices list
```

--------------------------------

### Install Foxglove notebook integration

Source: https://docs.foxglove.dev/docs/notebook

Install the optional notebook integration package using pip. This enables Jupyter-like environment support.

```bash
pip install "foxglove-sdk[notebook]"
```

--------------------------------

### Run Basic Robot Visualization

Source: https://docs.foxglove.dev/docs/getting-started/robots/so-100

Starts the basic SO-100 robot visualization without camera feeds. Replace `/dev/ttyUSB0` with your robot's port and `my_so100_arm` with your calibration ID.

```bash
python main.py \
    --robot.port=/dev/ttyUSB0 \
    --robot.id=my_so100_arm
```

--------------------------------

### Install Python dependencies with pip

Source: https://docs.foxglove.dev/docs/getting-started/hardware/stereolabs-depth-cameras

Install required Python packages including foxglove-sdk, numpy, opencv-python, and requests using pip.

```bash
pip install foxglove-sdk>=0.4.0 numpy>=2.0 opencv-python>=4.10 requests>=2.31  
```
Tokens:
Raw