Skip to content

Usage

Jump to bottom
NukeMinecart edited this page Aug 29, 2025 · 16 revisions

This page goes into more detail on how to use BadgerLog

Contents

  • Basic Usage
  • Types of Entries
    • Publisher
    • Subscriber
    • Sendable
  • Entry Configuration
    • @Key
    • @StructType
    • @UnitConversion
    • @AutoGenerateStruct
  • Dashboard methods
    • putValue
    • getValue
    • putSendable
    • createSelectorFromEnum
    • createNetworkTablesButton
    • removeNetworkTablesEntry
  • Wrappers
    • Value
    • Struct Value
    • Subtable
    • Sendable
  • Common Issues

Basic Usage

BadgerLog is designed to use annotations to generate custom NetworkTables wrappers that support some additional functionality. Annotations are the preferred method of using BadgerLog.

Some Notes before starting.

  • Fields need to be initialized after the constructor
  • Fields can not be final
  • Fields can have any access modifier (public, private, protected)
  • Fields may be either instance, or static fields
  • Dashboard.update must be called in a periodic method. (usually Robot.robotPeriodic)
  • Dashboard.configure may be called on startup. (Usually Robot.robotInit)

Given this, it is relatively easy to start creating entries.

The base annotation needed to mark a field to have an entry created is the @Entry annotation

Example base usage

@Entry(EntryType.PUBLISHER)
public int basicInteger = 1;

Without specifying the key using the @Key annotation, the default is Enclosing Class/Field Name.

In this example, if the class the field was defined in was named ArmSubsystem then the final NetworkTables key would be ArmSubsystem/basicInteger

The / in the key for NetworkTables specifies that it should use the table within the BadgerLog table named ArmSubsystem and the entry named basicInteger.

Types of Entries

There are 3 options to generate entries for NetworkTables. Publishers, Subscribers, and Sendables. They all have different specifications and do different things.

Publishers

Publisher entries take the value on the field and put it to NetworkTables. Changing the field's value in code, changes it on NetworkTables.
This can be used with any type of field except those with the value of Sendable

Subscribers

Subscriber entries take the value from NetworkTables and set the field's value to it. Changing the value on NetworkTables changes the field's value.

This can be used with any type of field except those with the value of Sendable and additionally, unlike publishers, cannot be used with the STRUCT StructType option.

Sendables

Sendable entries use the defined Sendable.init method to create associated entries and tables. Natively supports using both publisher and subscriber options.

This can be used with only the Sendable (or subclasses of it) field type.

Advanced Usage

BadgerLog allows for a high level of customization of each entry. This is done also through annotations, but are always optional and have a global default if missing.

@Key

The @Key annotation allows for customization of the key used on NetworkTables.

Parameters: String - the key to use on NetworkTables instead of the generated one
Changes: Key on NetworkTables

Usage Example

@Entry(EntryType.SUBSCRIBER)
@Key("Auto/AutoWaitTime")
public double waitTime = 0;

This creates a double entry under the Auto table named AutoWaitTime.

Using @Key removes the standard generation of the key from the field name and enclosing class

The @Key annotation additionally allows for instance specific keys in any portion of the key, referencing an instance variable. It is in the format of {Field Name}.

Usage Example

@Entry(EntryType.SUBSCRIBER)
@Key("Modules/{descriptor}/Module P")
public double moduleP = 0;

private String descriptor;

public SwerveModule(/*Other parameters */, String descriptor) {
    // Other initialization code
    this.descriptor = descriptor;
}

This would create a new entry for every instance of the SwerveModule class. The entry would be under both the Modules table and the table with the name of descriptor.

The {Field Name} must match the field name exactly as defined in the class.

@StructType

The @StructType annotation allows for customization of how a Struct type entry is created. See Wrappers for an explanation of each type.

Parameters: StructType - the type of struct entry to use
Changes: How a struct entry is created

Usage Example

@Entry(EntryType.PUBLISHER)
@Struct(StructType.STRUCT)
public Rotation2d rotation2d = Rotation2d.fromDegrees(1306);

This would publish the struct as a value-struct, using the default NetworkTables implementation of the StructEntry.

This could be changed to StructOptions.SUB_TABLE for subtable publishing or StructOptions.MAPPING for mapping publishing.

@UnitConversion

The @UnitConversion annotation allows units to be converted to a different form of the same unit.

Parameters:

  • String - the unit to convert to
  • String converterId - (Optional) the id of the converter to use with a mapping. Defaults empty

Usage Example

@Entry(EntryType.PUBLISHER)
@UnitConversion("meters")
public Distance height = Inches.of(10);

This publishes a double entry of the height converted to meters. Subscribing works the same way but in reverse. The unit String can be any form of the unit, case-insensitive.

// These all work
@UnitConversion("m")
@UnitConversion("meter")
@UnitConversion("METERS")
@UnitConversion("M")

The @UnitConversion annotation also allows for itself to be placed multiple times on a field to specify the converters to use for a more complicated mapping. Examples include Pose2d, Pose3d, Twist2d, and Twist3d.

The converterId is always translation for distance types and rotation for rotation types. It is only ever used when there are more than one unit to convert at a time.

Usage Example

@Entry(EntryType.SUBSCRIBER)
@UnitConversion(value = "in", converterId = "translation")
@UnitConversion(value = "radian", converterId = "rotation")
public Pose2d robotPose = Pose2d.kZero;

This converts any distance to inches and any rotation to radians in the Pose2d

@AutoGenerateStruct

The @AutoGenerateStruct annotation allows a struct to be generated from a record or enum class. It is used as a marker for BadgerLog to use the generated struct instead of a mapping.

Parameters: boolean (Optional) whether to generate the struct or not. Defaults true Changes: Marks the field to have a struct auto generated for it

Usage Example

@Entry(EntryType.SUBSCRIBER)
@AutoGenerateStruct
public CustomRecord record = new CustomRecord("value", 3);

public record CustomRecord(String value, int count) {
}

This will automatically generate a struct for this, allowing it to be used with BadgerLog's struct publishing options.

Dashboard Methods

BadgerLog provides a bunch of utility methods to allow for some unique interactions with NetworkTables.

putValue methods

The putValue method acts similarly to the EntryType.PUBLISHER for annotations. The only difference is that it doesn't automatically generate the configuration from annotations. Useful for one time logging of specific fields, but not recommended.

Usage Example

public void execute() {
    Dashboard.putValue("MoveArmCommand/Current Draw", /* the current draw */);
    Dashboard.putValue("MoveArmCommand/Arm Angle", /* the current angle */,
            new Configuration().withConverter("", UnitConversion.createConverter("degrees")));
}

getValue methods

The getValue method acts similarly to the EntryType.SUBSCRIBER for annotations. The only difference is that it doesn't automatically generate the configuration from annotations. Useful for one time retrieving of specific keys, but not recommended.

Usage Example

public void periodic() {
    int kG = Dashboard.getValue("Arm/kG", /* the initial value */);
    int targetRotation = Dashboard.getValue("Arm/Target Rotation", /* initial rotation */,
            new Configuration().withStructType(StructType.SUBTABLE));
}

putSendable method

The putSendable method acts similarly to the EntryType.SENDABLE for annotations. There is almost no difference in its use, except that it allows for publishing a Sendable within a method. putSendable may be called as many times as desired with the same key. It will close and override the previous entry.

Usage Example

public void updateOdometry() {
    Field2d field2d = new Field2d();
    field2d.setRobotPose(/* pose data */);

    Dashboard.putSendable("Field2d", field2d);
}

createSelectorFromEnum methods

The createSelectorFromEnum method allows an enum's constants to be published as a SendableChooser. It takes the name of each constant, and publishes it as a string.

By default, it will use the first constant defined in the Enum class, but can be specified with the method overload.

public Robot() {
    Dashboard.createSelectorFromEnum("Robot/RobotModeSelector", RobotMode.class, RobotMode.AUTOMATIC,
            (value) -> /* on changed */
    );
}

public enum RobotMode {
    MANUAL,
    AUTOMATIC,
    DISABLED
}

createNetworkTablesButton methods

The createNetworkTablesButton method allows a Trigger to be bound to a boolean on NetworkTables. The createAutoResettingButton is similar, but resets back to false after being true for 0.25 seconds.

A special requirement of both methods: it cannot be called more than once with the same key

public Autos() {
    Dashboard.createNetworkTablesButton("Auto/IgnoreWaitTime", CommandScheduler.getInstance().getDefaultButtonLoop())
            .onTrue(/* some command */);

    Dashboard.createAutoResettingButton("Auto/ResetOdometry", CommandScheduler.getInstance().getDefaultButtonLoop())
            .onTrue(/* some command */);
}

removeNetworkTablesEntry method

The removeNetworkTablesEntry method allows for the unpublishing of an entry. It removes the entry completely from updating and NetworkTables.

Wrappers

BadgerLog contains wrappers around NetworkTables entries to enable more customization and features.

Normal Value

Defined by ValueEntry. Enables the use of the mapping system, allows the conversion of any type into a valid NetworkTables type.

Struct Value

Defined by StructValueEntry. Publishes the struct as is, using the NetworkTables struct implementation.

Does not work with Elastic (Support for structs doesn't exist).

Subtable

Defined by SubtableEntry. Generates every entry needed to create a struct-like view. Creates relative tables for each field defined in the struct.

Sendable

Defined by SendableEntry. Registers the Sendable with the SendableRegistry and updates it.

Common Issues

  • Entries not appearing on NetworkTables:

  • Invalidated

  • Key specified wrong

  • Final field

  • Null field

  • Struct generated wrong

  • Invalid schema

  • Enum has invalid schema when autogenerated and using subtable publishing

  • Converter has default id when specified and multiple of them

  • Converter has invalid unit type

  • Converter has wrong id

  • Record references itself

  • Mapping doesn't exist for a type

  • Struct value doesn't let subscribing

Javadoc can be found on Jitpack

Clone this wiki locally