Sensor Component

A sensor is a device that can measure information about the outside world. Add a sensor component to your machine to send the information the sensor measures to the computer controlling the machine.

Most machines with a sensor need at least the following hardware:

• A board
• Depending on your sensor’s output type (analog or digital), an analog-to-digital converter (ADC) may be necessary to allow the sensor to communicate with the board

Related services

Data Management

Available models

To use your motor component, check whether one of the following models supports it.

For configuration information, click on the model name:

Control your sensor with Viam’s client SDK libraries

To get started using Viam’s SDKs to connect to and control your machine, go to your machine’s page on the Viam app, navigate to the CONNECT tab’s Code sample page, select your preferred programming language, and copy the sample code.

When executed, this sample code will create a connection to your machine as a client. Then control your machine programmatically by adding API method calls as shown in the following examples.

These examples assume you have a sensor called "my_sensor" configured as a component of your machine. If your sensor has a different name, change the name in the code.

Be sure to import the sensor package for the SDK you are using:

from viam.components.sensor import Sensor

import (
  "go.viam.com/rdk/components/sensor"
)

API

The sensor component supports the following methods:

GetReadings

Get the measurements or readings that this sensor provides. Supported by viam-micro-server.

my_sensor = Sensor.from_robot(robot=robot, name='my_sensor')

# Get the readings provided by the sensor.
readings = await my_sensor.get_readings()

// Get the readings provided by the sensor.
readings, err := mySensor.Readings(context.Background(), nil)

var readings = await mySensor.readings();

GetGeometries

Get all the geometries associated with the sensor in its current configuration, in the frame of the sensor. The motion and navigation services use the relative position of inherent geometries to configured geometries representing obstacles for collision detection and obstacle avoidance while motion planning.

geometries = await component.get_geometries()

if geometries:
    # Get the center of the first geometry
    print(f"Pose of the first geometry's centerpoint: {geometries[0].center}")

Reconfigure

Reconfigure this resource. Reconfigure must reconfigure the resource atomically and in place.

DoCommand

Execute model-specific commands that are not otherwise defined by the component API. For built-in models, model-specific commands are covered with each model’s documentation. If you are implementing your own sensor and add features that have no built-in API method, you can access them with DoCommand. Supported by viam-micro-server.

command = {"cmd": "test", "data1": 500}
result = component.do(command)

// This example shows using DoCommand with an arm component.
myArm, err := arm.FromRobot(machine, "my_arm")

command := map[string]interface{}{"cmd": "test", "data1": 500}
result, err := myArm.DoCommand(context.Background(), command)

// Example using doCommand with an arm component
const command = {'cmd': 'test', 'data1': 500};
var result = myArm.doCommand(command);

FromRobot

Get the resource from the provided robot with the given name.

GetResourceName

Get the ResourceName for this sensor with the given name.

# Can be used with any resource, using an arm as an example
my_arm_name = my_arm.get_resource_name("my_arm")

Close

Safely shut down the resource and prevent further use.

await component.close()

// This example shows using Close with an arm component.
myArm, err := arm.FromRobot(machine, "my_arm")

err = myArm.Close(ctx)

Troubleshooting

You can find additional assistance in the Troubleshooting section.

You can also ask questions in the Community Discord and we will be happy to help.

Next steps

Plant Watering Robot

Create a plant watering robot with a Raspberry Pi.

Drink Serving Robot

Create an autonomous drink carrying robot with motion sensing and machine learning.