> This page is for version 3.0 (Latest) (default).
> For other versions, use one of these documentation indexes:
> - 3.0 (Latest) (default): https://docs.nvidia.com/holoscan/sensor-bridge/3-0/llms.txt
> - 2.7: https://docs.nvidia.com/holoscan/sensor-bridge/2-7/llms.txt
> - Archives: https://docs.nvidia.com/holoscan/sensor-bridge/archives/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/holoscan/sensor-bridge/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/holoscan/sensor-bridge/_mcp/server.

# hololink::module::OscillatorInterfaceV1

> Configure a clock source driving a sensor.

Configure a clock source driving a sensor.

Sensors usually require an external reference clock before they can be configured. Call enable() with the rate the sensor requires, before configuring the sensor.

```cpp showLineNumbers={false}
#include <hololink/module/oscillator.hpp>
```

**Inherits from:** `hololink::module::ConfigurableService< OscillatorInterfaceV1 >` (public)

---

## Methods

### enable \[#enable]

```cpp showLineNumbers={false}
virtual bool hololink::module::OscillatorInterfaceV1::enable(
    uint64_t clocks_per_second
)
```

Start the oscillator at the given output rate.

Calling this again with the rate the oscillator is already producing succeeds without disturbing the output, so it is safe to call from each sensor sharing a clock generator. Where the generator can supply only one rate at a time, asking for a different rate than the one already running returns `false`. After the device is reset the output must be started again by calling enable() again.

**Returns:** `true` if the oscillator is now producing the requested rate. `false` if the hardware cannot produce that rate, or cannot do so while another rate is in use.

**Parameters**

**`clocks_per_second`** `uint64_t`

Requested output frequency, in Hz.

---

### get_caps \[#getcaps]

```cpp showLineNumbers={false}
virtual std::map<std::string, std::string> hololink::module::OscillatorInterfaceV1::get_caps()
```

Report the oscillator's adjustable settings.

Settings are hardware specific; keys and their meaning are defined by the oscillator in use. Values are strings; how numeric values are encoded is also defined by the oscillator. An oscillator with no adjustable settings returns an empty map.

**Returns:** The current value of each setting, by name.

### set_caps \[#setcaps]

```cpp showLineNumbers={false}
virtual bool hololink::module::OscillatorInterfaceV1::set_caps(
    const std::map<std::string, std::string> &caps
)
```

Change one or more of the oscillator's adjustable settings.

The update is all-or-nothing: either every entry is applied, or none is.

**Returns:** `true` if every entry was applied. `false` if any name is not supported or any value is out of range for the hardware, in which case no setting is changed.

**Parameters**

**`caps`** `const std::map<std::string, std::string> &`

New values, by setting name; use the names reported by get_caps().

---

### configure \[#configure]

```cpp showLineNumbers={false}
virtual void hololink::module::ConfigurableService<OscillatorInterfaceV1>::configure(
    const EnumerationMetadata &
)
```

Use `metadata` contents to initialize this instance.

This routine is guaranteed to be called the first time a call to get_service(metadata) is called on a specific service instance.

### module \[#module]

```cpp showLineNumbers={false}
std::shared_ptr<Module> hololink::module::ServiceBase::module() const
```

The [Module](module) that this service was published from.

The service holds no strong reference to its [Module](module), so this does not extend the [Module](module)'s lifetime.

**Returns:** The owning [Module](module), or an empty pointer if the service has not been published or its [Module](module) no longer exists.

---

## Static methods

### get_service \[#getservice]

#### Fetch a service

```cpp showLineNumbers={false}
static std::shared_ptr<OscillatorInterfaceV1> hololink::module::ConfigurableService<OscillatorInterfaceV1>::get_service(
    const EnumerationMetadata &metadata,
    bool allow_null = false
)
```

Fetch a service, configured by [EnumerationMetadata](enumerationmetadata).

[Module](module) usually caches service objects; so when a specific service instance isn't found, it will be constructed with the current values in [EnumerationMetadata](enumerationmetadata). Later calls to get_service are likely to return that cached instance, ignoring changes to any enumeration metadata that aren't specifically related to service addressing.

**Returns:** A shared pointer to the requested service (\<Derived>).

**Throws:** `std::runtime_error` when allow_null==false and the service lookup (or construction) fails.

**Parameters**

**`metadata`** `const EnumerationMetadata &`

Addressing and configuration for the service.

---

**`allow_null`** `bool` — default: false

Use `true` to return nullptr when the service cannot be resolved; the default `false` value raises a std::runtime_error.

---

#### Overload 2

inline

```cpp showLineNumbers={false}
static std::shared_ptr<OscillatorInterfaceV1> hololink::module::Service<OscillatorInterfaceV1>::get_service(
    std::shared_ptr<Module> module,
    const char *instance_id,
    bool allow_null = false
)
```

Type-safe way to fetch a std::shared_ptr to an instance of \<Derived> from a [Module](module).

Note that [Module](module) usually caches instances, it's likely that calls to get_service with the same locator_id will return pointers to the same implementation object.

**Returns:** A shared pointer to the service instance.

**Parameters**

**`module`** `std::shared_ptr<Module>`

Is the shared object that owns the instance we wish to fetch

---

**`instance_id`** `const char *`

Names the specific object, usually expressed as a set of "name=value;..." pairs, as defined by the implementations themselves. This name is normally fetched by calling `Derived::locator_id(enumeration_metadata)`.

---

**`allow_null`** `bool` — default: false

The default value of `false` causes this routine to throw a std::runtime_error if the service cannot be found within the module; this would be expected to terminate the calling program. If the application wants to handle the error, pass in `true` here and get_service will return `nullptr` when this module doesn't provide the requested service.

---

### for_each_type_id \[#foreachtypeid]

```cpp showLineNumbers={false}
static bool hololink::module::Service<OscillatorInterfaceV1>::for_each_type_id(
    Callback &&cb
)
```

Iterate over every type_id supported by this instance.

The callback signature is `bool(const char*)` — returning false halts the walk; true continues. Iteration is depth-first, so you'll see the most specific implementation types first.