Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-03 03:01:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

[wpimath] Reorganize LinearSystem factories (#8468)

Browse Source
This commit is contained in:
Tyler Veness
2026-01-12 19:09:35 -08:00
committed by GitHub
parent 89d0759ef2
commit 00fa8361dd
108 changed files with 1808 additions and 2138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

621
wpimath/src/generated/main/java/org/wpilib/math/proto/Plant.java generated
View File

@@ -1,621 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
// Code generated by protocol buffer compiler. Do not edit!
package org.wpilib.math.proto;
import java.io.IOException;
import us.hebi.quickbuf.Descriptors;
import us.hebi.quickbuf.FieldName;
import us.hebi.quickbuf.InvalidProtocolBufferException;
import us.hebi.quickbuf.JsonSink;
import us.hebi.quickbuf.JsonSource;
import us.hebi.quickbuf.MessageFactory;
import us.hebi.quickbuf.ProtoMessage;
import us.hebi.quickbuf.ProtoSink;
import us.hebi.quickbuf.ProtoSource;
import us.hebi.quickbuf.ProtoUtil;
import us.hebi.quickbuf.RepeatedByte;
public final class Plant {
private static final RepeatedByte descriptorData = ProtoUtil.decodeBase64(607,
"CgtwbGFudC5wcm90bxIJd3BpLnByb3RvIsQBCg9Qcm90b2J1ZkRDTW90b3ISJwoPbm9taW5hbF92b2x0" +
"YWdlGAEgASgBUg5ub21pbmFsVm9sdGFnZRIhCgxzdGFsbF90b3JxdWUYAiABKAFSC3N0YWxsVG9ycXVl" +
"EiMKDXN0YWxsX2N1cnJlbnQYAyABKAFSDHN0YWxsQ3VycmVudBIhCgxmcmVlX2N1cnJlbnQYBCABKAFS" +
"C2ZyZWVDdXJyZW50Eh0KCmZyZWVfc3BlZWQYBSABKAFSCWZyZWVTcGVlZEIXChVvcmcud3BpbGliLm1h" +
"dGgucHJvdG9K3AIKBhIEAAAMAQoICgEMEgMAABIKCAoBAhIDAgASCggKAQgSAwQALgoJCgIIARIDBAAu" +
"CgoKAgQAEgQGAAwBCgoKAwQAARIDBggXCgsKBAQAAgASAwcCHQoMCgUEAAIABRIDBwIICgwKBQQAAgAB" +
"EgMHCRgKDAoFBAACAAMSAwcbHAoLCgQEAAIBEgMIAhoKDAoFBAACAQUSAwgCCAoMCgUEAAIBARIDCAkV" +
"CgwKBQQAAgEDEgMIGBkKCwoEBAACAhIDCQIbCgwKBQQAAgIFEgMJAggKDAoFBAACAgESAwkJFgoMCgUE" +
"AAICAxIDCRkaCgsKBAQAAgMSAwoCGgoMCgUEAAIDBRIDCgIICgwKBQQAAgMBEgMKCRUKDAoFBAACAwMS" +
"AwoYGQoLCgQEAAIEEgMLAhgKDAoFBAACBAUSAwsCCAoMCgUEAAIEARIDCwkTCgwKBQQAAgQDEgMLFhdi" +
"BnByb3RvMw==");
static final Descriptors.FileDescriptor descriptor = Descriptors.FileDescriptor.internalBuildGeneratedFileFrom("plant.proto", "wpi.proto", descriptorData);
static final Descriptors.Descriptor wpi_proto_ProtobufDCMotor_descriptor = descriptor.internalContainedType(27, 196, "ProtobufDCMotor", "wpi.proto.ProtobufDCMotor");
/**
* @return this proto file's descriptor.
*/
public static Descriptors.FileDescriptor getDescriptor() {
return descriptor;
}
/**
* Protobuf type {@code ProtobufDCMotor}
*/
public static final class ProtobufDCMotor extends ProtoMessage<ProtobufDCMotor> implements Cloneable {
private static final long serialVersionUID = 0L;
/**
* <code>optional double nominal_voltage = 1;</code>
*/
private double nominalVoltage;
/**
* <code>optional double stall_torque = 2;</code>
*/
private double stallTorque;
/**
* <code>optional double stall_current = 3;</code>
*/
private double stallCurrent;
/**
* <code>optional double free_current = 4;</code>
*/
private double freeCurrent;
/**
* <code>optional double free_speed = 5;</code>
*/
private double freeSpeed;
private ProtobufDCMotor() {
}
/**
* @return a new empty instance of {@code ProtobufDCMotor}
*/
public static ProtobufDCMotor newInstance() {
return new ProtobufDCMotor();
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @return whether the nominalVoltage field is set
*/
public boolean hasNominalVoltage() {
return (bitField0_ & 0x00000001) != 0;
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @return this
*/
public ProtobufDCMotor clearNominalVoltage() {
bitField0_ &= ~0x00000001;
nominalVoltage = 0D;
return this;
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @return the nominalVoltage
*/
public double getNominalVoltage() {
return nominalVoltage;
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @param value the nominalVoltage to set
* @return this
*/
public ProtobufDCMotor setNominalVoltage(final double value) {
bitField0_ |= 0x00000001;
nominalVoltage = value;
return this;
}
/**
* <code>optional double stall_torque = 2;</code>
* @return whether the stallTorque field is set
*/
public boolean hasStallTorque() {
return (bitField0_ & 0x00000002) != 0;
}
/**
* <code>optional double stall_torque = 2;</code>
* @return this
*/
public ProtobufDCMotor clearStallTorque() {
bitField0_ &= ~0x00000002;
stallTorque = 0D;
return this;
}
/**
* <code>optional double stall_torque = 2;</code>
* @return the stallTorque
*/
public double getStallTorque() {
return stallTorque;
}
/**
* <code>optional double stall_torque = 2;</code>
* @param value the stallTorque to set
* @return this
*/
public ProtobufDCMotor setStallTorque(final double value) {
bitField0_ |= 0x00000002;
stallTorque = value;
return this;
}
/**
* <code>optional double stall_current = 3;</code>
* @return whether the stallCurrent field is set
*/
public boolean hasStallCurrent() {
return (bitField0_ & 0x00000004) != 0;
}
/**
* <code>optional double stall_current = 3;</code>
* @return this
*/
public ProtobufDCMotor clearStallCurrent() {
bitField0_ &= ~0x00000004;
stallCurrent = 0D;
return this;
}
/**
* <code>optional double stall_current = 3;</code>
* @return the stallCurrent
*/
public double getStallCurrent() {
return stallCurrent;
}
/**
* <code>optional double stall_current = 3;</code>
* @param value the stallCurrent to set
* @return this
*/
public ProtobufDCMotor setStallCurrent(final double value) {
bitField0_ |= 0x00000004;
stallCurrent = value;
return this;
}
/**
* <code>optional double free_current = 4;</code>
* @return whether the freeCurrent field is set
*/
public boolean hasFreeCurrent() {
return (bitField0_ & 0x00000008) != 0;
}
/**
* <code>optional double free_current = 4;</code>
* @return this
*/
public ProtobufDCMotor clearFreeCurrent() {
bitField0_ &= ~0x00000008;
freeCurrent = 0D;
return this;
}
/**
* <code>optional double free_current = 4;</code>
* @return the freeCurrent
*/
public double getFreeCurrent() {
return freeCurrent;
}
/**
* <code>optional double free_current = 4;</code>
* @param value the freeCurrent to set
* @return this
*/
public ProtobufDCMotor setFreeCurrent(final double value) {
bitField0_ |= 0x00000008;
freeCurrent = value;
return this;
}
/**
* <code>optional double free_speed = 5;</code>
* @return whether the freeSpeed field is set
*/
public boolean hasFreeSpeed() {
return (bitField0_ & 0x00000010) != 0;
}
/**
* <code>optional double free_speed = 5;</code>
* @return this
*/
public ProtobufDCMotor clearFreeSpeed() {
bitField0_ &= ~0x00000010;
freeSpeed = 0D;
return this;
}
/**
* <code>optional double free_speed = 5;</code>
* @return the freeSpeed
*/
public double getFreeSpeed() {
return freeSpeed;
}
/**
* <code>optional double free_speed = 5;</code>
* @param value the freeSpeed to set
* @return this
*/
public ProtobufDCMotor setFreeSpeed(final double value) {
bitField0_ |= 0x00000010;
freeSpeed = value;
return this;
}
@Override
public ProtobufDCMotor copyFrom(final ProtobufDCMotor other) {
cachedSize = other.cachedSize;
if ((bitField0_ | other.bitField0_) != 0) {
bitField0_ = other.bitField0_;
nominalVoltage = other.nominalVoltage;
stallTorque = other.stallTorque;
stallCurrent = other.stallCurrent;
freeCurrent = other.freeCurrent;
freeSpeed = other.freeSpeed;
}
return this;
}
@Override
public ProtobufDCMotor mergeFrom(final ProtobufDCMotor other) {
if (other.isEmpty()) {
return this;
}
cachedSize = -1;
if (other.hasNominalVoltage()) {
setNominalVoltage(other.nominalVoltage);
}
if (other.hasStallTorque()) {
setStallTorque(other.stallTorque);
}
if (other.hasStallCurrent()) {
setStallCurrent(other.stallCurrent);
}
if (other.hasFreeCurrent()) {
setFreeCurrent(other.freeCurrent);
}
if (other.hasFreeSpeed()) {
setFreeSpeed(other.freeSpeed);
}
return this;
}
@Override
public ProtobufDCMotor clear() {
if (isEmpty()) {
return this;
}
cachedSize = -1;
bitField0_ = 0;
nominalVoltage = 0D;
stallTorque = 0D;
stallCurrent = 0D;
freeCurrent = 0D;
freeSpeed = 0D;
return this;
}
@Override
public ProtobufDCMotor clearQuick() {
if (isEmpty()) {
return this;
}
cachedSize = -1;
bitField0_ = 0;
return this;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof ProtobufDCMotor)) {
return false;
}
ProtobufDCMotor other = (ProtobufDCMotor) o;
return bitField0_ == other.bitField0_
&& (!hasNominalVoltage() || ProtoUtil.isEqual(nominalVoltage, other.nominalVoltage))
&& (!hasStallTorque() || ProtoUtil.isEqual(stallTorque, other.stallTorque))
&& (!hasStallCurrent() || ProtoUtil.isEqual(stallCurrent, other.stallCurrent))
&& (!hasFreeCurrent() || ProtoUtil.isEqual(freeCurrent, other.freeCurrent))
&& (!hasFreeSpeed() || ProtoUtil.isEqual(freeSpeed, other.freeSpeed));
}
@Override
public void writeTo(final ProtoSink output) throws IOException {
if ((bitField0_ & 0x00000001) != 0) {
output.writeRawByte((byte) 9);
output.writeDoubleNoTag(nominalVoltage);
}
if ((bitField0_ & 0x00000002) != 0) {
output.writeRawByte((byte) 17);
output.writeDoubleNoTag(stallTorque);
}
if ((bitField0_ & 0x00000004) != 0) {
output.writeRawByte((byte) 25);
output.writeDoubleNoTag(stallCurrent);
}
if ((bitField0_ & 0x00000008) != 0) {
output.writeRawByte((byte) 33);
output.writeDoubleNoTag(freeCurrent);
}
if ((bitField0_ & 0x00000010) != 0) {
output.writeRawByte((byte) 41);
output.writeDoubleNoTag(freeSpeed);
}
}
@Override
protected int computeSerializedSize() {
int size = 0;
if ((bitField0_ & 0x00000001) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000002) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000004) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000008) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000010) != 0) {
size += 9;
}
return size;
}
@Override
@SuppressWarnings("fallthrough")
public ProtobufDCMotor mergeFrom(final ProtoSource input) throws IOException {
// Enabled Fall-Through Optimization (QuickBuffers)
int tag = input.readTag();
while (true) {
switch (tag) {
case 9: {
// nominalVoltage
nominalVoltage = input.readDouble();
bitField0_ |= 0x00000001;
tag = input.readTag();
if (tag != 17) {
break;
}
}
case 17: {
// stallTorque
stallTorque = input.readDouble();
bitField0_ |= 0x00000002;
tag = input.readTag();
if (tag != 25) {
break;
}
}
case 25: {
// stallCurrent
stallCurrent = input.readDouble();
bitField0_ |= 0x00000004;
tag = input.readTag();
if (tag != 33) {
break;
}
}
case 33: {
// freeCurrent
freeCurrent = input.readDouble();
bitField0_ |= 0x00000008;
tag = input.readTag();
if (tag != 41) {
break;
}
}
case 41: {
// freeSpeed
freeSpeed = input.readDouble();
bitField0_ |= 0x00000010;
tag = input.readTag();
if (tag != 0) {
break;
}
}
case 0: {
return this;
}
default: {
if (!input.skipField(tag)) {
return this;
}
tag = input.readTag();
break;
}
}
}
}
@Override
public void writeTo(final JsonSink output) throws IOException {
output.beginObject();
if ((bitField0_ & 0x00000001) != 0) {
output.writeDouble(FieldNames.nominalVoltage, nominalVoltage);
}
if ((bitField0_ & 0x00000002) != 0) {
output.writeDouble(FieldNames.stallTorque, stallTorque);
}
if ((bitField0_ & 0x00000004) != 0) {
output.writeDouble(FieldNames.stallCurrent, stallCurrent);
}
if ((bitField0_ & 0x00000008) != 0) {
output.writeDouble(FieldNames.freeCurrent, freeCurrent);
}
if ((bitField0_ & 0x00000010) != 0) {
output.writeDouble(FieldNames.freeSpeed, freeSpeed);
}
output.endObject();
}
@Override
public ProtobufDCMotor mergeFrom(final JsonSource input) throws IOException {
if (!input.beginObject()) {
return this;
}
while (!input.isAtEnd()) {
switch (input.readFieldHash()) {
case 1374862050:
case 173092603: {
if (input.isAtField(FieldNames.nominalVoltage)) {
if (!input.trySkipNullValue()) {
nominalVoltage = input.readDouble();
bitField0_ |= 0x00000001;
}
} else {
input.skipUnknownField();
}
break;
}
case 2075810250:
case 1238615945: {
if (input.isAtField(FieldNames.stallTorque)) {
if (!input.trySkipNullValue()) {
stallTorque = input.readDouble();
bitField0_ |= 0x00000002;
}
} else {
input.skipUnknownField();
}
break;
}
case -2105262663:
case 2006484954: {
if (input.isAtField(FieldNames.stallCurrent)) {
if (!input.trySkipNullValue()) {
stallCurrent = input.readDouble();
bitField0_ |= 0x00000004;
}
} else {
input.skipUnknownField();
}
break;
}
case 1024355693:
case 240406182: {
if (input.isAtField(FieldNames.freeCurrent)) {
if (!input.trySkipNullValue()) {
freeCurrent = input.readDouble();
bitField0_ |= 0x00000008;
}
} else {
input.skipUnknownField();
}
break;
}
case -444654277:
case -552732492: {
if (input.isAtField(FieldNames.freeSpeed)) {
if (!input.trySkipNullValue()) {
freeSpeed = input.readDouble();
bitField0_ |= 0x00000010;
}
} else {
input.skipUnknownField();
}
break;
}
default: {
input.skipUnknownField();
break;
}
}
}
input.endObject();
return this;
}
@Override
public ProtobufDCMotor clone() {
return new ProtobufDCMotor().copyFrom(this);
}
@Override
public boolean isEmpty() {
return ((bitField0_) == 0);
}
public static ProtobufDCMotor parseFrom(final byte[] data) throws
InvalidProtocolBufferException {
return ProtoMessage.mergeFrom(new ProtobufDCMotor(), data).checkInitialized();
}
public static ProtobufDCMotor parseFrom(final ProtoSource input) throws IOException {
return ProtoMessage.mergeFrom(new ProtobufDCMotor(), input).checkInitialized();
}
public static ProtobufDCMotor parseFrom(final JsonSource input) throws IOException {
return ProtoMessage.mergeFrom(new ProtobufDCMotor(), input).checkInitialized();
}
/**
* @return factory for creating ProtobufDCMotor messages
*/
public static MessageFactory<ProtobufDCMotor> getFactory() {
return ProtobufDCMotorFactory.INSTANCE;
}
/**
* @return this type's descriptor.
*/
public static Descriptors.Descriptor getDescriptor() {
return Plant.wpi_proto_ProtobufDCMotor_descriptor;
}
private enum ProtobufDCMotorFactory implements MessageFactory<ProtobufDCMotor> {
INSTANCE;
@Override
public ProtobufDCMotor create() {
return ProtobufDCMotor.newInstance();
}
}
/**
* Contains name constants used for serializing JSON
*/
static class FieldNames {
static final FieldName nominalVoltage = FieldName.forField("nominalVoltage", "nominal_voltage");
static final FieldName stallTorque = FieldName.forField("stallTorque", "stall_torque");
static final FieldName stallCurrent = FieldName.forField("stallCurrent", "stall_current");
static final FieldName freeCurrent = FieldName.forField("freeCurrent", "free_current");
static final FieldName freeSpeed = FieldName.forField("freeSpeed", "free_speed");
}
}
}

620
wpimath/src/generated/main/java/org/wpilib/math/proto/System.java generated
View File

@@ -18,25 +18,36 @@ import us.hebi.quickbuf.ProtoUtil;
import us.hebi.quickbuf.RepeatedByte;
public final class System {
private static final RepeatedByte descriptorData = ProtoUtil.decodeBase64(829,
"CgxzeXN0ZW0ucHJvdG8SCXdwaS5wcm90bxoNd3BpbWF0aC5wcm90byKZAgoUUHJvdG9idWZMaW5lYXJT" +
"eXN0ZW0SHQoKbnVtX3N0YXRlcxgBIAEoDVIJbnVtU3RhdGVzEh0KCm51bV9pbnB1dHMYAiABKA1SCW51" +
"bUlucHV0cxIfCgtudW1fb3V0cHV0cxgDIAEoDVIKbnVtT3V0cHV0cxInCgFhGAQgASgLMhkud3BpLnBy" +
"b3RvLlByb3RvYnVmTWF0cml4UgFhEicKAWIYBSABKAsyGS53cGkucHJvdG8uUHJvdG9idWZNYXRyaXhS" +
"AWISJwoBYxgGIAEoCzIZLndwaS5wcm90by5Qcm90b2J1Zk1hdHJpeFIBYxInCgFkGAcgASgLMhkud3Bp" +
"LnByb3RvLlByb3RvYnVmTWF0cml4UgFkQhcKFW9yZy53cGlsaWIubWF0aC5wcm90b0rVAwoGEgQAABAB" +
"CggKAQwSAwAAEgoICgECEgMCABIKCQoCAwASAwQAFwoICgEIEgMGAC4KCQoCCAESAwYALgoKCgIEABIE" +
"CAAQAQoKCgMEAAESAwgIHAoLCgQEAAIAEgMJAhgKDAoFBAACAAUSAwkCCAoMCgUEAAIAARIDCQkTCgwK" +
"BQQAAgADEgMJFhcKCwoEBAACARIDCgIYCgwKBQQAAgEFEgMKAggKDAoFBAACAQESAwoJEwoMCgUEAAIB" +
"AxIDChYXCgsKBAQAAgISAwsCGQoMCgUEAAICBRIDCwIICgwKBQQAAgIBEgMLCRQKDAoFBAACAgMSAwsX" +
"GAoLCgQEAAIDEgMMAhcKDAoFBAACAwYSAwwCEAoMCgUEAAIDARIDDBESCgwKBQQAAgMDEgMMFRYKCwoE" +
"BAACBBIDDQIXCgwKBQQAAgQGEgMNAhAKDAoFBAACBAESAw0REgoMCgUEAAIEAxIDDRUWCgsKBAQAAgUS" +
"Aw4CFwoMCgUEAAIFBhIDDgIQCgwKBQQAAgUBEgMOERIKDAoFBAACBQMSAw4VFgoLCgQEAAIGEgMPAhcK" +
"DAoFBAACBgYSAw8CEAoMCgUEAAIGARIDDxESCgwKBQQAAgYDEgMPFRZiBnByb3RvMw==");
private static final RepeatedByte descriptorData = ProtoUtil.decodeBase64(1327,
"CgxzeXN0ZW0ucHJvdG8SCXdwaS5wcm90bxoNd3BpbWF0aC5wcm90byLEAQoPUHJvdG9idWZEQ01vdG9y" +
"EicKD25vbWluYWxfdm9sdGFnZRgBIAEoAVIObm9taW5hbFZvbHRhZ2USIQoMc3RhbGxfdG9ycXVlGAIg" +
"ASgBUgtzdGFsbFRvcnF1ZRIjCg1zdGFsbF9jdXJyZW50GAMgASgBUgxzdGFsbEN1cnJlbnQSIQoMZnJl" +
"ZV9jdXJyZW50GAQgASgBUgtmcmVlQ3VycmVudBIdCgpmcmVlX3NwZWVkGAUgASgBUglmcmVlU3BlZWQi" +
"mQIKFFByb3RvYnVmTGluZWFyU3lzdGVtEh0KCm51bV9zdGF0ZXMYASABKA1SCW51bVN0YXRlcxIdCgpu" +
"dW1faW5wdXRzGAIgASgNUgludW1JbnB1dHMSHwoLbnVtX291dHB1dHMYAyABKA1SCm51bU91dHB1dHMS" +
"JwoBYRgEIAEoCzIZLndwaS5wcm90by5Qcm90b2J1Zk1hdHJpeFIBYRInCgFiGAUgASgLMhkud3BpLnBy" +
"b3RvLlByb3RvYnVmTWF0cml4UgFiEicKAWMYBiABKAsyGS53cGkucHJvdG8uUHJvdG9idWZNYXRyaXhS" +
"AWMSJwoBZBgHIAEoCzIZLndwaS5wcm90by5Qcm90b2J1Zk1hdHJpeFIBZEIXChVvcmcud3BpbGliLm1h" +
"dGgucHJvdG9KgAYKBhIEAAAYAQoICgEMEgMAABIKCAoBAhIDAgASCgkKAgMAEgMEABcKCAoBCBIDBgAu" +
"CgkKAggBEgMGAC4KCgoCBAASBAgADgEKCgoDBAABEgMICBcKCwoEBAACABIDCQIdCgwKBQQAAgAFEgMJ" +
"AggKDAoFBAACAAESAwkJGAoMCgUEAAIAAxIDCRscCgsKBAQAAgESAwoCGgoMCgUEAAIBBRIDCgIICgwK" +
"BQQAAgEBEgMKCRUKDAoFBAACAQMSAwoYGQoLCgQEAAICEgMLAhsKDAoFBAACAgUSAwsCCAoMCgUEAAIC" +
"ARIDCwkWCgwKBQQAAgIDEgMLGRoKCwoEBAACAxIDDAIaCgwKBQQAAgMFEgMMAggKDAoFBAACAwESAwwJ" +
"FQoMCgUEAAIDAxIDDBgZCgsKBAQAAgQSAw0CGAoMCgUEAAIEBRIDDQIICgwKBQQAAgQBEgMNCRMKDAoF" +
"BAACBAMSAw0WFwoKCgIEARIEEAAYAQoKCgMEAQESAxAIHAoLCgQEAQIAEgMRAhgKDAoFBAECAAUSAxEC" +
"CAoMCgUEAQIAARIDEQkTCgwKBQQBAgADEgMRFhcKCwoEBAECARIDEgIYCgwKBQQBAgEFEgMSAggKDAoF" +
"BAECAQESAxIJEwoMCgUEAQIBAxIDEhYXCgsKBAQBAgISAxMCGQoMCgUEAQICBRIDEwIICgwKBQQBAgIB" +
"EgMTCRQKDAoFBAECAgMSAxMXGAoLCgQEAQIDEgMUAhcKDAoFBAECAwYSAxQCEAoMCgUEAQIDARIDFBES" +
"CgwKBQQBAgMDEgMUFRYKCwoEBAECBBIDFQIXCgwKBQQBAgQGEgMVAhAKDAoFBAECBAESAxUREgoMCgUE",
"AQIEAxIDFRUWCgsKBAQBAgUSAxYCFwoMCgUEAQIFBhIDFgIQCgwKBQQBAgUBEgMWERIKDAoFBAECBQMS" +
"AxYVFgoLCgQEAQIGEgMXAhcKDAoFBAECBgYSAxcCEAoMCgUEAQIGARIDFxESCgwKBQQBAgYDEgMXFRZi" +
"BnByb3RvMw==");
static final Descriptors.FileDescriptor descriptor = Descriptors.FileDescriptor.internalBuildGeneratedFileFrom("system.proto", "wpi.proto", descriptorData, Wpimath.getDescriptor());
static final Descriptors.Descriptor wpi_proto_ProtobufLinearSystem_descriptor = descriptor.internalContainedType(43, 281, "ProtobufLinearSystem", "wpi.proto.ProtobufLinearSystem");
static final Descriptors.Descriptor wpi_proto_ProtobufDCMotor_descriptor = descriptor.internalContainedType(43, 196, "ProtobufDCMotor", "wpi.proto.ProtobufDCMotor");
static final Descriptors.Descriptor wpi_proto_ProtobufLinearSystem_descriptor = descriptor.internalContainedType(242, 281, "ProtobufLinearSystem", "wpi.proto.ProtobufLinearSystem");
/**
* @return this proto file's descriptor.
@@ -45,6 +56,583 @@ public final class System {
return descriptor;
}
/**
* Protobuf type {@code ProtobufDCMotor}
*/
public static final class ProtobufDCMotor extends ProtoMessage<ProtobufDCMotor> implements Cloneable {
private static final long serialVersionUID = 0L;
/**
* <code>optional double nominal_voltage = 1;</code>
*/
private double nominalVoltage;
/**
* <code>optional double stall_torque = 2;</code>
*/
private double stallTorque;
/**
* <code>optional double stall_current = 3;</code>
*/
private double stallCurrent;
/**
* <code>optional double free_current = 4;</code>
*/
private double freeCurrent;
/**
* <code>optional double free_speed = 5;</code>
*/
private double freeSpeed;
private ProtobufDCMotor() {
}
/**
* @return a new empty instance of {@code ProtobufDCMotor}
*/
public static ProtobufDCMotor newInstance() {
return new ProtobufDCMotor();
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @return whether the nominalVoltage field is set
*/
public boolean hasNominalVoltage() {
return (bitField0_ & 0x00000001) != 0;
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @return this
*/
public ProtobufDCMotor clearNominalVoltage() {
bitField0_ &= ~0x00000001;
nominalVoltage = 0D;
return this;
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @return the nominalVoltage
*/
public double getNominalVoltage() {
return nominalVoltage;
}
/**
* <code>optional double nominal_voltage = 1;</code>
* @param value the nominalVoltage to set
* @return this
*/
public ProtobufDCMotor setNominalVoltage(final double value) {
bitField0_ |= 0x00000001;
nominalVoltage = value;
return this;
}
/**
* <code>optional double stall_torque = 2;</code>
* @return whether the stallTorque field is set
*/
public boolean hasStallTorque() {
return (bitField0_ & 0x00000002) != 0;
}
/**
* <code>optional double stall_torque = 2;</code>
* @return this
*/
public ProtobufDCMotor clearStallTorque() {
bitField0_ &= ~0x00000002;
stallTorque = 0D;
return this;
}
/**
* <code>optional double stall_torque = 2;</code>
* @return the stallTorque
*/
public double getStallTorque() {
return stallTorque;
}
/**
* <code>optional double stall_torque = 2;</code>
* @param value the stallTorque to set
* @return this
*/
public ProtobufDCMotor setStallTorque(final double value) {
bitField0_ |= 0x00000002;
stallTorque = value;
return this;
}
/**
* <code>optional double stall_current = 3;</code>
* @return whether the stallCurrent field is set
*/
public boolean hasStallCurrent() {
return (bitField0_ & 0x00000004) != 0;
}
/**
* <code>optional double stall_current = 3;</code>
* @return this
*/
public ProtobufDCMotor clearStallCurrent() {
bitField0_ &= ~0x00000004;
stallCurrent = 0D;
return this;
}
/**
* <code>optional double stall_current = 3;</code>
* @return the stallCurrent
*/
public double getStallCurrent() {
return stallCurrent;
}
/**
* <code>optional double stall_current = 3;</code>
* @param value the stallCurrent to set
* @return this
*/
public ProtobufDCMotor setStallCurrent(final double value) {
bitField0_ |= 0x00000004;
stallCurrent = value;
return this;
}
/**
* <code>optional double free_current = 4;</code>
* @return whether the freeCurrent field is set
*/
public boolean hasFreeCurrent() {
return (bitField0_ & 0x00000008) != 0;
}
/**
* <code>optional double free_current = 4;</code>
* @return this
*/
public ProtobufDCMotor clearFreeCurrent() {
bitField0_ &= ~0x00000008;
freeCurrent = 0D;
return this;
}
/**
* <code>optional double free_current = 4;</code>
* @return the freeCurrent
*/
public double getFreeCurrent() {
return freeCurrent;
}
/**
* <code>optional double free_current = 4;</code>
* @param value the freeCurrent to set
* @return this
*/
public ProtobufDCMotor setFreeCurrent(final double value) {
bitField0_ |= 0x00000008;
freeCurrent = value;
return this;
}
/**
* <code>optional double free_speed = 5;</code>
* @return whether the freeSpeed field is set
*/
public boolean hasFreeSpeed() {
return (bitField0_ & 0x00000010) != 0;
}
/**
* <code>optional double free_speed = 5;</code>
* @return this
*/
public ProtobufDCMotor clearFreeSpeed() {
bitField0_ &= ~0x00000010;
freeSpeed = 0D;
return this;
}
/**
* <code>optional double free_speed = 5;</code>
* @return the freeSpeed
*/
public double getFreeSpeed() {
return freeSpeed;
}
/**
* <code>optional double free_speed = 5;</code>
* @param value the freeSpeed to set
* @return this
*/
public ProtobufDCMotor setFreeSpeed(final double value) {
bitField0_ |= 0x00000010;
freeSpeed = value;
return this;
}
@Override
public ProtobufDCMotor copyFrom(final ProtobufDCMotor other) {
cachedSize = other.cachedSize;
if ((bitField0_ | other.bitField0_) != 0) {
bitField0_ = other.bitField0_;
nominalVoltage = other.nominalVoltage;
stallTorque = other.stallTorque;
stallCurrent = other.stallCurrent;
freeCurrent = other.freeCurrent;
freeSpeed = other.freeSpeed;
}
return this;
}
@Override
public ProtobufDCMotor mergeFrom(final ProtobufDCMotor other) {
if (other.isEmpty()) {
return this;
}
cachedSize = -1;
if (other.hasNominalVoltage()) {
setNominalVoltage(other.nominalVoltage);
}
if (other.hasStallTorque()) {
setStallTorque(other.stallTorque);
}
if (other.hasStallCurrent()) {
setStallCurrent(other.stallCurrent);
}
if (other.hasFreeCurrent()) {
setFreeCurrent(other.freeCurrent);
}
if (other.hasFreeSpeed()) {
setFreeSpeed(other.freeSpeed);
}
return this;
}
@Override
public ProtobufDCMotor clear() {
if (isEmpty()) {
return this;
}
cachedSize = -1;
bitField0_ = 0;
nominalVoltage = 0D;
stallTorque = 0D;
stallCurrent = 0D;
freeCurrent = 0D;
freeSpeed = 0D;
return this;
}
@Override
public ProtobufDCMotor clearQuick() {
if (isEmpty()) {
return this;
}
cachedSize = -1;
bitField0_ = 0;
return this;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof ProtobufDCMotor)) {
return false;
}
ProtobufDCMotor other = (ProtobufDCMotor) o;
return bitField0_ == other.bitField0_
&& (!hasNominalVoltage() || ProtoUtil.isEqual(nominalVoltage, other.nominalVoltage))
&& (!hasStallTorque() || ProtoUtil.isEqual(stallTorque, other.stallTorque))
&& (!hasStallCurrent() || ProtoUtil.isEqual(stallCurrent, other.stallCurrent))
&& (!hasFreeCurrent() || ProtoUtil.isEqual(freeCurrent, other.freeCurrent))
&& (!hasFreeSpeed() || ProtoUtil.isEqual(freeSpeed, other.freeSpeed));
}
@Override
public void writeTo(final ProtoSink output) throws IOException {
if ((bitField0_ & 0x00000001) != 0) {
output.writeRawByte((byte) 9);
output.writeDoubleNoTag(nominalVoltage);
}
if ((bitField0_ & 0x00000002) != 0) {
output.writeRawByte((byte) 17);
output.writeDoubleNoTag(stallTorque);
}
if ((bitField0_ & 0x00000004) != 0) {
output.writeRawByte((byte) 25);
output.writeDoubleNoTag(stallCurrent);
}
if ((bitField0_ & 0x00000008) != 0) {
output.writeRawByte((byte) 33);
output.writeDoubleNoTag(freeCurrent);
}
if ((bitField0_ & 0x00000010) != 0) {
output.writeRawByte((byte) 41);
output.writeDoubleNoTag(freeSpeed);
}
}
@Override
protected int computeSerializedSize() {
int size = 0;
if ((bitField0_ & 0x00000001) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000002) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000004) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000008) != 0) {
size += 9;
}
if ((bitField0_ & 0x00000010) != 0) {
size += 9;
}
return size;
}
@Override
@SuppressWarnings("fallthrough")
public ProtobufDCMotor mergeFrom(final ProtoSource input) throws IOException {
// Enabled Fall-Through Optimization (QuickBuffers)
int tag = input.readTag();
while (true) {
switch (tag) {
case 9: {
// nominalVoltage
nominalVoltage = input.readDouble();
bitField0_ |= 0x00000001;
tag = input.readTag();
if (tag != 17) {
break;
}
}
case 17: {
// stallTorque
stallTorque = input.readDouble();
bitField0_ |= 0x00000002;
tag = input.readTag();
if (tag != 25) {
break;
}
}
case 25: {
// stallCurrent
stallCurrent = input.readDouble();
bitField0_ |= 0x00000004;
tag = input.readTag();
if (tag != 33) {
break;
}
}
case 33: {
// freeCurrent
freeCurrent = input.readDouble();
bitField0_ |= 0x00000008;
tag = input.readTag();
if (tag != 41) {
break;
}
}
case 41: {
// freeSpeed
freeSpeed = input.readDouble();
bitField0_ |= 0x00000010;
tag = input.readTag();
if (tag != 0) {
break;
}
}
case 0: {
return this;
}
default: {
if (!input.skipField(tag)) {
return this;
}
tag = input.readTag();
break;
}
}
}
}
@Override
public void writeTo(final JsonSink output) throws IOException {
output.beginObject();
if ((bitField0_ & 0x00000001) != 0) {
output.writeDouble(FieldNames.nominalVoltage, nominalVoltage);
}
if ((bitField0_ & 0x00000002) != 0) {
output.writeDouble(FieldNames.stallTorque, stallTorque);
}
if ((bitField0_ & 0x00000004) != 0) {
output.writeDouble(FieldNames.stallCurrent, stallCurrent);
}
if ((bitField0_ & 0x00000008) != 0) {
output.writeDouble(FieldNames.freeCurrent, freeCurrent);
}
if ((bitField0_ & 0x00000010) != 0) {
output.writeDouble(FieldNames.freeSpeed, freeSpeed);
}
output.endObject();
}
@Override
public ProtobufDCMotor mergeFrom(final JsonSource input) throws IOException {
if (!input.beginObject()) {
return this;
}
while (!input.isAtEnd()) {
switch (input.readFieldHash()) {
case 1374862050:
case 173092603: {
if (input.isAtField(FieldNames.nominalVoltage)) {
if (!input.trySkipNullValue()) {
nominalVoltage = input.readDouble();
bitField0_ |= 0x00000001;
}
} else {
input.skipUnknownField();
}
break;
}
case 2075810250:
case 1238615945: {
if (input.isAtField(FieldNames.stallTorque)) {
if (!input.trySkipNullValue()) {
stallTorque = input.readDouble();
bitField0_ |= 0x00000002;
}
} else {
input.skipUnknownField();
}
break;
}
case -2105262663:
case 2006484954: {
if (input.isAtField(FieldNames.stallCurrent)) {
if (!input.trySkipNullValue()) {
stallCurrent = input.readDouble();
bitField0_ |= 0x00000004;
}
} else {
input.skipUnknownField();
}
break;
}
case 1024355693:
case 240406182: {
if (input.isAtField(FieldNames.freeCurrent)) {
if (!input.trySkipNullValue()) {
freeCurrent = input.readDouble();
bitField0_ |= 0x00000008;
}
} else {
input.skipUnknownField();
}
break;
}
case -444654277:
case -552732492: {
if (input.isAtField(FieldNames.freeSpeed)) {
if (!input.trySkipNullValue()) {
freeSpeed = input.readDouble();
bitField0_ |= 0x00000010;
}
} else {
input.skipUnknownField();
}
break;
}
default: {
input.skipUnknownField();
break;
}
}
}
input.endObject();
return this;
}
@Override
public ProtobufDCMotor clone() {
return new ProtobufDCMotor().copyFrom(this);
}
@Override
public boolean isEmpty() {
return ((bitField0_) == 0);
}
public static ProtobufDCMotor parseFrom(final byte[] data) throws
InvalidProtocolBufferException {
return ProtoMessage.mergeFrom(new ProtobufDCMotor(), data).checkInitialized();
}
public static ProtobufDCMotor parseFrom(final ProtoSource input) throws IOException {
return ProtoMessage.mergeFrom(new ProtobufDCMotor(), input).checkInitialized();
}
public static ProtobufDCMotor parseFrom(final JsonSource input) throws IOException {
return ProtoMessage.mergeFrom(new ProtobufDCMotor(), input).checkInitialized();
}
/**
* @return factory for creating ProtobufDCMotor messages
*/
public static MessageFactory<ProtobufDCMotor> getFactory() {
return ProtobufDCMotorFactory.INSTANCE;
}
/**
* @return this type's descriptor.
*/
public static Descriptors.Descriptor getDescriptor() {
return System.wpi_proto_ProtobufDCMotor_descriptor;
}
private enum ProtobufDCMotorFactory implements MessageFactory<ProtobufDCMotor> {
INSTANCE;
@Override
public ProtobufDCMotor create() {
return ProtobufDCMotor.newInstance();
}
}
/**
* Contains name constants used for serializing JSON
*/
static class FieldNames {
static final FieldName nominalVoltage = FieldName.forField("nominalVoltage", "nominal_voltage");
static final FieldName stallTorque = FieldName.forField("stallTorque", "stall_torque");
static final FieldName stallCurrent = FieldName.forField("stallCurrent", "stall_current");
static final FieldName freeCurrent = FieldName.forField("freeCurrent", "free_current");
static final FieldName freeSpeed = FieldName.forField("freeSpeed", "free_speed");
}
}
/**
* Protobuf type {@code ProtobufLinearSystem}
*/

92
wpimath/src/generated/main/native/cpp/wpimath/protobuf/plant.npb.cpp generated
View File

@@ -1,92 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
/* Automatically generated nanopb constant definitions */
/* Generated by nanopb-0.4.9 */
#include "plant.npb.h"
#if PB_PROTO_HEADER_VERSION != 40
#error Regenerate this file with the current version of nanopb generator.
#endif
#include <span>
#include <string_view>
static const uint8_t file_descriptor[] {
0x0a,0x0b,0x70,0x6c,0x61,0x6e,0x74,0x2e,0x70,0x72,
0x6f,0x74,0x6f,0x12,0x09,0x77,0x70,0x69,0x2e,0x70,
0x72,0x6f,0x74,0x6f,0x22,0xc4,0x01,0x0a,0x0f,0x50,
0x72,0x6f,0x74,0x6f,0x62,0x75,0x66,0x44,0x43,0x4d,
0x6f,0x74,0x6f,0x72,0x12,0x27,0x0a,0x0f,0x6e,0x6f,
0x6d,0x69,0x6e,0x61,0x6c,0x5f,0x76,0x6f,0x6c,0x74,
0x61,0x67,0x65,0x18,0x01,0x20,0x01,0x28,0x01,0x52,
0x0e,0x6e,0x6f,0x6d,0x69,0x6e,0x61,0x6c,0x56,0x6f,
0x6c,0x74,0x61,0x67,0x65,0x12,0x21,0x0a,0x0c,0x73,
0x74,0x61,0x6c,0x6c,0x5f,0x74,0x6f,0x72,0x71,0x75,
0x65,0x18,0x02,0x20,0x01,0x28,0x01,0x52,0x0b,0x73,
0x74,0x61,0x6c,0x6c,0x54,0x6f,0x72,0x71,0x75,0x65,
0x12,0x23,0x0a,0x0d,0x73,0x74,0x61,0x6c,0x6c,0x5f,
0x63,0x75,0x72,0x72,0x65,0x6e,0x74,0x18,0x03,0x20,
0x01,0x28,0x01,0x52,0x0c,0x73,0x74,0x61,0x6c,0x6c,
0x43,0x75,0x72,0x72,0x65,0x6e,0x74,0x12,0x21,0x0a,
0x0c,0x66,0x72,0x65,0x65,0x5f,0x63,0x75,0x72,0x72,
0x65,0x6e,0x74,0x18,0x04,0x20,0x01,0x28,0x01,0x52,
0x0b,0x66,0x72,0x65,0x65,0x43,0x75,0x72,0x72,0x65,
0x6e,0x74,0x12,0x1d,0x0a,0x0a,0x66,0x72,0x65,0x65,
0x5f,0x73,0x70,0x65,0x65,0x64,0x18,0x05,0x20,0x01,
0x28,0x01,0x52,0x09,0x66,0x72,0x65,0x65,0x53,0x70,
0x65,0x65,0x64,0x42,0x17,0x0a,0x15,0x6f,0x72,0x67,
0x2e,0x77,0x70,0x69,0x6c,0x69,0x62,0x2e,0x6d,0x61,
0x74,0x68,0x2e,0x70,0x72,0x6f,0x74,0x6f,0x4a,0xdc,
0x02,0x0a,0x06,0x12,0x04,0x00,0x00,0x0c,0x01,0x0a,
0x08,0x0a,0x01,0x0c,0x12,0x03,0x00,0x00,0x12,0x0a,
0x08,0x0a,0x01,0x02,0x12,0x03,0x02,0x00,0x12,0x0a,
0x08,0x0a,0x01,0x08,0x12,0x03,0x04,0x00,0x2e,0x0a,
0x09,0x0a,0x02,0x08,0x01,0x12,0x03,0x04,0x00,0x2e,
0x0a,0x0a,0x0a,0x02,0x04,0x00,0x12,0x04,0x06,0x00,
0x0c,0x01,0x0a,0x0a,0x0a,0x03,0x04,0x00,0x01,0x12,
0x03,0x06,0x08,0x17,0x0a,0x0b,0x0a,0x04,0x04,0x00,
0x02,0x00,0x12,0x03,0x07,0x02,0x1d,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x00,0x05,0x12,0x03,0x07,0x02,
0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x00,0x01,
0x12,0x03,0x07,0x09,0x18,0x0a,0x0c,0x0a,0x05,0x04,
0x00,0x02,0x00,0x03,0x12,0x03,0x07,0x1b,0x1c,0x0a,
0x0b,0x0a,0x04,0x04,0x00,0x02,0x01,0x12,0x03,0x08,
0x02,0x1a,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x01,
0x05,0x12,0x03,0x08,0x02,0x08,0x0a,0x0c,0x0a,0x05,
0x04,0x00,0x02,0x01,0x01,0x12,0x03,0x08,0x09,0x15,
0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x01,0x03,0x12,
0x03,0x08,0x18,0x19,0x0a,0x0b,0x0a,0x04,0x04,0x00,
0x02,0x02,0x12,0x03,0x09,0x02,0x1b,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x02,0x05,0x12,0x03,0x09,0x02,
0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x02,0x01,
0x12,0x03,0x09,0x09,0x16,0x0a,0x0c,0x0a,0x05,0x04,
0x00,0x02,0x02,0x03,0x12,0x03,0x09,0x19,0x1a,0x0a,
0x0b,0x0a,0x04,0x04,0x00,0x02,0x03,0x12,0x03,0x0a,
0x02,0x1a,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x03,
0x05,0x12,0x03,0x0a,0x02,0x08,0x0a,0x0c,0x0a,0x05,
0x04,0x00,0x02,0x03,0x01,0x12,0x03,0x0a,0x09,0x15,
0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x03,0x03,0x12,
0x03,0x0a,0x18,0x19,0x0a,0x0b,0x0a,0x04,0x04,0x00,
0x02,0x04,0x12,0x03,0x0b,0x02,0x18,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x04,0x05,0x12,0x03,0x0b,0x02,
0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x04,0x01,
0x12,0x03,0x0b,0x09,0x13,0x0a,0x0c,0x0a,0x05,0x04,
0x00,0x02,0x04,0x03,0x12,0x03,0x0b,0x16,0x17,0x62,
0x06,0x70,0x72,0x6f,0x74,0x6f,0x33,
};
static const char file_name[] = "plant.proto";
static const char wpi_proto_ProtobufDCMotor_name[] = "wpi.proto.ProtobufDCMotor";
std::string_view wpi_proto_ProtobufDCMotor::msg_name(void) noexcept { return wpi_proto_ProtobufDCMotor_name; }
pb_filedesc_t wpi_proto_ProtobufDCMotor::file_descriptor(void) noexcept { return {::file_name, ::file_descriptor}; }
PB_BIND(wpi_proto_ProtobufDCMotor, wpi_proto_ProtobufDCMotor, AUTO)
#ifndef PB_CONVERT_DOUBLE_FLOAT
/* On some platforms (such as AVR), double is really float.
* To be able to encode/decode double on these platforms, you need.
* to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
*/
PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
#endif

57
wpimath/src/generated/main/native/cpp/wpimath/protobuf/plant.npb.h generated
View File

@@ -1,57 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
/* Automatically generated nanopb header */
/* Generated by nanopb-0.4.9 */
#ifndef PB_WPI_PROTO_PLANT_NPB_H_INCLUDED
#define PB_WPI_PROTO_PLANT_NPB_H_INCLUDED
#include <pb.h>
#include <span>
#include <string_view>
#if PB_PROTO_HEADER_VERSION != 40
#error Regenerate this file with the current version of nanopb generator.
#endif
/* Struct definitions */
typedef struct _wpi_proto_ProtobufDCMotor {
static const pb_msgdesc_t* msg_descriptor(void) noexcept;
static std::string_view msg_name(void) noexcept;
static pb_filedesc_t file_descriptor(void) noexcept;
double nominal_voltage;
double stall_torque;
double stall_current;
double free_current;
double free_speed;
} wpi_proto_ProtobufDCMotor;
/* Initializer values for message structs */
#define wpi_proto_ProtobufDCMotor_init_default {0, 0, 0, 0, 0}
#define wpi_proto_ProtobufDCMotor_init_zero {0, 0, 0, 0, 0}
/* Field tags (for use in manual encoding/decoding) */
#define wpi_proto_ProtobufDCMotor_nominal_voltage_tag 1
#define wpi_proto_ProtobufDCMotor_stall_torque_tag 2
#define wpi_proto_ProtobufDCMotor_stall_current_tag 3
#define wpi_proto_ProtobufDCMotor_free_current_tag 4
#define wpi_proto_ProtobufDCMotor_free_speed_tag 5
/* Struct field encoding specification for nanopb */
#define wpi_proto_ProtobufDCMotor_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, DOUBLE, nominal_voltage, 1) \
X(a, STATIC, SINGULAR, DOUBLE, stall_torque, 2) \
X(a, STATIC, SINGULAR, DOUBLE, stall_current, 3) \
X(a, STATIC, SINGULAR, DOUBLE, free_current, 4) \
X(a, STATIC, SINGULAR, DOUBLE, free_speed, 5)
#define wpi_proto_ProtobufDCMotor_CALLBACK NULL
#define wpi_proto_ProtobufDCMotor_DEFAULT NULL
/* Maximum encoded size of messages (where known) */
#define WPI_PROTO_PLANT_NPB_H_MAX_SIZE wpi_proto_ProtobufDCMotor_size
#define wpi_proto_ProtobufDCMotor_size 45
#endif

204
wpimath/src/generated/main/native/cpp/wpimath/protobuf/system.npb.cpp generated
View File

@@ -16,87 +16,143 @@ static const uint8_t file_descriptor[] {
0x72,0x6f,0x74,0x6f,0x12,0x09,0x77,0x70,0x69,0x2e,
0x70,0x72,0x6f,0x74,0x6f,0x1a,0x0d,0x77,0x70,0x69,
0x6d,0x61,0x74,0x68,0x2e,0x70,0x72,0x6f,0x74,0x6f,
0x22,0x99,0x02,0x0a,0x14,0x50,0x72,0x6f,0x74,0x6f,
0x62,0x75,0x66,0x4c,0x69,0x6e,0x65,0x61,0x72,0x53,
0x79,0x73,0x74,0x65,0x6d,0x12,0x1d,0x0a,0x0a,0x6e,
0x75,0x6d,0x5f,0x73,0x74,0x61,0x74,0x65,0x73,0x18,
0x01,0x20,0x01,0x28,0x0d,0x52,0x09,0x6e,0x75,0x6d,
0x53,0x74,0x61,0x74,0x65,0x73,0x12,0x1d,0x0a,0x0a,
0x6e,0x75,0x6d,0x5f,0x69,0x6e,0x70,0x75,0x74,0x73,
0x18,0x02,0x20,0x01,0x28,0x0d,0x52,0x09,0x6e,0x75,
0x6d,0x49,0x6e,0x70,0x75,0x74,0x73,0x12,0x1f,0x0a,
0x0b,0x6e,0x75,0x6d,0x5f,0x6f,0x75,0x74,0x70,0x75,
0x74,0x73,0x18,0x03,0x20,0x01,0x28,0x0d,0x52,0x0a,
0x6e,0x75,0x6d,0x4f,0x75,0x74,0x70,0x75,0x74,0x73,
0x12,0x27,0x0a,0x01,0x61,0x18,0x04,0x20,0x01,0x28,
0x22,0xc4,0x01,0x0a,0x0f,0x50,0x72,0x6f,0x74,0x6f,
0x62,0x75,0x66,0x44,0x43,0x4d,0x6f,0x74,0x6f,0x72,
0x12,0x27,0x0a,0x0f,0x6e,0x6f,0x6d,0x69,0x6e,0x61,
0x6c,0x5f,0x76,0x6f,0x6c,0x74,0x61,0x67,0x65,0x18,
0x01,0x20,0x01,0x28,0x01,0x52,0x0e,0x6e,0x6f,0x6d,
0x69,0x6e,0x61,0x6c,0x56,0x6f,0x6c,0x74,0x61,0x67,
0x65,0x12,0x21,0x0a,0x0c,0x73,0x74,0x61,0x6c,0x6c,
0x5f,0x74,0x6f,0x72,0x71,0x75,0x65,0x18,0x02,0x20,
0x01,0x28,0x01,0x52,0x0b,0x73,0x74,0x61,0x6c,0x6c,
0x54,0x6f,0x72,0x71,0x75,0x65,0x12,0x23,0x0a,0x0d,
0x73,0x74,0x61,0x6c,0x6c,0x5f,0x63,0x75,0x72,0x72,
0x65,0x6e,0x74,0x18,0x03,0x20,0x01,0x28,0x01,0x52,
0x0c,0x73,0x74,0x61,0x6c,0x6c,0x43,0x75,0x72,0x72,
0x65,0x6e,0x74,0x12,0x21,0x0a,0x0c,0x66,0x72,0x65,
0x65,0x5f,0x63,0x75,0x72,0x72,0x65,0x6e,0x74,0x18,
0x04,0x20,0x01,0x28,0x01,0x52,0x0b,0x66,0x72,0x65,
0x65,0x43,0x75,0x72,0x72,0x65,0x6e,0x74,0x12,0x1d,
0x0a,0x0a,0x66,0x72,0x65,0x65,0x5f,0x73,0x70,0x65,
0x65,0x64,0x18,0x05,0x20,0x01,0x28,0x01,0x52,0x09,
0x66,0x72,0x65,0x65,0x53,0x70,0x65,0x65,0x64,0x22,
0x99,0x02,0x0a,0x14,0x50,0x72,0x6f,0x74,0x6f,0x62,
0x75,0x66,0x4c,0x69,0x6e,0x65,0x61,0x72,0x53,0x79,
0x73,0x74,0x65,0x6d,0x12,0x1d,0x0a,0x0a,0x6e,0x75,
0x6d,0x5f,0x73,0x74,0x61,0x74,0x65,0x73,0x18,0x01,
0x20,0x01,0x28,0x0d,0x52,0x09,0x6e,0x75,0x6d,0x53,
0x74,0x61,0x74,0x65,0x73,0x12,0x1d,0x0a,0x0a,0x6e,
0x75,0x6d,0x5f,0x69,0x6e,0x70,0x75,0x74,0x73,0x18,
0x02,0x20,0x01,0x28,0x0d,0x52,0x09,0x6e,0x75,0x6d,
0x49,0x6e,0x70,0x75,0x74,0x73,0x12,0x1f,0x0a,0x0b,
0x6e,0x75,0x6d,0x5f,0x6f,0x75,0x74,0x70,0x75,0x74,
0x73,0x18,0x03,0x20,0x01,0x28,0x0d,0x52,0x0a,0x6e,
0x75,0x6d,0x4f,0x75,0x74,0x70,0x75,0x74,0x73,0x12,
0x27,0x0a,0x01,0x61,0x18,0x04,0x20,0x01,0x28,0x0b,
0x32,0x19,0x2e,0x77,0x70,0x69,0x2e,0x70,0x72,0x6f,
0x74,0x6f,0x2e,0x50,0x72,0x6f,0x74,0x6f,0x62,0x75,
0x66,0x4d,0x61,0x74,0x72,0x69,0x78,0x52,0x01,0x61,
0x12,0x27,0x0a,0x01,0x62,0x18,0x05,0x20,0x01,0x28,
0x0b,0x32,0x19,0x2e,0x77,0x70,0x69,0x2e,0x70,0x72,
0x6f,0x74,0x6f,0x2e,0x50,0x72,0x6f,0x74,0x6f,0x62,
0x75,0x66,0x4d,0x61,0x74,0x72,0x69,0x78,0x52,0x01,
0x61,0x12,0x27,0x0a,0x01,0x62,0x18,0x05,0x20,0x01,
0x62,0x12,0x27,0x0a,0x01,0x63,0x18,0x06,0x20,0x01,
0x28,0x0b,0x32,0x19,0x2e,0x77,0x70,0x69,0x2e,0x70,
0x72,0x6f,0x74,0x6f,0x2e,0x50,0x72,0x6f,0x74,0x6f,
0x62,0x75,0x66,0x4d,0x61,0x74,0x72,0x69,0x78,0x52,
0x01,0x62,0x12,0x27,0x0a,0x01,0x63,0x18,0x06,0x20,
0x01,0x63,0x12,0x27,0x0a,0x01,0x64,0x18,0x07,0x20,
0x01,0x28,0x0b,0x32,0x19,0x2e,0x77,0x70,0x69,0x2e,
0x70,0x72,0x6f,0x74,0x6f,0x2e,0x50,0x72,0x6f,0x74,
0x6f,0x62,0x75,0x66,0x4d,0x61,0x74,0x72,0x69,0x78,
0x52,0x01,0x63,0x12,0x27,0x0a,0x01,0x64,0x18,0x07,
0x20,0x01,0x28,0x0b,0x32,0x19,0x2e,0x77,0x70,0x69,
0x2e,0x70,0x72,0x6f,0x74,0x6f,0x2e,0x50,0x72,0x6f,
0x74,0x6f,0x62,0x75,0x66,0x4d,0x61,0x74,0x72,0x69,
0x78,0x52,0x01,0x64,0x42,0x17,0x0a,0x15,0x6f,0x72,
0x67,0x2e,0x77,0x70,0x69,0x6c,0x69,0x62,0x2e,0x6d,
0x61,0x74,0x68,0x2e,0x70,0x72,0x6f,0x74,0x6f,0x4a,
0xd5,0x03,0x0a,0x06,0x12,0x04,0x00,0x00,0x10,0x01,
0x0a,0x08,0x0a,0x01,0x0c,0x12,0x03,0x00,0x00,0x12,
0x0a,0x08,0x0a,0x01,0x02,0x12,0x03,0x02,0x00,0x12,
0x0a,0x09,0x0a,0x02,0x03,0x00,0x12,0x03,0x04,0x00,
0x17,0x0a,0x08,0x0a,0x01,0x08,0x12,0x03,0x06,0x00,
0x2e,0x0a,0x09,0x0a,0x02,0x08,0x01,0x12,0x03,0x06,
0x00,0x2e,0x0a,0x0a,0x0a,0x02,0x04,0x00,0x12,0x04,
0x08,0x00,0x10,0x01,0x0a,0x0a,0x0a,0x03,0x04,0x00,
0x01,0x12,0x03,0x08,0x08,0x1c,0x0a,0x0b,0x0a,0x04,
0x04,0x00,0x02,0x00,0x12,0x03,0x09,0x02,0x18,0x0a,
0x0c,0x0a,0x05,0x04,0x00,0x02,0x00,0x05,0x12,0x03,
0x09,0x02,0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,
0x00,0x01,0x12,0x03,0x09,0x09,0x13,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x00,0x03,0x12,0x03,0x09,0x16,
0x17,0x0a,0x0b,0x0a,0x04,0x04,0x00,0x02,0x01,0x12,
0x03,0x0a,0x02,0x18,0x0a,0x0c,0x0a,0x05,0x04,0x00,
0x02,0x01,0x05,0x12,0x03,0x0a,0x02,0x08,0x0a,0x0c,
0x0a,0x05,0x04,0x00,0x02,0x01,0x01,0x12,0x03,0x0a,
0x09,0x13,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x01,
0x03,0x12,0x03,0x0a,0x16,0x17,0x0a,0x0b,0x0a,0x04,
0x04,0x00,0x02,0x02,0x12,0x03,0x0b,0x02,0x19,0x0a,
0x0c,0x0a,0x05,0x04,0x00,0x02,0x02,0x05,0x12,0x03,
0x0b,0x02,0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,
0x02,0x01,0x12,0x03,0x0b,0x09,0x14,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x02,0x03,0x12,0x03,0x0b,0x17,
0x18,0x0a,0x0b,0x0a,0x04,0x04,0x00,0x02,0x03,0x12,
0x03,0x0c,0x02,0x17,0x0a,0x0c,0x0a,0x05,0x04,0x00,
0x02,0x03,0x06,0x12,0x03,0x0c,0x02,0x10,0x0a,0x0c,
0x0a,0x05,0x04,0x00,0x02,0x03,0x01,0x12,0x03,0x0c,
0x11,0x12,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x03,
0x03,0x12,0x03,0x0c,0x15,0x16,0x0a,0x0b,0x0a,0x04,
0x04,0x00,0x02,0x04,0x12,0x03,0x0d,0x02,0x17,0x0a,
0x0c,0x0a,0x05,0x04,0x00,0x02,0x04,0x06,0x12,0x03,
0x0d,0x02,0x10,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,
0x04,0x01,0x12,0x03,0x0d,0x11,0x12,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x04,0x03,0x12,0x03,0x0d,0x15,
0x16,0x0a,0x0b,0x0a,0x04,0x04,0x00,0x02,0x05,0x12,
0x03,0x0e,0x02,0x17,0x0a,0x0c,0x0a,0x05,0x04,0x00,
0x02,0x05,0x06,0x12,0x03,0x0e,0x02,0x10,0x0a,0x0c,
0x0a,0x05,0x04,0x00,0x02,0x05,0x01,0x12,0x03,0x0e,
0x11,0x12,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x05,
0x03,0x12,0x03,0x0e,0x15,0x16,0x0a,0x0b,0x0a,0x04,
0x04,0x00,0x02,0x06,0x12,0x03,0x0f,0x02,0x17,0x0a,
0x0c,0x0a,0x05,0x04,0x00,0x02,0x06,0x06,0x12,0x03,
0x0f,0x02,0x10,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,
0x06,0x01,0x12,0x03,0x0f,0x11,0x12,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x06,0x03,0x12,0x03,0x0f,0x15,
0x16,0x62,0x06,0x70,0x72,0x6f,0x74,0x6f,0x33,
0x52,0x01,0x64,0x42,0x17,0x0a,0x15,0x6f,0x72,0x67,
0x2e,0x77,0x70,0x69,0x6c,0x69,0x62,0x2e,0x6d,0x61,
0x74,0x68,0x2e,0x70,0x72,0x6f,0x74,0x6f,0x4a,0x80,
0x06,0x0a,0x06,0x12,0x04,0x00,0x00,0x18,0x01,0x0a,
0x08,0x0a,0x01,0x0c,0x12,0x03,0x00,0x00,0x12,0x0a,
0x08,0x0a,0x01,0x02,0x12,0x03,0x02,0x00,0x12,0x0a,
0x09,0x0a,0x02,0x03,0x00,0x12,0x03,0x04,0x00,0x17,
0x0a,0x08,0x0a,0x01,0x08,0x12,0x03,0x06,0x00,0x2e,
0x0a,0x09,0x0a,0x02,0x08,0x01,0x12,0x03,0x06,0x00,
0x2e,0x0a,0x0a,0x0a,0x02,0x04,0x00,0x12,0x04,0x08,
0x00,0x0e,0x01,0x0a,0x0a,0x0a,0x03,0x04,0x00,0x01,
0x12,0x03,0x08,0x08,0x17,0x0a,0x0b,0x0a,0x04,0x04,
0x00,0x02,0x00,0x12,0x03,0x09,0x02,0x1d,0x0a,0x0c,
0x0a,0x05,0x04,0x00,0x02,0x00,0x05,0x12,0x03,0x09,
0x02,0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x00,
0x01,0x12,0x03,0x09,0x09,0x18,0x0a,0x0c,0x0a,0x05,
0x04,0x00,0x02,0x00,0x03,0x12,0x03,0x09,0x1b,0x1c,
0x0a,0x0b,0x0a,0x04,0x04,0x00,0x02,0x01,0x12,0x03,
0x0a,0x02,0x1a,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,
0x01,0x05,0x12,0x03,0x0a,0x02,0x08,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x01,0x01,0x12,0x03,0x0a,0x09,
0x15,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x01,0x03,
0x12,0x03,0x0a,0x18,0x19,0x0a,0x0b,0x0a,0x04,0x04,
0x00,0x02,0x02,0x12,0x03,0x0b,0x02,0x1b,0x0a,0x0c,
0x0a,0x05,0x04,0x00,0x02,0x02,0x05,0x12,0x03,0x0b,
0x02,0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x02,
0x01,0x12,0x03,0x0b,0x09,0x16,0x0a,0x0c,0x0a,0x05,
0x04,0x00,0x02,0x02,0x03,0x12,0x03,0x0b,0x19,0x1a,
0x0a,0x0b,0x0a,0x04,0x04,0x00,0x02,0x03,0x12,0x03,
0x0c,0x02,0x1a,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,
0x03,0x05,0x12,0x03,0x0c,0x02,0x08,0x0a,0x0c,0x0a,
0x05,0x04,0x00,0x02,0x03,0x01,0x12,0x03,0x0c,0x09,
0x15,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x03,0x03,
0x12,0x03,0x0c,0x18,0x19,0x0a,0x0b,0x0a,0x04,0x04,
0x00,0x02,0x04,0x12,0x03,0x0d,0x02,0x18,0x0a,0x0c,
0x0a,0x05,0x04,0x00,0x02,0x04,0x05,0x12,0x03,0x0d,
0x02,0x08,0x0a,0x0c,0x0a,0x05,0x04,0x00,0x02,0x04,
0x01,0x12,0x03,0x0d,0x09,0x13,0x0a,0x0c,0x0a,0x05,
0x04,0x00,0x02,0x04,0x03,0x12,0x03,0x0d,0x16,0x17,
0x0a,0x0a,0x0a,0x02,0x04,0x01,0x12,0x04,0x10,0x00,
0x18,0x01,0x0a,0x0a,0x0a,0x03,0x04,0x01,0x01,0x12,
0x03,0x10,0x08,0x1c,0x0a,0x0b,0x0a,0x04,0x04,0x01,
0x02,0x00,0x12,0x03,0x11,0x02,0x18,0x0a,0x0c,0x0a,
0x05,0x04,0x01,0x02,0x00,0x05,0x12,0x03,0x11,0x02,
0x08,0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x00,0x01,
0x12,0x03,0x11,0x09,0x13,0x0a,0x0c,0x0a,0x05,0x04,
0x01,0x02,0x00,0x03,0x12,0x03,0x11,0x16,0x17,0x0a,
0x0b,0x0a,0x04,0x04,0x01,0x02,0x01,0x12,0x03,0x12,
0x02,0x18,0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x01,
0x05,0x12,0x03,0x12,0x02,0x08,0x0a,0x0c,0x0a,0x05,
0x04,0x01,0x02,0x01,0x01,0x12,0x03,0x12,0x09,0x13,
0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x01,0x03,0x12,
0x03,0x12,0x16,0x17,0x0a,0x0b,0x0a,0x04,0x04,0x01,
0x02,0x02,0x12,0x03,0x13,0x02,0x19,0x0a,0x0c,0x0a,
0x05,0x04,0x01,0x02,0x02,0x05,0x12,0x03,0x13,0x02,
0x08,0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x02,0x01,
0x12,0x03,0x13,0x09,0x14,0x0a,0x0c,0x0a,0x05,0x04,
0x01,0x02,0x02,0x03,0x12,0x03,0x13,0x17,0x18,0x0a,
0x0b,0x0a,0x04,0x04,0x01,0x02,0x03,0x12,0x03,0x14,
0x02,0x17,0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x03,
0x06,0x12,0x03,0x14,0x02,0x10,0x0a,0x0c,0x0a,0x05,
0x04,0x01,0x02,0x03,0x01,0x12,0x03,0x14,0x11,0x12,
0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x03,0x03,0x12,
0x03,0x14,0x15,0x16,0x0a,0x0b,0x0a,0x04,0x04,0x01,
0x02,0x04,0x12,0x03,0x15,0x02,0x17,0x0a,0x0c,0x0a,
0x05,0x04,0x01,0x02,0x04,0x06,0x12,0x03,0x15,0x02,
0x10,0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x04,0x01,
0x12,0x03,0x15,0x11,0x12,0x0a,0x0c,0x0a,0x05,0x04,
0x01,0x02,0x04,0x03,0x12,0x03,0x15,0x15,0x16,0x0a,
0x0b,0x0a,0x04,0x04,0x01,0x02,0x05,0x12,0x03,0x16,
0x02,0x17,0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x05,
0x06,0x12,0x03,0x16,0x02,0x10,0x0a,0x0c,0x0a,0x05,
0x04,0x01,0x02,0x05,0x01,0x12,0x03,0x16,0x11,0x12,
0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x05,0x03,0x12,
0x03,0x16,0x15,0x16,0x0a,0x0b,0x0a,0x04,0x04,0x01,
0x02,0x06,0x12,0x03,0x17,0x02,0x17,0x0a,0x0c,0x0a,
0x05,0x04,0x01,0x02,0x06,0x06,0x12,0x03,0x17,0x02,
0x10,0x0a,0x0c,0x0a,0x05,0x04,0x01,0x02,0x06,0x01,
0x12,0x03,0x17,0x11,0x12,0x0a,0x0c,0x0a,0x05,0x04,
0x01,0x02,0x06,0x03,0x12,0x03,0x17,0x15,0x16,0x62,
0x06,0x70,0x72,0x6f,0x74,0x6f,0x33,
};
static const char file_name[] = "system.proto";
static const char wpi_proto_ProtobufDCMotor_name[] = "wpi.proto.ProtobufDCMotor";
std::string_view wpi_proto_ProtobufDCMotor::msg_name(void) noexcept { return wpi_proto_ProtobufDCMotor_name; }
pb_filedesc_t wpi_proto_ProtobufDCMotor::file_descriptor(void) noexcept { return {::file_name, ::file_descriptor}; }
PB_BIND(wpi_proto_ProtobufDCMotor, wpi_proto_ProtobufDCMotor, AUTO)
static const char wpi_proto_ProtobufLinearSystem_name[] = "wpi.proto.ProtobufLinearSystem";
std::string_view wpi_proto_ProtobufLinearSystem::msg_name(void) noexcept { return wpi_proto_ProtobufLinearSystem_name; }
pb_filedesc_t wpi_proto_ProtobufLinearSystem::file_descriptor(void) noexcept { return {::file_name, ::file_descriptor}; }
@@ -104,3 +160,11 @@ PB_BIND(wpi_proto_ProtobufLinearSystem, wpi_proto_ProtobufLinearSystem, AUTO)
#ifndef PB_CONVERT_DOUBLE_FLOAT
/* On some platforms (such as AVR), double is really float.
* To be able to encode/decode double on these platforms, you need.
* to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
*/
PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
#endif

30
wpimath/src/generated/main/native/cpp/wpimath/protobuf/system.npb.h generated
View File

@@ -16,6 +16,18 @@
#endif
/* Struct definitions */
typedef struct _wpi_proto_ProtobufDCMotor {
static const pb_msgdesc_t* msg_descriptor(void) noexcept;
static std::string_view msg_name(void) noexcept;
static pb_filedesc_t file_descriptor(void) noexcept;
double nominal_voltage;
double stall_torque;
double stall_current;
double free_current;
double free_speed;
} wpi_proto_ProtobufDCMotor;
typedef struct _wpi_proto_ProtobufLinearSystem {
static const pb_msgdesc_t* msg_descriptor(void) noexcept;
static std::string_view msg_name(void) noexcept;
@@ -32,10 +44,17 @@ typedef struct _wpi_proto_ProtobufLinearSystem {
/* Initializer values for message structs */
#define wpi_proto_ProtobufDCMotor_init_default {0, 0, 0, 0, 0}
#define wpi_proto_ProtobufLinearSystem_init_default {0, 0, 0, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
#define wpi_proto_ProtobufDCMotor_init_zero {0, 0, 0, 0, 0}
#define wpi_proto_ProtobufLinearSystem_init_zero {0, 0, 0, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}}
/* Field tags (for use in manual encoding/decoding) */
#define wpi_proto_ProtobufDCMotor_nominal_voltage_tag 1
#define wpi_proto_ProtobufDCMotor_stall_torque_tag 2
#define wpi_proto_ProtobufDCMotor_stall_current_tag 3
#define wpi_proto_ProtobufDCMotor_free_current_tag 4
#define wpi_proto_ProtobufDCMotor_free_speed_tag 5
#define wpi_proto_ProtobufLinearSystem_num_states_tag 1
#define wpi_proto_ProtobufLinearSystem_num_inputs_tag 2
#define wpi_proto_ProtobufLinearSystem_num_outputs_tag 3
@@ -45,6 +64,15 @@ typedef struct _wpi_proto_ProtobufLinearSystem {
#define wpi_proto_ProtobufLinearSystem_d_tag 7
/* Struct field encoding specification for nanopb */
#define wpi_proto_ProtobufDCMotor_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, DOUBLE, nominal_voltage, 1) \
X(a, STATIC, SINGULAR, DOUBLE, stall_torque, 2) \
X(a, STATIC, SINGULAR, DOUBLE, stall_current, 3) \
X(a, STATIC, SINGULAR, DOUBLE, free_current, 4) \
X(a, STATIC, SINGULAR, DOUBLE, free_speed, 5)
#define wpi_proto_ProtobufDCMotor_CALLBACK NULL
#define wpi_proto_ProtobufDCMotor_DEFAULT NULL
#define wpi_proto_ProtobufLinearSystem_FIELDLIST(X, a_) \
X(a_, STATIC, SINGULAR, UINT32, num_states, 1) \
X(a_, STATIC, SINGULAR, UINT32, num_inputs, 2) \
@@ -62,6 +90,8 @@ X(a_, CALLBACK, OPTIONAL, MESSAGE, d, 7)
/* Maximum encoded size of messages (where known) */
/* wpi_proto_ProtobufLinearSystem_size depends on runtime parameters */
#define WPI_PROTO_SYSTEM_NPB_H_MAX_SIZE wpi_proto_ProtobufDCMotor_size
#define wpi_proto_ProtobufDCMotor_size 45
#endif

2
wpimath/src/main/java/org/wpilib/math/controller/DifferentialDriveAccelerationLimiter.java
View File

@@ -16,7 +16,7 @@ import org.wpilib.math.util.Nat;
* Filters the provided voltages to limit a differential drive's linear and angular acceleration.
*
* <p>The differential drive model can be created via the functions in {@link
* org.wpilib.math.system.plant.LinearSystemId}.
* org.wpilib.math.system.Models}.
*/
public class DifferentialDriveAccelerationLimiter {
private final LinearSystem<N2, N2, N2> m_system;

6
wpimath/src/main/java/org/wpilib/math/controller/DifferentialDriveFeedforward.java
View File

@@ -9,7 +9,7 @@ import org.wpilib.math.controller.struct.DifferentialDriveFeedforwardStruct;
import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.system.LinearSystem;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.system.Models;
import org.wpilib.util.protobuf.ProtobufSerializable;
import org.wpilib.util.struct.StructSerializable;
@@ -41,7 +41,7 @@ public class DifferentialDriveFeedforward implements ProtobufSerializable, Struc
*/
public DifferentialDriveFeedforward(
double kVLinear, double kALinear, double kVAngular, double kAAngular, double trackwidth) {
// See LinearSystemId.identifyDrivetrainSystem(double, double, double, double, double)
// See Models.differentialDriveFromSysId(double, double, double, double, double)
this(kVLinear, kALinear, kVAngular * 2.0 / trackwidth, kAAngular * 2.0 / trackwidth);
}
@@ -55,7 +55,7 @@ public class DifferentialDriveFeedforward implements ProtobufSerializable, Struc
*/
public DifferentialDriveFeedforward(
double kVLinear, double kALinear, double kVAngular, double kAAngular) {
m_plant = LinearSystemId.identifyDrivetrainSystem(kVLinear, kALinear, kVAngular, kAAngular);
m_plant = Models.differentialDriveFromSysId(kVLinear, kALinear, kVAngular, kAAngular);
m_kVLinear = kVLinear;
m_kALinear = kALinear;
m_kVAngular = kVAngular;

6
wpimath/src/main/java/org/wpilib/math/system/plant/DCMotor.java → wpimath/src/main/java/org/wpilib/math/system/DCMotor.java
View File

@@ -2,10 +2,10 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package org.wpilib.math.system.plant;
package org.wpilib.math.system;
import org.wpilib.math.system.plant.proto.DCMotorProto;
import org.wpilib.math.system.plant.struct.DCMotorStruct;
import org.wpilib.math.system.proto.DCMotorProto;
import org.wpilib.math.system.struct.DCMotorStruct;
import org.wpilib.math.util.Units;
import org.wpilib.util.protobuf.ProtobufSerializable;
import org.wpilib.util.struct.StructSerializable;

370
wpimath/src/main/java/org/wpilib/math/system/Models.java Normal file
View File

@@ -0,0 +1,370 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package org.wpilib.math.system;
import org.wpilib.math.linalg.MatBuilder;
import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.util.Nat;
/** Linear system factories. */
public final class Models {
private Models() {
// Utility class
}
/**
* Creates a flywheel state-space model from physical constants.
*
* <p>The states are [angular velocity], the inputs are [voltage], and the outputs are [angular
* velocity].
*
* @param motor The motor (or gearbox) attached to the flywheel.
* @param J The moment of inertia J of the flywheel.
* @param gearing Gear ratio from motor to flywheel (greater than 1 is a reduction).
* @return Flywheel state-space model.
* @throws IllegalArgumentException if J &lt;= 0 or gearing &lt;= 0.
*/
public static LinearSystem<N1, N1, N1> flywheelFromPhysicalConstants(
DCMotor motor, double J, double gearing) {
if (J <= 0.0) {
throw new IllegalArgumentException("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
var A =
MatBuilder.fill(
Nat.N1(), Nat.N1(), -Math.pow(gearing, 2) * motor.Kt / (motor.Kv * motor.R * J));
var B = MatBuilder.fill(Nat.N1(), Nat.N1(), gearing * motor.Kt / (motor.R * J));
var C = MatBuilder.fill(Nat.N1(), Nat.N1(), 1.0);
var D = MatBuilder.fill(Nat.N1(), Nat.N1(), 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Creates a flywheel state-space model from SysId constants kᵥ (V/(rad/s)) and kₐ (V/(rad/s²))
* from the feedforward model u = kᵥv + kₐa.
*
* <p>The states are [velocity], the inputs are [voltage], and the outputs are [velocity].
*
* @param kV The velocity gain, in V/(rad/s).
* @param kA The acceleration gain, in V/(rad/s²).
* @return Flywheel state-space model.
* @throws IllegalArgumentException if kV &lt; 0 or kA &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N1, N1, N1> flywheelFromSysId(double kV, double kA) {
if (kV < 0.0) {
throw new IllegalArgumentException("Kv must be greater than or equal to zero.");
}
if (kA <= 0.0) {
throw new IllegalArgumentException("Ka must be greater than zero.");
}
var A = MatBuilder.fill(Nat.N1(), Nat.N1(), -kV / kA);
var B = MatBuilder.fill(Nat.N1(), Nat.N1(), 1.0 / kA);
var C = MatBuilder.fill(Nat.N1(), Nat.N1(), 1.0);
var D = MatBuilder.fill(Nat.N1(), Nat.N1(), 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Creates an elevator state-space model from physical constants.
*
* <p>The states are [position, velocity], the inputs are [voltage], and the outputs are
* [position, velocity].
*
* @param motor The motor (or gearbox) attached to the carriage.
* @param mass The mass of the elevator carriage, in kilograms.
* @param radius The radius of the elevator's driving drum, in meters.
* @param gearing Gear ratio from motor to carriage (greater than 1 is a reduction).
* @return Elevator state-space model.
* @throws IllegalArgumentException if mass &lt;= 0, radius &lt;= 0, or gearing &lt;= 0.
*/
public static LinearSystem<N2, N1, N2> elevatorFromPhysicalConstants(
DCMotor motor, double mass, double radius, double gearing) {
if (mass <= 0.0) {
throw new IllegalArgumentException("mass must be greater than zero.");
}
if (radius <= 0.0) {
throw new IllegalArgumentException("radius must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
var A =
MatBuilder.fill(
Nat.N2(),
Nat.N2(),
0.0,
1.0,
0.0,
-Math.pow(gearing, 2) * motor.Kt / (motor.R * Math.pow(radius, 2) * mass * motor.Kv));
var B =
MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, gearing * motor.Kt / (motor.R * radius * mass));
var C = MatBuilder.fill(Nat.N2(), Nat.N2(), 1.0, 0.0, 0.0, 1.0);
var D = MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Creates an elevator state-space model from SysId constants kᵥ (V/(m/s)) and kₐ (V/(m/s²)) from
* the feedforward model u = kᵥv + kₐa.
*
* <p>The states are [position, velocity], the inputs are [voltage], and the outputs are
* [position, velocity].
*
* @param kV The velocity gain, in V/(m/s).
* @param kA The acceleration gain, in V/(m/s²).
* @return Elevator state-space model.
* @throws IllegalArgumentException if kV &lt; 0 or kA &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N1, N2> elevatorFromSysId(double kV, double kA) {
if (kV < 0.0) {
throw new IllegalArgumentException("Kv must be greater than or equal to zero.");
}
if (kA <= 0.0) {
throw new IllegalArgumentException("Ka must be greater than zero.");
}
var A = MatBuilder.fill(Nat.N2(), Nat.N2(), 0.0, 1.0, 0.0, -kV / kA);
var B = MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, 1.0 / kA);
var C = MatBuilder.fill(Nat.N2(), Nat.N2(), 1.0, 0.0, 0.0, 1.0);
var D = MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Create a single-jointed arm state-space model from physical constants.
*
* <p>The states are [angle, angular velocity], the inputs are [voltage], and the outputs are
* [angle, angular velocity].
*
* @param motor The motor (or gearbox) attached to the arm.
* @param J The moment of inertia J of the arm.
* @param gearing Gear ratio from motor to arm (greater than 1 is a reduction).
* @return Single-jointed arm state-space model.
* @throws IllegalArgumentException if J &lt;= 0 or gearing &lt;= 0.
*/
public static LinearSystem<N2, N1, N2> singleJointedArmFromPhysicalConstants(
DCMotor motor, double J, double gearing) {
if (J <= 0.0) {
throw new IllegalArgumentException("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
var A =
MatBuilder.fill(
Nat.N2(),
Nat.N2(),
0.0,
1.0,
0.0,
-Math.pow(gearing, 2) * motor.Kt / (motor.Kv * motor.R * J));
var B = MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, gearing * motor.Kt / (motor.R * J));
var C = MatBuilder.fill(Nat.N2(), Nat.N2(), 1.0, 0.0, 0.0, 1.0);
var D = MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Creates a single-jointed arm state-space model from SysId constants kᵥ (V/(rad/s)) and kₐ
* (V/(rad/s²)) from the feedforward model u = kᵥv + kₐa.
*
* <p>The states are [position, velocity], the inputs are [voltage], and the outputs are
* [position, velocity].
*
* @param kV The velocity gain, in volts/(unit/sec).
* @param kA The acceleration gain, in volts/(unit/sec²).
* @return Single-jointed arm state-space model.
* @throws IllegalArgumentException if kV &lt; 0 or kA &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N1, N2> singleJointedArmFromSysId(double kV, double kA) {
if (kV < 0.0) {
throw new IllegalArgumentException("Kv must be greater than or equal to zero.");
}
if (kA <= 0.0) {
throw new IllegalArgumentException("Ka must be greater than zero.");
}
var A = MatBuilder.fill(Nat.N2(), Nat.N2(), 0.0, 1.0, 0.0, -kV / kA);
var B = MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, 1.0 / kA);
var C = MatBuilder.fill(Nat.N2(), Nat.N2(), 1.0, 0.0, 0.0, 1.0);
var D = MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Creates a differential drive state-space model from physical constants.
*
* <p>The states are [left velocity, right velocity], the inputs are [left voltage, right
* voltage], and the outputs are [left velocity, right velocity].
*
* @param motor The motor (or gearbox) driving the drivetrain.
* @param mass The mass of the robot in kilograms.
* @param r The radius of the wheels in meters.
* @param rb The radius of the base (half of the trackwidth), in meters.
* @param J The moment of inertia of the robot.
* @param gearing Gear ratio from motor to wheel (greater than 1 is a reduction).
* @return Differential drive state-space model.
* @throws IllegalArgumentException if mass &lt;= 0, r &lt;= 0, rb &lt;= 0, J &lt;= 0, or gearing
* &lt;= 0.
*/
public static LinearSystem<N2, N2, N2> differentialDriveFromPhysicalConstants(
DCMotor motor, double mass, double r, double rb, double J, double gearing) {
if (mass <= 0.0) {
throw new IllegalArgumentException("mass must be greater than zero.");
}
if (r <= 0.0) {
throw new IllegalArgumentException("r must be greater than zero.");
}
if (rb <= 0.0) {
throw new IllegalArgumentException("rb must be greater than zero.");
}
if (J <= 0.0) {
throw new IllegalArgumentException("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
double C1 = -Math.pow(gearing, 2) * motor.Kt / (motor.Kv * motor.R * Math.pow(r, 2));
double C2 = gearing * motor.Kt / (motor.R * r);
var A =
MatBuilder.fill(
Nat.N2(),
Nat.N2(),
(1 / mass + Math.pow(rb, 2) / J) * C1,
(1 / mass - Math.pow(rb, 2) / J) * C1,
(1 / mass - Math.pow(rb, 2) / J) * C1,
(1 / mass + Math.pow(rb, 2) / J) * C1);
var B =
MatBuilder.fill(
Nat.N2(),
Nat.N2(),
(1 / mass + Math.pow(rb, 2) / J) * C2,
(1 / mass - Math.pow(rb, 2) / J) * C2,
(1 / mass - Math.pow(rb, 2) / J) * C2,
(1 / mass + Math.pow(rb, 2) / J) * C2);
var C = MatBuilder.fill(Nat.N2(), Nat.N2(), 1.0, 0.0, 0.0, 1.0);
var D = MatBuilder.fill(Nat.N2(), Nat.N2(), 0.0, 0.0, 0.0, 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Creates a differential drive state-space model from SysId constants kᵥ and kₐ in both linear
* {(V/(m/s), (V/(m/s²))} and angular {(V/(rad/s), (V/(rad/s²))} cases.
*
* <p>The states are [left velocity, right velocity], the inputs are [left voltage, right
* voltage], and the outputs are [left velocity, right velocity].
*
* @param kVLinear The linear velocity gain in volts per (meters per second).
* @param kALinear The linear acceleration gain in volts per (meters per second squared).
* @param kVAngular The angular velocity gain in volts per (meters per second).
* @param kAAngular The angular acceleration gain in volts per (meters per second squared).
* @return Differential drive state-space model.
* @throws IllegalArgumentException if kVLinear &lt;= 0, kALinear &lt;= 0, kVAngular &lt;= 0, or
* kAAngular &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N2, N2> differentialDriveFromSysId(
double kVLinear, double kALinear, double kVAngular, double kAAngular) {
if (kVLinear <= 0.0) {
throw new IllegalArgumentException("Kv,linear must be greater than zero.");
}
if (kALinear <= 0.0) {
throw new IllegalArgumentException("Ka,linear must be greater than zero.");
}
if (kVAngular <= 0.0) {
throw new IllegalArgumentException("Kv,angular must be greater than zero.");
}
if (kAAngular <= 0.0) {
throw new IllegalArgumentException("Ka,angular must be greater than zero.");
}
double A1 = -0.5 * (kVLinear / kALinear + kVAngular / kAAngular);
double A2 = -0.5 * (kVLinear / kALinear - kVAngular / kAAngular);
double B1 = 0.5 / kALinear + 0.5 / kAAngular;
double B2 = 0.5 / kALinear - 0.5 / kAAngular;
var A = MatBuilder.fill(Nat.N2(), Nat.N2(), A1, A2, A2, A1);
var B = MatBuilder.fill(Nat.N2(), Nat.N2(), B1, B2, B2, B1);
var C = MatBuilder.fill(Nat.N2(), Nat.N2(), 1.0, 0.0, 0.0, 1.0);
var D = MatBuilder.fill(Nat.N2(), Nat.N2(), 0.0, 0.0, 0.0, 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Creates a differential drive state-space model from SysId constants kᵥ and kₐ in both linear
* {(V/(m/s), (V/(m/s²))} and angular {(V/(rad/s), (V/(rad/s²))} cases.
*
* <p>The states are [left velocity, right velocity], the inputs are [left voltage, right
* voltage], and the outputs are [left velocity, right velocity].
*
* @param kVLinear The linear velocity gain in volts per (meters per second).
* @param kALinear The linear acceleration gain in volts per (meters per second squared).
* @param kVAngular The angular velocity gain in volts per (radians per second).
* @param kAAngular The angular acceleration gain in volts per (radians per second squared).
* @param trackwidth The distance between the differential drive's left and right wheels, in
* meters.
* @return Differential drive state-space model.
* @throws IllegalArgumentException if kVLinear &lt;= 0, kALinear &lt;= 0, kVAngular &lt;= 0,
* kAAngular &lt;= 0, or trackwidth &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N2, N2> differentialDriveFromSysId(
double kVLinear, double kALinear, double kVAngular, double kAAngular, double trackwidth) {
if (kVLinear <= 0.0) {
throw new IllegalArgumentException("Kv,linear must be greater than zero.");
}
if (kALinear <= 0.0) {
throw new IllegalArgumentException("Ka,linear must be greater than zero.");
}
if (kVAngular <= 0.0) {
throw new IllegalArgumentException("Kv,angular must be greater than zero.");
}
if (kAAngular <= 0.0) {
throw new IllegalArgumentException("Ka,angular must be greater than zero.");
}
if (trackwidth <= 0.0) {
throw new IllegalArgumentException("r must be greater than zero.");
}
// We want to find a factor to include in Kv,angular that will convert
// `u = Kv,angular omega` to `u = Kv,angular v`.
//
// v = omega r
// omega = v/r
// omega = 1/r v
// omega = 1/(trackwidth/2) v
// omega = 2/trackwidth v
//
// So multiplying by 2/trackwidth converts the angular gains from V/(rad/s)
// to V/(m/s).
return differentialDriveFromSysId(
kVLinear, kALinear, kVAngular * 2.0 / trackwidth, kAAngular * 2.0 / trackwidth);
}
}

390
wpimath/src/main/java/org/wpilib/math/system/plant/LinearSystemId.java
View File

@@ -1,390 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package org.wpilib.math.system.plant;
import org.wpilib.math.linalg.MatBuilder;
import org.wpilib.math.linalg.Matrix;
import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.system.LinearSystem;
import org.wpilib.math.util.Nat;
/** Linear system ID utility functions. */
public final class LinearSystemId {
private LinearSystemId() {
// Utility class
}
/**
* Create a state-space model of an elevator system. The states of the system are [position,
* velocity]ᵀ, inputs are [voltage], and outputs are [position, velocity]ᵀ.
*
* @param motor The motor (or gearbox) attached to the carriage.
* @param mass The mass of the elevator carriage, in kilograms.
* @param radius The radius of the elevator's driving drum, in meters.
* @param gearing The reduction between motor and drum, as a ratio of output to input.
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if mass &lt;= 0, radius &lt;= 0, or gearing &lt;= 0.
*/
public static LinearSystem<N2, N1, N2> createElevatorSystem(
DCMotor motor, double mass, double radius, double gearing) {
if (mass <= 0.0) {
throw new IllegalArgumentException("mass must be greater than zero.");
}
if (radius <= 0.0) {
throw new IllegalArgumentException("radius must be greater than zero.");
}
if (gearing <= 0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
return new LinearSystem<>(
MatBuilder.fill(
Nat.N2(),
Nat.N2(),
0,
1,
0,
-Math.pow(gearing, 2) * motor.Kt / (motor.R * radius * radius * mass * motor.Kv)),
VecBuilder.fill(0, gearing * motor.Kt / (motor.R * radius * mass)),
Matrix.eye(Nat.N2()),
new Matrix<>(Nat.N2(), Nat.N1()));
}
/**
* Create a state-space model of a flywheel system. The states of the system are [angular
* velocity], inputs are [voltage], and outputs are [angular velocity].
*
* @param motor The motor (or gearbox) attached to the flywheel.
* @param J The moment of inertia J of the flywheel in kg-m².
* @param gearing The reduction between motor and drum, as a ratio of output to input.
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if J &lt;= 0 or gearing &lt;= 0.
*/
public static LinearSystem<N1, N1, N1> createFlywheelSystem(
DCMotor motor, double J, double gearing) {
if (J <= 0.0) {
throw new IllegalArgumentException("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
return new LinearSystem<>(
VecBuilder.fill(-gearing * gearing * motor.Kt / (motor.Kv * motor.R * J)),
VecBuilder.fill(gearing * motor.Kt / (motor.R * J)),
Matrix.eye(Nat.N1()),
new Matrix<>(Nat.N1(), Nat.N1()));
}
/**
* Create a state-space model of a DC motor system. The states of the system are [angular
* position, angular velocity]ᵀ, inputs are [voltage], and outputs are [angular position, angular
* velocity]ᵀ.
*
* @param motor The motor (or gearbox) attached to system.
* @param J The moment of inertia J of the DC motor in kg-m².
* @param gearing The reduction between motor and drum, as a ratio of output to input.
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if J &lt;= 0 or gearing &lt;= 0.
*/
public static LinearSystem<N2, N1, N2> createDCMotorSystem(
DCMotor motor, double J, double gearing) {
if (J <= 0.0) {
throw new IllegalArgumentException("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
return new LinearSystem<>(
MatBuilder.fill(
Nat.N2(), Nat.N2(), 0, 1, 0, -gearing * gearing * motor.Kt / (motor.Kv * motor.R * J)),
VecBuilder.fill(0, gearing * motor.Kt / (motor.R * J)),
Matrix.eye(Nat.N2()),
new Matrix<>(Nat.N2(), Nat.N1()));
}
/**
* Create a state-space model of a DC motor system from its kV (volts/(unit/sec)) and kA
* (volts/(unit/sec²)). These constants can be found using SysId. the states of the system are
* [position, velocity]ᵀ, inputs are [voltage], and outputs are [position].
*
* <p>The distance unit you choose MUST be an SI unit (i.e. meters or radians). You can use the
* {@link org.wpilib.math.util.Units} class for converting between unit types.
*
* <p>The parameters provided by the user are from this feedforward model:
*
* <p>u = K_v v + K_a a
*
* @param kV The velocity gain, in volts/(unit/sec)
* @param kA The acceleration gain, in volts/(unit/sec²)
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if kV &lt; 0 or kA &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N1, N2> createDCMotorSystem(double kV, double kA) {
if (kV < 0.0) {
throw new IllegalArgumentException("Kv must be greater than or equal to zero.");
}
if (kA <= 0.0) {
throw new IllegalArgumentException("Ka must be greater than zero.");
}
return new LinearSystem<>(
MatBuilder.fill(Nat.N2(), Nat.N2(), 0, 1, 0, -kV / kA),
VecBuilder.fill(0, 1 / kA),
Matrix.eye(Nat.N2()),
new Matrix<>(Nat.N2(), Nat.N1()));
}
/**
* Create a state-space model of a differential drive drivetrain. In this model, the states are
* [left velocity, right velocity]ᵀ, inputs are [left voltage, right voltage]ᵀ, and outputs are
* [left velocity, right velocity]ᵀ.
*
* @param motor The motor (or gearbox) driving the drivetrain.
* @param mass The mass of the robot in kilograms.
* @param r The radius of the wheels in meters.
* @param rb The radius of the base (half the trackwidth) in meters.
* @param J The moment of inertia of the robot in kg-m².
* @param gearing The gearing reduction as output over input.
* @return A LinearSystem representing a differential drivetrain.
* @throws IllegalArgumentException if m &lt;= 0, r &lt;= 0, rb &lt;= 0, J &lt;= 0, or gearing
* &lt;= 0.
*/
public static LinearSystem<N2, N2, N2> createDrivetrainVelocitySystem(
DCMotor motor, double mass, double r, double rb, double J, double gearing) {
if (mass <= 0.0) {
throw new IllegalArgumentException("mass must be greater than zero.");
}
if (r <= 0.0) {
throw new IllegalArgumentException("r must be greater than zero.");
}
if (rb <= 0.0) {
throw new IllegalArgumentException("rb must be greater than zero.");
}
if (J <= 0.0) {
throw new IllegalArgumentException("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
var C1 = -(gearing * gearing) * motor.Kt / (motor.Kv * motor.R * r * r);
var C2 = gearing * motor.Kt / (motor.R * r);
final double C3 = 1 / mass + rb * rb / J;
final double C4 = 1 / mass - rb * rb / J;
var A = MatBuilder.fill(Nat.N2(), Nat.N2(), C3 * C1, C4 * C1, C4 * C1, C3 * C1);
var B = MatBuilder.fill(Nat.N2(), Nat.N2(), C3 * C2, C4 * C2, C4 * C2, C3 * C2);
var C = MatBuilder.fill(Nat.N2(), Nat.N2(), 1.0, 0.0, 0.0, 1.0);
var D = MatBuilder.fill(Nat.N2(), Nat.N2(), 0.0, 0.0, 0.0, 0.0);
return new LinearSystem<>(A, B, C, D);
}
/**
* Create a state-space model of a single jointed arm system. The states of the system are [angle,
* angular velocity]ᵀ, inputs are [voltage], and outputs are [angle, angular velocity]ᵀ.
*
* @param motor The motor (or gearbox) attached to the arm.
* @param J The moment of inertia J of the arm in kg-m².
* @param gearing The gearing between the motor and arm, in output over input. Most of the time
* this will be greater than 1.
* @return A LinearSystem representing the given characterized constants.
*/
public static LinearSystem<N2, N1, N2> createSingleJointedArmSystem(
DCMotor motor, double J, double gearing) {
if (J <= 0.0) {
throw new IllegalArgumentException("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw new IllegalArgumentException("gearing must be greater than zero.");
}
return new LinearSystem<>(
MatBuilder.fill(
Nat.N2(),
Nat.N2(),
0,
1,
0,
-Math.pow(gearing, 2) * motor.Kt / (motor.Kv * motor.R * J)),
VecBuilder.fill(0, gearing * motor.Kt / (motor.R * J)),
Matrix.eye(Nat.N2()),
new Matrix<>(Nat.N2(), Nat.N1()));
}
/**
* Create a state-space model for a 1 DOF velocity system from its kV (volts/(unit/sec)) and kA
* (volts/(unit/sec²). These constants cam be found using SysId. The states of the system are
* [velocity], inputs are [voltage], and outputs are [velocity].
*
* <p>The distance unit you choose MUST be an SI unit (i.e. meters or radians). You can use the
* {@link org.wpilib.math.util.Units} class for converting between unit types.
*
* <p>The parameters provided by the user are from this feedforward model:
*
* <p>u = K_v v + K_a a
*
* @param kV The velocity gain, in volts/(unit/sec)
* @param kA The acceleration gain, in volts/(unit/sec²)
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if kV &lt; 0 or kA &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N1, N1, N1> identifyVelocitySystem(double kV, double kA) {
if (kV < 0.0) {
throw new IllegalArgumentException("Kv must be greater than or equal to zero.");
}
if (kA <= 0.0) {
throw new IllegalArgumentException("Ka must be greater than zero.");
}
return new LinearSystem<>(
VecBuilder.fill(-kV / kA),
VecBuilder.fill(1.0 / kA),
VecBuilder.fill(1.0),
VecBuilder.fill(0.0));
}
/**
* Create a state-space model for a 1 DOF position system from its kV (volts/(unit/sec)) and kA
* (volts/(unit/sec²). These constants cam be found using SysId. The states of the system are
* [position, velocity]ᵀ, inputs are [voltage], and outputs are [position, velocity]ᵀ.
*
* <p>The distance unit you choose MUST be an SI unit (i.e. meters or radians). You can use the
* {@link org.wpilib.math.util.Units} class for converting between unit types.
*
* <p>The parameters provided by the user are from this feedforward model:
*
* <p>u = K_v v + K_a a
*
* @param kV The velocity gain, in volts/(unit/sec)
* @param kA The acceleration gain, in volts/(unit/sec²)
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if kV &lt; 0 or kA &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N1, N2> identifyPositionSystem(double kV, double kA) {
if (kV < 0.0) {
throw new IllegalArgumentException("Kv must be greater than or equal to zero.");
}
if (kA <= 0.0) {
throw new IllegalArgumentException("Ka must be greater than zero.");
}
return new LinearSystem<>(
MatBuilder.fill(Nat.N2(), Nat.N2(), 0.0, 1.0, 0.0, -kV / kA),
VecBuilder.fill(0.0, 1.0 / kA),
Matrix.eye(Nat.N2()),
new Matrix<>(Nat.N2(), Nat.N1()));
}
/**
* Identify a differential drive drivetrain given the drivetrain's kV and kA in both linear
* {(volts/(meter/sec), (volts/(meter/sec²))} and angular {(volts/(radian/sec)),
* (volts/(radian/sec²))} cases. These constants can be found using SysId.
*
* <p>States: [[left velocity], [right velocity]]<br>
* Inputs: [[left voltage], [right voltage]]<br>
* Outputs: [[left velocity], [right velocity]]
*
* @param kVLinear The linear velocity gain in volts per (meters per second).
* @param kALinear The linear acceleration gain in volts per (meters per second squared).
* @param kVAngular The angular velocity gain in volts per (meters per second).
* @param kAAngular The angular acceleration gain in volts per (meters per second squared).
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if kVLinear &lt;= 0, kALinear &lt;= 0, kVAngular &lt;= 0, or
* kAAngular &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N2, N2> identifyDrivetrainSystem(
double kVLinear, double kALinear, double kVAngular, double kAAngular) {
if (kVLinear <= 0.0) {
throw new IllegalArgumentException("Kv,linear must be greater than zero.");
}
if (kALinear <= 0.0) {
throw new IllegalArgumentException("Ka,linear must be greater than zero.");
}
if (kVAngular <= 0.0) {
throw new IllegalArgumentException("Kv,angular must be greater than zero.");
}
if (kAAngular <= 0.0) {
throw new IllegalArgumentException("Ka,angular must be greater than zero.");
}
final double A1 = 0.5 * -(kVLinear / kALinear + kVAngular / kAAngular);
final double A2 = 0.5 * -(kVLinear / kALinear - kVAngular / kAAngular);
final double B1 = 0.5 * (1.0 / kALinear + 1.0 / kAAngular);
final double B2 = 0.5 * (1.0 / kALinear - 1.0 / kAAngular);
return new LinearSystem<>(
MatBuilder.fill(Nat.N2(), Nat.N2(), A1, A2, A2, A1),
MatBuilder.fill(Nat.N2(), Nat.N2(), B1, B2, B2, B1),
MatBuilder.fill(Nat.N2(), Nat.N2(), 1, 0, 0, 1),
MatBuilder.fill(Nat.N2(), Nat.N2(), 0, 0, 0, 0));
}
/**
* Identify a differential drive drivetrain given the drivetrain's kV and kA in both linear
* {(volts/(meter/sec)), (volts/(meter/sec²))} and angular {(volts/(radian/sec)),
* (volts/(radian/sec²))} cases. This can be found using SysId.
*
* <p>States: [[left velocity], [right velocity]]<br>
* Inputs: [[left voltage], [right voltage]]<br>
* Outputs: [[left velocity], [right velocity]]
*
* @param kVLinear The linear velocity gain in volts per (meters per second).
* @param kALinear The linear acceleration gain in volts per (meters per second squared).
* @param kVAngular The angular velocity gain in volts per (radians per second).
* @param kAAngular The angular acceleration gain in volts per (radians per second squared).
* @param trackwidth The distance between the differential drive's left and right wheels, in
* meters.
* @return A LinearSystem representing the given characterized constants.
* @throws IllegalArgumentException if kVLinear &lt;= 0, kALinear &lt;= 0, kVAngular &lt;= 0,
* kAAngular &lt;= 0, or trackwidth &lt;= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
public static LinearSystem<N2, N2, N2> identifyDrivetrainSystem(
double kVLinear, double kALinear, double kVAngular, double kAAngular, double trackwidth) {
if (kVLinear <= 0.0) {
throw new IllegalArgumentException("Kv,linear must be greater than zero.");
}
if (kALinear <= 0.0) {
throw new IllegalArgumentException("Ka,linear must be greater than zero.");
}
if (kVAngular <= 0.0) {
throw new IllegalArgumentException("Kv,angular must be greater than zero.");
}
if (kAAngular <= 0.0) {
throw new IllegalArgumentException("Ka,angular must be greater than zero.");
}
if (trackwidth <= 0.0) {
throw new IllegalArgumentException("trackwidth must be greater than zero.");
}
// We want to find a factor to include in Kv,angular that will convert
// `u = Kv,angular omega` to `u = Kv,angular v`.
//
// v = omega r
// omega = v/r
// omega = 1/r v
// omega = 1/(trackwidth/2) v
// omega = 2/trackwidth v
//
// So multiplying by 2/trackwidth converts the angular gains from V/(rad/s)
// to V/(m/s).
return identifyDrivetrainSystem(
kVLinear, kALinear, kVAngular * 2.0 / trackwidth, kAAngular * 2.0 / trackwidth);
}
}

6
wpimath/src/main/java/org/wpilib/math/system/plant/proto/DCMotorProto.java → wpimath/src/main/java/org/wpilib/math/system/proto/DCMotorProto.java
View File

@@ -2,10 +2,10 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package org.wpilib.math.system.plant.proto;
package org.wpilib.math.system.proto;
import org.wpilib.math.proto.Plant.ProtobufDCMotor;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.proto.System.ProtobufDCMotor;
import org.wpilib.math.system.DCMotor;
import org.wpilib.util.protobuf.Protobuf;
import us.hebi.quickbuf.Descriptors.Descriptor;

4
wpimath/src/main/java/org/wpilib/math/system/plant/struct/DCMotorStruct.java → wpimath/src/main/java/org/wpilib/math/system/struct/DCMotorStruct.java
View File

@@ -2,10 +2,10 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package org.wpilib.math.system.plant.struct;
package org.wpilib.math.system.struct;
import java.nio.ByteBuffer;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.DCMotor;
import org.wpilib.util.struct.Struct;
public class DCMotorStruct implements Struct<DCMotor> {

4
wpimath/src/main/native/cpp/system/plant/proto/DCMotorProto.cpp → wpimath/src/main/native/cpp/system/proto/DCMotorProto.cpp
View File

@@ -2,11 +2,11 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include "wpi/math/system/plant/proto/DCMotorProto.hpp"
#include "wpi/math/system/proto/DCMotorProto.hpp"
#include <optional>
#include "wpimath/protobuf/plant.npb.h"
#include "wpimath/protobuf/system.npb.h"
std::optional<wpi::math::DCMotor>
wpi::util::Protobuf<wpi::math::DCMotor>::Unpack(InputStream& stream) {

2
wpimath/src/main/native/cpp/system/plant/struct/DCMotorStruct.cpp → wpimath/src/main/native/cpp/system/struct/DCMotorStruct.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include "wpi/math/system/plant/struct/DCMotorStruct.hpp"
#include "wpi/math/system/struct/DCMotorStruct.hpp"
namespace {
constexpr size_t kNominalVoltageOff = 0;

3
wpimath/src/main/native/include/wpi/math/controller/DifferentialDriveAccelerationLimiter.hpp
View File

@@ -23,8 +23,7 @@ namespace wpi::math {
* Filters the provided voltages to limit a differential drive's linear and
* angular acceleration.
*
* The differential drive model can be created via the functions in
* LinearSystemId.
* The differential drive model can be created via the functions in Models.
*/
class WPILIB_DLLEXPORT DifferentialDriveAccelerationLimiter {
public:

6
wpimath/src/main/native/include/wpi/math/controller/DifferentialDriveFeedforward.hpp
View File

@@ -6,7 +6,7 @@
#include "wpi/math/controller/DifferentialDriveWheelVoltages.hpp"
#include "wpi/math/system/LinearSystem.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/units/acceleration.hpp"
#include "wpi/units/angular_acceleration.hpp"
#include "wpi/units/angular_velocity.hpp"
@@ -42,7 +42,7 @@ class WPILIB_DLLEXPORT DifferentialDriveFeedforward {
decltype(1_V / 1_mps) kVLinear, decltype(1_V / 1_mps_sq) kALinear,
decltype(1_V / 1_rad_per_s) kVAngular,
decltype(1_V / 1_rad_per_s_sq) kAAngular, wpi::units::meter_t trackwidth)
// See LinearSystemId::IdentifyDrivetrainSystem(decltype(1_V / 1_mps),
// See Models::DifferentialDriveFromSysId(decltype(1_V / 1_mps),
// decltype(1_V / 1_mps_sq), decltype(1_V / 1_rad_per_s), decltype(1_V /
// 1_rad_per_s_sq))
: DifferentialDriveFeedforward{kVLinear, kALinear,
@@ -64,7 +64,7 @@ class WPILIB_DLLEXPORT DifferentialDriveFeedforward {
decltype(1_V / 1_mps_sq) kALinear,
decltype(1_V / 1_mps) kVAngular,
decltype(1_V / 1_mps_sq) kAAngular)
: m_plant{wpi::math::LinearSystemId::IdentifyDrivetrainSystem(
: m_plant{wpi::math::Models::DifferentialDriveFromSysId(
kVLinear, kALinear, kVAngular, kAAngular)},
m_kVLinear{kVLinear},
m_kALinear{kALinear},

42
wpimath/src/main/native/include/wpi/math/controller/ElevatorFeedforward.hpp
View File

@@ -6,7 +6,6 @@
#include "wpi/math/controller/LinearPlantInversionFeedforward.hpp"
#include "wpi/math/linalg/EigenCore.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/util/MathShared.hpp"
#include "wpi/units/length.hpp"
#include "wpi/units/time.hpp"
@@ -70,47 +69,6 @@ class ElevatorFeedforward {
}
}
/**
* Calculates the feedforward from the gains and setpoints assuming continuous
* control.
*
* @param velocity The velocity setpoint.
* @param acceleration The acceleration setpoint.
* @return The computed feedforward, in volts.
* @deprecated Use the current/next velocity overload instead.
*/
[[deprecated("Use the current/next velocity overload instead.")]]
constexpr wpi::units::volt_t Calculate(
wpi::units::unit_t<Velocity> velocity,
wpi::units::unit_t<Acceleration> acceleration) const {
return kS * wpi::util::sgn(velocity) + kG + kV * velocity +
kA * acceleration;
}
/**
* Calculates the feedforward from the gains and setpoints assuming continuous
* control.
*
* @param currentVelocity The current velocity setpoint.
* @param nextVelocity The next velocity setpoint.
* @param dt Time between velocity setpoints in seconds.
* @return The computed feedforward, in volts.
*/
[[deprecated("Use the current/next velocity overload instead.")]]
wpi::units::volt_t Calculate(wpi::units::unit_t<Velocity> currentVelocity,
wpi::units::unit_t<Velocity> nextVelocity,
wpi::units::second_t dt) const {
// See wpimath/algorithms.md#Elevator_feedforward for derivation
auto plant = LinearSystemId::IdentifyVelocitySystem<Distance>(kV, kA);
LinearPlantInversionFeedforward<1, 1> feedforward{plant, dt};
Vectord<1> r{{currentVelocity.value()}};
Vectord<1> nextR{{nextVelocity.value()}};
return kG + kS * wpi::util::sgn(currentVelocity.value()) +
wpi::units::volt_t{feedforward.Calculate(r, nextR)(0)};
}
/**
* Calculates the feedforward from the gains and setpoint assuming discrete
* control. Use this method when the setpoint does not change.

4
wpimath/src/main/native/include/wpi/math/system/plant/DCMotor.hpp → wpimath/src/main/native/include/wpi/math/system/DCMotor.hpp
View File

@@ -289,5 +289,5 @@ class WPILIB_DLLEXPORT DCMotor {
} // namespace wpi::math
#include "wpi/math/system/plant/proto/DCMotorProto.hpp"
#include "wpi/math/system/plant/struct/DCMotorStruct.hpp"
#include "wpi/math/system/proto/DCMotorProto.hpp"
#include "wpi/math/system/struct/DCMotorStruct.hpp"

499
wpimath/src/main/native/include/wpi/math/system/plant/LinearSystemId.hpp → wpimath/src/main/native/include/wpi/math/system/Models.hpp
View File

@@ -4,13 +4,12 @@
#pragma once
#include <concepts>
#include <stdexcept>
#include <gcem.hpp>
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/LinearSystem.hpp"
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/units/acceleration.hpp"
#include "wpi/units/angular_acceleration.hpp"
#include "wpi/units/angular_velocity.hpp"
@@ -22,9 +21,9 @@
namespace wpi::math {
/**
* Linear system ID utility functions.
* Linear system factories.
*/
class WPILIB_DLLEXPORT LinearSystemId {
class WPILIB_DLLEXPORT Models {
public:
template <typename Distance>
using Velocity_t = wpi::units::unit_t<wpi::units::compound_unit<
@@ -37,17 +36,80 @@ class WPILIB_DLLEXPORT LinearSystemId {
wpi::units::inverse<wpi::units::seconds>>>;
/**
* Create a state-space model of the elevator system. The states of the system
* are [position, velocity]ᵀ, inputs are [voltage], and outputs are [position,
* velocity]ᵀ.
* Creates a flywheel state-space model from physical constants.
*
* The states are [angular velocity], the inputs are [voltage], and the
* outputs are [angular velocity].
*
* @param motor The motor (or gearbox) attached to the flywheel.
* @param J The moment of inertia J of the flywheel.
* @param gearing Gear ratio from motor to flywheel (greater than 1 is a
* reduction).
* @throws std::domain_error if J <= 0 or gearing <= 0.
*/
static constexpr LinearSystem<1, 1, 1> FlywheelFromPhysicalConstants(
DCMotor motor, wpi::units::kilogram_square_meter_t J, double gearing) {
if (J <= 0_kg_sq_m) {
throw std::domain_error("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw std::domain_error("gearing must be greater than zero.");
}
Matrixd<1, 1> A{
{(-gcem::pow(gearing, 2) * motor.Kt / (motor.Kv * motor.R * J))
.value()}};
Matrixd<1, 1> B{{(gearing * motor.Kt / (motor.R * J)).value()}};
Matrixd<1, 1> C{{1.0}};
Matrixd<1, 1> D{{0.0}};
return LinearSystem<1, 1, 1>(A, B, C, D);
}
/**
* Creates a flywheel state-space model from SysId constants kᵥ (V/(rad/s))
* and kₐ (V/(rad/s²)) from the feedforward model u = kᵥv + kₐa.
*
* The states are [velocity], the inputs are [voltage], and the outputs are
* [velocity].
*
* @param kV The velocity gain, in V/(rad/s).
* @param kA The acceleration gain, in V/(rad/s²).
* @throws std::domain_error if kV < 0 or kA <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
static constexpr LinearSystem<1, 1, 1> FlywheelFromSysId(
decltype(1_V / 1_rad_per_s) kV, decltype(1_V / 1_rad_per_s_sq) kA) {
if (kV < decltype(kV){0}) {
throw std::domain_error("Kv must be greater than or equal to zero.");
}
if (kA <= decltype(kA){0}) {
throw std::domain_error("Ka must be greater than zero.");
}
Matrixd<1, 1> A{{-kV.value() / kA.value()}};
Matrixd<1, 1> B{{1.0 / kA.value()}};
Matrixd<1, 1> C{{1.0}};
Matrixd<1, 1> D{{0.0}};
return LinearSystem<1, 1, 1>(A, B, C, D);
}
/**
* Creates an elevator state-space model from physical constants.
*
* The states are [position, velocity], the inputs are [voltage], and the
* outputs are [position, velocity].
*
* @param motor The motor (or gearbox) attached to the carriage.
* @param mass The mass of the elevator carriage, in kilograms.
* @param radius The radius of the elevator's driving drum, in meters.
* @param gearing Gear ratio from motor to carriage.
* @param gearing Gear ratio from motor to carriage (greater than 1 is a
* reduction).
* @throws std::domain_error if mass <= 0, radius <= 0, or gearing <= 0.
*/
static constexpr LinearSystem<2, 1, 2> ElevatorSystem(
static constexpr LinearSystem<2, 1, 2> ElevatorFromPhysicalConstants(
DCMotor motor, wpi::units::kilogram_t mass, wpi::units::meter_t radius,
double gearing) {
if (mass <= 0_kg) {
@@ -74,105 +136,21 @@ class WPILIB_DLLEXPORT LinearSystemId {
}
/**
* Create a state-space model of a single-jointed arm system.The states of the
* system are [angle, angular velocity]ᵀ, inputs are [voltage], and outputs
* are [angle, angular velocity]ᵀ.
* Creates an elevator state-space model from SysId constants kᵥ (V/(m/s)) and
* kₐ (V/(m/s²)) from the feedforward model u = kᵥv + kₐa.
*
* @param motor The motor (or gearbox) attached to the arm.
* @param J The moment of inertia J of the arm.
* @param gearing Gear ratio from motor to arm.
* @throws std::domain_error if J <= 0 or gearing <= 0.
*/
static constexpr LinearSystem<2, 1, 2> SingleJointedArmSystem(
DCMotor motor, wpi::units::kilogram_square_meter_t J, double gearing) {
if (J <= 0_kg_sq_m) {
throw std::domain_error("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw std::domain_error("gearing must be greater than zero.");
}
Matrixd<2, 2> A{
{0.0, 1.0},
{0.0, (-gcem::pow(gearing, 2) * motor.Kt / (motor.Kv * motor.R * J))
.value()}};
Matrixd<2, 1> B{{0.0}, {(gearing * motor.Kt / (motor.R * J)).value()}};
Matrixd<2, 2> C{{1.0, 0.0}, {0.0, 1.0}};
Matrixd<2, 1> D{{0.0}, {0.0}};
return LinearSystem<2, 1, 2>(A, B, C, D);
}
/**
* Create a state-space model for a 1 DOF velocity system from its kV
* (volts/(unit/sec)) and kA (volts/(unit/sec²)). These constants can be
* found using SysId. The states of the system are [velocity], inputs are
* [voltage], and outputs are [velocity].
* The states are [position, velocity], the inputs are [voltage], and the
* outputs are [position, velocity].
*
* You MUST use an SI unit (i.e. meters or radians) for the Distance template
* argument. You may still use non-SI units (such as feet or inches) for the
* actual method arguments; they will automatically be converted to SI
* internally.
*
* The parameters provided by the user are from this feedforward model:
*
* u = K_v v + K_a a
*
* @param kV The velocity gain, in volts/(unit/sec).
* @param kA The acceleration gain, in volts/(unit/sec²).
* @throws std::domain_error if kV < 0 or kA <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
template <typename Distance>
requires std::same_as<wpi::units::meter, Distance> ||
std::same_as<wpi::units::radian, Distance>
static constexpr LinearSystem<1, 1, 1> IdentifyVelocitySystem(
decltype(1_V / Velocity_t<Distance>(1)) kV,
decltype(1_V / Acceleration_t<Distance>(1)) kA) {
if (kV < decltype(kV){0}) {
throw std::domain_error("Kv must be greater than or equal to zero.");
}
if (kA <= decltype(kA){0}) {
throw std::domain_error("Ka must be greater than zero.");
}
Matrixd<1, 1> A{{-kV.value() / kA.value()}};
Matrixd<1, 1> B{{1.0 / kA.value()}};
Matrixd<1, 1> C{{1.0}};
Matrixd<1, 1> D{{0.0}};
return LinearSystem<1, 1, 1>(A, B, C, D);
}
/**
* Create a state-space model for a 1 DOF position system from its kV
* (volts/(unit/sec)) and kA (volts/(unit/sec²)). These constants can be
* found using SysId. the states of the system are [position, velocity]ᵀ,
* inputs are [voltage], and outputs are [position, velocity]ᵀ.
*
* You MUST use an SI unit (i.e. meters or radians) for the Distance template
* argument. You may still use non-SI units (such as feet or inches) for the
* actual method arguments; they will automatically be converted to SI
* internally.
*
* The parameters provided by the user are from this feedforward model:
*
* u = K_v v + K_a a
*
* @param kV The velocity gain, in volts/(unit/sec).
* @param kA The acceleration gain, in volts/(unit/sec²).
* @param kV The velocity gain, in V/(m/s).
* @param kA The acceleration gain, in V/(m/s²).
*
* @throws std::domain_error if kV < 0 or kA <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
template <typename Distance>
requires std::same_as<wpi::units::meter, Distance> ||
std::same_as<wpi::units::radian, Distance>
static constexpr LinearSystem<2, 1, 2> IdentifyPositionSystem(
decltype(1_V / Velocity_t<Distance>(1)) kV,
decltype(1_V / Acceleration_t<Distance>(1)) kA) {
static constexpr LinearSystem<2, 1, 2> ElevatorFromSysId(
decltype(1_V / 1_mps) kV, decltype(1_V / 1_mps_sq) kA) {
if (kV < decltype(kV){0}) {
throw std::domain_error("Kv must be greater than or equal to zero.");
}
@@ -189,167 +167,18 @@ class WPILIB_DLLEXPORT LinearSystemId {
}
/**
* Identify a differential drive drivetrain given the drivetrain's kV and kA
* in both linear {(volts/(meter/sec), (volts/(meter/sec²))} and angular
* {(volts/(radian/sec), (volts/(radian/sec²))} cases. These constants can be
* found using SysId.
* Create a single-jointed arm state-space model from physical constants.
*
* States: [[left velocity], [right velocity]]<br>
* Inputs: [[left voltage], [right voltage]]<br>
* Outputs: [[left velocity], [right velocity]]
* The states are [angle, angular velocity], the inputs are [voltage], and the
* outputs are [angle, angular velocity].
*
* @param kVLinear The linear velocity gain in volts per (meters per second).
* @param kALinear The linear acceleration gain in volts per (meters per
* second squared).
* @param kVAngular The angular velocity gain in volts per (meters per
* second).
* @param kAAngular The angular acceleration gain in volts per (meters per
* second squared).
* @throws domain_error if kVLinear <= 0, kALinear <= 0, kVAngular <= 0,
* or kAAngular <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
static constexpr LinearSystem<2, 2, 2> IdentifyDrivetrainSystem(
decltype(1_V / 1_mps) kVLinear, decltype(1_V / 1_mps_sq) kALinear,
decltype(1_V / 1_mps) kVAngular, decltype(1_V / 1_mps_sq) kAAngular) {
if (kVLinear <= decltype(kVLinear){0}) {
throw std::domain_error("Kv,linear must be greater than zero.");
}
if (kALinear <= decltype(kALinear){0}) {
throw std::domain_error("Ka,linear must be greater than zero.");
}
if (kVAngular <= decltype(kVAngular){0}) {
throw std::domain_error("Kv,angular must be greater than zero.");
}
if (kAAngular <= decltype(kAAngular){0}) {
throw std::domain_error("Ka,angular must be greater than zero.");
}
double A1 = -(kVLinear.value() / kALinear.value() +
kVAngular.value() / kAAngular.value());
double A2 = -(kVLinear.value() / kALinear.value() -
kVAngular.value() / kAAngular.value());
double B1 = 1.0 / kALinear.value() + 1.0 / kAAngular.value();
double B2 = 1.0 / kALinear.value() - 1.0 / kAAngular.value();
A1 /= 2.0;
A2 /= 2.0;
B1 /= 2.0;
B2 /= 2.0;
Matrixd<2, 2> A{{A1, A2}, {A2, A1}};
Matrixd<2, 2> B{{B1, B2}, {B2, B1}};
Matrixd<2, 2> C{{1.0, 0.0}, {0.0, 1.0}};
Matrixd<2, 2> D{{0.0, 0.0}, {0.0, 0.0}};
return LinearSystem<2, 2, 2>(A, B, C, D);
}
/**
* Identify a differential drive drivetrain given the drivetrain's kV and kA
* in both linear {(volts/(meter/sec)), (volts/(meter/sec²))} and angular
* {(volts/(radian/sec)), (volts/(radian/sec²))} cases. This can be found
* using SysId.
*
* States: [[left velocity], [right velocity]]<br>
* Inputs: [[left voltage], [right voltage]]<br>
* Outputs: [[left velocity], [right velocity]]
*
* @param kVLinear The linear velocity gain in volts per (meters per
* second).
* @param kALinear The linear acceleration gain in volts per (meters per
* second squared).
* @param kVAngular The angular velocity gain in volts per (radians per
* second).
* @param kAAngular The angular acceleration gain in volts per (radians per
* second squared).
* @param trackwidth The distance between the differential drive's left and
* right wheels, in meters.
* @throws domain_error if kVLinear <= 0, kALinear <= 0, kVAngular <= 0,
* kAAngular <= 0, or trackwidth <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
static constexpr LinearSystem<2, 2, 2> IdentifyDrivetrainSystem(
decltype(1_V / 1_mps) kVLinear, decltype(1_V / 1_mps_sq) kALinear,
decltype(1_V / 1_rad_per_s) kVAngular,
decltype(1_V / 1_rad_per_s_sq) kAAngular,
wpi::units::meter_t trackwidth) {
if (kVLinear <= decltype(kVLinear){0}) {
throw std::domain_error("Kv,linear must be greater than zero.");
}
if (kALinear <= decltype(kALinear){0}) {
throw std::domain_error("Ka,linear must be greater than zero.");
}
if (kVAngular <= decltype(kVAngular){0}) {
throw std::domain_error("Kv,angular must be greater than zero.");
}
if (kAAngular <= decltype(kAAngular){0}) {
throw std::domain_error("Ka,angular must be greater than zero.");
}
if (trackwidth <= 0_m) {
throw std::domain_error("r must be greater than zero.");
}
// We want to find a factor to include in Kv,angular that will convert
// `u = Kv,angular omega` to `u = Kv,angular v`.
//
// v = omega r
// omega = v/r
// omega = 1/r v
// omega = 1/(trackwidth/2) v
// omega = 2/trackwidth v
//
// So multiplying by 2/trackwidth converts the angular gains from V/(rad/s)
// to V/(m/s).
return IdentifyDrivetrainSystem(kVLinear, kALinear,
kVAngular * 2.0 / trackwidth * 1_rad,
kAAngular * 2.0 / trackwidth * 1_rad);
}
/**
* Create a state-space model of a flywheel system, the states of the system
* are [angular velocity], inputs are [voltage], and outputs are [angular
* velocity].
*
* @param motor The motor (or gearbox) attached to the flywheel.
* @param J The moment of inertia J of the flywheel.
* @param gearing Gear ratio from motor to flywheel.
* @param motor The motor (or gearbox) attached to the arm.
* @param J The moment of inertia J of the arm.
* @param gearing Gear ratio from motor to arm (greater than 1 is a
* reduction).
* @throws std::domain_error if J <= 0 or gearing <= 0.
*/
static constexpr LinearSystem<1, 1, 1> FlywheelSystem(
DCMotor motor, wpi::units::kilogram_square_meter_t J, double gearing) {
if (J <= 0_kg_sq_m) {
throw std::domain_error("J must be greater than zero.");
}
if (gearing <= 0.0) {
throw std::domain_error("gearing must be greater than zero.");
}
Matrixd<1, 1> A{
{(-gcem::pow(gearing, 2) * motor.Kt / (motor.Kv * motor.R * J))
.value()}};
Matrixd<1, 1> B{{(gearing * motor.Kt / (motor.R * J)).value()}};
Matrixd<1, 1> C{{1.0}};
Matrixd<1, 1> D{{0.0}};
return LinearSystem<1, 1, 1>(A, B, C, D);
}
/**
* Create a state-space model of a DC motor system. The states of the system
* are [angular position, angular velocity]ᵀ, inputs are [voltage], and
* outputs are [angular position, angular velocity]ᵀ.
*
* @param motor The motor (or gearbox) attached to the system.
* @param J the moment of inertia J of the DC motor.
* @param gearing Gear ratio from motor to output.
* @throws std::domain_error if J <= 0 or gearing <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
static constexpr LinearSystem<2, 1, 2> DCMotorSystem(
static constexpr LinearSystem<2, 1, 2> SingleJointedArmFromPhysicalConstants(
DCMotor motor, wpi::units::kilogram_square_meter_t J, double gearing) {
if (J <= 0_kg_sq_m) {
throw std::domain_error("J must be greater than zero.");
@@ -370,32 +199,21 @@ class WPILIB_DLLEXPORT LinearSystemId {
}
/**
* Create a state-space model of a DC motor system from its kV
* (volts/(unit/sec)) and kA (volts/(unit/sec²)). These constants can be
* found using SysId. the states of the system are [angular position, angular
* velocity]ᵀ, inputs are [voltage], and outputs are [angular position,
* angular velocity]ᵀ.
* Creates a single-jointed arm state-space model from SysId constants kᵥ
* (V/(rad/s)) and kₐ (V/(rad/s²)) from the feedforward model u = kᵥv + kₐa.
*
* You MUST use an SI unit (i.e. meters or radians) for the Distance template
* argument. You may still use non-SI units (such as feet or inches) for the
* actual method arguments; they will automatically be converted to SI
* internally.
*
* The parameters provided by the user are from this feedforward model:
*
* u = K_v v + K_a a
* The states are [position, velocity], the inputs are [voltage], and the
* outputs are [position, velocity].
*
* @param kV The velocity gain, in volts/(unit/sec).
* @param kA The acceleration gain, in volts/(unit/sec²).
*
* @throws std::domain_error if kV < 0 or kA <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
template <typename Distance>
requires std::same_as<wpi::units::meter, Distance> ||
std::same_as<wpi::units::radian, Distance>
static constexpr LinearSystem<2, 1, 2> DCMotorSystem(
decltype(1_V / Velocity_t<Distance>(1)) kV,
decltype(1_V / Acceleration_t<Distance>(1)) kA) {
static constexpr LinearSystem<2, 1, 2> SingleJointedArmFromSysId(
decltype(1_V / 1_rad_per_s) kV, decltype(1_V / 1_rad_per_s_sq) kA) {
if (kV < decltype(kV){0}) {
throw std::domain_error("Kv must be greater than or equal to zero.");
}
@@ -404,7 +222,7 @@ class WPILIB_DLLEXPORT LinearSystemId {
}
Matrixd<2, 2> A{{0.0, 1.0}, {0.0, -kV.value() / kA.value()}};
Matrixd<2, 1> B{0.0, 1.0 / kA.value()};
Matrixd<2, 1> B{{0.0}, {1.0 / kA.value()}};
Matrixd<2, 2> C{{1.0, 0.0}, {0.0, 1.0}};
Matrixd<2, 1> D{{0.0}, {0.0}};
@@ -412,21 +230,23 @@ class WPILIB_DLLEXPORT LinearSystemId {
}
/**
* Create a state-space model of differential drive drivetrain. In this model,
* the states are [left velocity, right velocity]ᵀ, the inputs are [left
* Creates a differential drive state-space model from physical constants.
*
* The states are [left velocity, right velocity], the inputs are [left
* voltage, right voltage], and the outputs are [left velocity, right
* velocity]ᵀ.
* velocity].
*
* @param motor The motor (or gearbox) driving the drivetrain.
* @param mass The mass of the robot in kilograms.
* @param r The radius of the wheels in meters.
* @param rb The radius of the base (half of the trackwidth), in meters.
* @param J The moment of inertia of the robot.
* @param gearing Gear ratio from motor to wheel.
* @param gearing Gear ratio from motor to wheel (greater than 1 is a
* reduction).
* @throws std::domain_error if mass <= 0, r <= 0, rb <= 0, J <= 0, or
* gearing <= 0.
*/
static constexpr LinearSystem<2, 2, 2> DrivetrainVelocitySystem(
static constexpr LinearSystem<2, 2, 2> DifferentialDriveFromPhysicalConstants(
const DCMotor& motor, wpi::units::kilogram_t mass, wpi::units::meter_t r,
wpi::units::meter_t rb, wpi::units::kilogram_square_meter_t J,
double gearing) {
@@ -465,6 +285,119 @@ class WPILIB_DLLEXPORT LinearSystemId {
return LinearSystem<2, 2, 2>(A, B, C, D);
}
/**
* Creates a differential drive state-space model from SysId constants kᵥ and
* kₐ in both linear {(V/(m/s), (V/(m/s²))} and angular {(V/(rad/s),
* (V/(rad/s²))} cases.
*
* The states are [left velocity, right velocity], the inputs are [left
* voltage, right voltage], and the outputs are [left velocity, right
* velocity].
*
* @param kVLinear The linear velocity gain in volts per (meters per second).
* @param kALinear The linear acceleration gain in volts per (meters per
* second squared).
* @param kVAngular The angular velocity gain in volts per (meters per
* second).
* @param kAAngular The angular acceleration gain in volts per (meters per
* second squared).
* @throws domain_error if kVLinear <= 0, kALinear <= 0, kVAngular <= 0,
* or kAAngular <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
static constexpr LinearSystem<2, 2, 2> DifferentialDriveFromSysId(
decltype(1_V / 1_mps) kVLinear, decltype(1_V / 1_mps_sq) kALinear,
decltype(1_V / 1_mps) kVAngular, decltype(1_V / 1_mps_sq) kAAngular) {
if (kVLinear <= decltype(kVLinear){0}) {
throw std::domain_error("Kv,linear must be greater than zero.");
}
if (kALinear <= decltype(kALinear){0}) {
throw std::domain_error("Ka,linear must be greater than zero.");
}
if (kVAngular <= decltype(kVAngular){0}) {
throw std::domain_error("Kv,angular must be greater than zero.");
}
if (kAAngular <= decltype(kAAngular){0}) {
throw std::domain_error("Ka,angular must be greater than zero.");
}
double A1 = -0.5 * (kVLinear.value() / kALinear.value() +
kVAngular.value() / kAAngular.value());
double A2 = -0.5 * (kVLinear.value() / kALinear.value() -
kVAngular.value() / kAAngular.value());
double B1 = 0.5 / kALinear.value() + 0.5 / kAAngular.value();
double B2 = 0.5 / kALinear.value() - 0.5 / kAAngular.value();
Matrixd<2, 2> A{{A1, A2}, {A2, A1}};
Matrixd<2, 2> B{{B1, B2}, {B2, B1}};
Matrixd<2, 2> C{{1.0, 0.0}, {0.0, 1.0}};
Matrixd<2, 2> D{{0.0, 0.0}, {0.0, 0.0}};
return LinearSystem<2, 2, 2>(A, B, C, D);
}
/**
* Creates a differential drive state-space model from SysId constants kᵥ and
* kₐ in both linear {(V/(m/s), (V/(m/s²))} and angular {(V/(rad/s),
* (V/(rad/s²))} cases.
*
* The states are [left velocity, right velocity], the inputs are [left
* voltage, right voltage], and the outputs are [left velocity, right
* velocity].
*
* @param kVLinear The linear velocity gain in volts per (meters per
* second).
* @param kALinear The linear acceleration gain in volts per (meters per
* second squared).
* @param kVAngular The angular velocity gain in volts per (radians per
* second).
* @param kAAngular The angular acceleration gain in volts per (radians per
* second squared).
* @param trackwidth The distance between the differential drive's left and
* right wheels, in meters.
* @throws domain_error if kVLinear <= 0, kALinear <= 0, kVAngular <= 0,
* kAAngular <= 0, or trackwidth <= 0.
* @see <a
* href="https://github.com/wpilibsuite/allwpilib/tree/main/sysid">https://github.com/wpilibsuite/allwpilib/tree/main/sysid</a>
*/
static constexpr LinearSystem<2, 2, 2> DifferentialDriveFromSysId(
decltype(1_V / 1_mps) kVLinear, decltype(1_V / 1_mps_sq) kALinear,
decltype(1_V / 1_rad_per_s) kVAngular,
decltype(1_V / 1_rad_per_s_sq) kAAngular,
wpi::units::meter_t trackwidth) {
if (kVLinear <= decltype(kVLinear){0}) {
throw std::domain_error("Kv,linear must be greater than zero.");
}
if (kALinear <= decltype(kALinear){0}) {
throw std::domain_error("Ka,linear must be greater than zero.");
}
if (kVAngular <= decltype(kVAngular){0}) {
throw std::domain_error("Kv,angular must be greater than zero.");
}
if (kAAngular <= decltype(kAAngular){0}) {
throw std::domain_error("Ka,angular must be greater than zero.");
}
if (trackwidth <= 0_m) {
throw std::domain_error("r must be greater than zero.");
}
// We want to find a factor to include in Kv,angular that will convert
// `u = Kv,angular omega` to `u = Kv,angular v`.
//
// v = omega r
// omega = v/r
// omega = 1/r v
// omega = 1/(trackwidth/2) v
// omega = 2/trackwidth v
//
// So multiplying by 2/trackwidth converts the angular gains from V/(rad/s)
// to V/(m/s).
return DifferentialDriveFromSysId(kVLinear, kALinear,
kVAngular * 2.0 / trackwidth * 1_rad,
kAAngular * 2.0 / trackwidth * 1_rad);
}
};
} // namespace wpi::math

4
wpimath/src/main/native/include/wpi/math/system/plant/proto/DCMotorProto.hpp → wpimath/src/main/native/include/wpi/math/system/proto/DCMotorProto.hpp
View File

@@ -4,10 +4,10 @@
#pragma once
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/util/SymbolExports.hpp"
#include "wpi/util/protobuf/Protobuf.hpp"
#include "wpimath/protobuf/plant.npb.h"
#include "wpimath/protobuf/system.npb.h"
template <>
struct WPILIB_DLLEXPORT wpi::util::Protobuf<wpi::math::DCMotor> {

2
wpimath/src/main/native/include/wpi/math/system/plant/struct/DCMotorStruct.hpp → wpimath/src/main/native/include/wpi/math/system/struct/DCMotorStruct.hpp
View File

@@ -4,7 +4,7 @@
#pragma once
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/util/SymbolExports.hpp"
#include "wpi/util/struct/Struct.hpp"

13
wpimath/src/main/proto/plant.proto
View File

@@ -1,13 +0,0 @@
syntax = "proto3";
package wpi.proto;
option java_package = "org.wpilib.math.proto";
message ProtobufDCMotor {
double nominal_voltage = 1;
double stall_torque = 2;
double stall_current = 3;
double free_current = 4;
double free_speed = 5;
}

8
wpimath/src/main/proto/system.proto
View File

@@ -6,6 +6,14 @@ import "wpimath.proto";
option java_package = "org.wpilib.math.proto";
message ProtobufDCMotor {
double nominal_voltage = 1;
double stall_torque = 2;
double stall_current = 3;
double free_current = 4;
double free_speed = 5;
}
message ProtobufLinearSystem {
uint32 num_states = 1;
uint32 num_inputs = 2;

6
wpimath/src/main/python/pyproject.toml
View File

@@ -1560,17 +1560,15 @@ SplineHelper = "wpi/math/spline/SplineHelper.hpp"
SplineParameterizer = "wpi/math/spline/SplineParameterizer.hpp"
# wpi/math/system
DCMotor = "wpi/math/system/DCMotor.hpp"
# Discretization = "wpi/math/system/Discretization.hpp"
LinearSystem = "wpi/math/system/LinearSystem.hpp"
LinearSystemLoop = "wpi/math/system/LinearSystemLoop.hpp"
# LinearSystemUtil = "wpi/math/system/LinearSystemUtil.hpp"
Models = "wpi/math/system/Models.hpp"
# NumericalIntegration = "wpi/math/system/NumericalIntegration.hpp"
# NumericalJacobian = "wpi/math/system/NumericalJacobian.hpp"
# wpi/math/system/plant
DCMotor = "wpi/math/system/plant/DCMotor.hpp"
LinearSystemId = "wpi/math/system/plant/LinearSystemId.hpp"
# wpi/math/trajectory
ExponentialProfile = "wpi/math/trajectory/ExponentialProfile.hpp"
Trajectory = "wpi/math/trajectory/Trajectory.hpp"

4
wpimath/src/main/python/semiwrap/ElevatorFeedforward.yml
View File

@@ -10,10 +10,6 @@ classes:
wpi::units::volt_t, wpi::units::volt_t, wpi::units::unit_t<kv_unit>, wpi::units::unit_t<ka_unit>:
Calculate:
overloads:
wpi::units::unit_t<Velocity>, wpi::units::unit_t<Acceleration> [const]:
ignore: true
wpi::units::unit_t<Velocity>, wpi::units::unit_t<Velocity>, wpi::units::second_t [const]:
ignore: true
wpi::units::unit_t<Velocity> [const]:
wpi::units::unit_t<Velocity>, wpi::units::unit_t<Velocity> [const]:
MaxAchievableVelocity:

59
wpimath/src/main/python/semiwrap/LinearSystemId.yml
View File

@@ -1,59 +0,0 @@
classes:
wpi::math::LinearSystemId:
typealias:
- kv_meters = wpi::units::unit_t<wpi::units::compound_unit<wpi::units::volts, wpi::units::inverse<wpi::units::meters_per_second>>>
- kv_radians = wpi::units::unit_t<wpi::units::compound_unit<wpi::units::volts, wpi::units::inverse<wpi::units::radians_per_second>>>
- ka_meters = wpi::units::unit_t<wpi::units::compound_unit<wpi::units::volts, wpi::units::inverse<wpi::units::meters_per_second_squared>>>
- ka_radians = wpi::units::unit_t<wpi::units::compound_unit<wpi::units::volts, wpi::units::inverse<wpi::units::radians_per_second_squared>>>
methods:
ElevatorSystem:
SingleJointedArmSystem:
IdentifyVelocitySystem:
rename: identifyVelocitySystemMeters
cpp_code: |
[](kv_meters kV, ka_meters kA) {
return wpi::math::LinearSystemId::IdentifyVelocitySystem<wpi::units::meter>(kV, kA);
}
IdentifyPositionSystem:
rename: identifyPositionSystemMeters
cpp_code: |
[](kv_meters kV, ka_meters kA) {
return wpi::math::LinearSystemId::IdentifyPositionSystem<wpi::units::meter>(kV, kA);
}
IdentifyDrivetrainSystem:
overloads:
decltype(1_V/1_mps), decltype(1_V/1_mps_sq), decltype(1_V/1_mps), decltype(1_V/1_mps_sq):
cpp_code: |
[](kv_meters kVlinear, ka_meters kAlinear, kv_meters kVangular, ka_meters kAangular) {
return wpi::math::LinearSystemId::IdentifyDrivetrainSystem(kVlinear, kAlinear, kVangular, kAangular);
}
decltype(1_V/1_mps), decltype(1_V/1_mps_sq), decltype(1_V/1_rad_per_s), decltype(1_V/1_rad_per_s_sq), wpi::units::meter_t:
cpp_code: |
[](kv_meters kVlinear, ka_meters kAlinear, kv_radians kVangular, ka_radians kAangular, wpi::units::meter_t trackWidth) {
return wpi::math::LinearSystemId::IdentifyDrivetrainSystem(kVlinear, kAlinear, kVangular, kAangular, trackWidth);
}
FlywheelSystem:
DCMotorSystem:
overloads:
DCMotor, wpi::units::kilogram_square_meter_t, double:
decltype(1_V/Velocity_t<Distance> (1)), decltype(1_V/Acceleration_t<Distance> (1)):
cpp_code: |
[](kv_meters kv, ka_meters ka) {
return wpi::math::LinearSystemId::DCMotorSystem<wpi::units::meter>(kv, ka);
}
DrivetrainVelocitySystem:
inline_code: |
.def_static("DCMotorSystemRadians", [](kv_radians kV, ka_radians kA) {
return wpi::math::LinearSystemId::DCMotorSystem<wpi::units::radian>(kV, kA);
}, py::arg("kV"), py::arg("kA"), release_gil()
)
.def_static("identifyVelocitySystemRadians", [](kv_radians kV, ka_radians kA) {
return wpi::math::LinearSystemId::IdentifyVelocitySystem<wpi::units::radian>(kV, kA);
}, py::arg("kV"), py::arg("kA"), release_gil()
)
.def_static("identifyPositionSystemRadians", [](kv_radians kV, ka_radians kA) {
return wpi::math::LinearSystemId::IdentifyPositionSystem<wpi::units::radian>(kV, kA);
}, py::arg("kV"), py::arg("kA"), release_gil()
)

14
wpimath/src/main/python/semiwrap/Models.yml Normal file
View File

@@ -0,0 +1,14 @@
classes:
wpi::math::Models:
methods:
FlywheelFromPhysicalConstants:
FlywheelFromSysId:
ElevatorFromPhysicalConstants:
ElevatorFromSysId:
SingleJointedArmFromPhysicalConstants:
SingleJointedArmFromSysId:
DifferentialDriveFromPhysicalConstants:
DifferentialDriveFromSysId:
overloads:
decltype(1_V/1_mps), decltype(1_V/1_mps_sq), decltype(1_V/1_mps), decltype(1_V/1_mps_sq):
decltype(1_V/1_mps), decltype(1_V/1_mps_sq), decltype(1_V/1_rad_per_s), decltype(1_V/1_rad_per_s_sq), wpi::units::meter_t:

4
wpimath/src/main/python/wpimath/__init__.py
View File

@@ -60,7 +60,6 @@ from ._wpimath import (
LinearQuadraticRegulator_2_1,
LinearQuadraticRegulator_2_2,
LinearQuadraticRegulator_3_2,
LinearSystemId,
LinearSystemLoop_1_1_1,
LinearSystemLoop_2_1_1,
LinearSystemLoop_2_1_2,
@@ -94,6 +93,7 @@ from ._wpimath import (
MecanumDriveWheelPositions,
MecanumDriveWheelSpeeds,
MedianFilter,
Models,
PIDController,
Pose2d,
Pose3d,
@@ -247,7 +247,6 @@ __all__ = [
"LinearQuadraticRegulator_2_1",
"LinearQuadraticRegulator_2_2",
"LinearQuadraticRegulator_3_2",
"LinearSystemId",
"LinearSystemLoop_1_1_1",
"LinearSystemLoop_2_1_1",
"LinearSystemLoop_2_1_2",
@@ -281,6 +280,7 @@ __all__ = [
"MecanumDriveWheelPositions",
"MecanumDriveWheelSpeeds",
"MedianFilter",
"Models",
"PIDController",
"Pose2d",
"Pose3d",

10
wpimath/src/test/java/org/wpilib/math/controller/DifferentialDriveAccelerationLimiterTest.java
View File

@@ -14,7 +14,7 @@ import org.wpilib.math.linalg.Matrix;
import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.system.Models;
class DifferentialDriveAccelerationLimiterTest {
@Test
@@ -24,7 +24,7 @@ class DifferentialDriveAccelerationLimiterTest {
final double maxA = 2.0;
final double maxAlpha = 2.0;
var plant = LinearSystemId.identifyDrivetrainSystem(1.0, 1.0, 1.0, 1.0);
var plant = Models.differentialDriveFromSysId(1.0, 1.0, 1.0, 1.0);
var accelLimiter = new DifferentialDriveAccelerationLimiter(plant, trackwidth, maxA, maxAlpha);
@@ -114,7 +114,7 @@ class DifferentialDriveAccelerationLimiterTest {
final double trackwidth = 0.9;
final double dt = 0.005;
var plant = LinearSystemId.identifyDrivetrainSystem(1.0, 1.0, 1.0, 1.0);
var plant = Models.differentialDriveFromSysId(1.0, 1.0, 1.0, 1.0);
// Limits are so high, they don't get hit, so states of constrained and
// unconstrained systems should match
@@ -178,7 +178,7 @@ class DifferentialDriveAccelerationLimiterTest {
final double maxA = 2.0;
final double maxAlpha = 2.0;
var plant = LinearSystemId.identifyDrivetrainSystem(1.0, 1.0, 1.0, 1.0);
var plant = Models.differentialDriveFromSysId(1.0, 1.0, 1.0, 1.0);
var accelLimiter =
new DifferentialDriveAccelerationLimiter(plant, trackwidth, minA, maxA, maxAlpha);
@@ -237,7 +237,7 @@ class DifferentialDriveAccelerationLimiterTest {
@Test
void testMinAccelGreaterThanMaxAccel() {
var plant = LinearSystemId.identifyDrivetrainSystem(1.0, 1.0, 1.0, 1.0);
var plant = Models.differentialDriveFromSysId(1.0, 1.0, 1.0, 1.0);
assertDoesNotThrow(() -> new DifferentialDriveAccelerationLimiter(plant, 1, -1, 1, 1e3));
assertThrows(
IllegalArgumentException.class,

7
wpimath/src/test/java/org/wpilib/math/controller/DifferentialDriveFeedforwardTest.java
View File

@@ -12,7 +12,7 @@ import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.system.LinearSystem;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.system.Models;
class DifferentialDriveFeedforwardTest {
private static final double kVLinear = 1.0;
@@ -27,8 +27,7 @@ class DifferentialDriveFeedforwardTest {
DifferentialDriveFeedforward differentialDriveFeedforward =
new DifferentialDriveFeedforward(kVLinear, kALinear, kVAngular, kAAngular, trackwidth);
LinearSystem<N2, N2, N2> plant =
LinearSystemId.identifyDrivetrainSystem(
kVLinear, kALinear, kVAngular, kAAngular, trackwidth);
Models.differentialDriveFromSysId(kVLinear, kALinear, kVAngular, kAAngular, trackwidth);
for (int currentLeftVelocity = -4; currentLeftVelocity <= 4; currentLeftVelocity += 2) {
for (int currentRightVelocity = -4; currentRightVelocity <= 4; currentRightVelocity += 2) {
for (int nextLeftVelocity = -4; nextLeftVelocity <= 4; nextLeftVelocity += 2) {
@@ -58,7 +57,7 @@ class DifferentialDriveFeedforwardTest {
DifferentialDriveFeedforward differentialDriveFeedforward =
new DifferentialDriveFeedforward(kVLinear, kALinear, kVAngular, kAAngular);
LinearSystem<N2, N2, N2> plant =
LinearSystemId.identifyDrivetrainSystem(kVLinear, kALinear, kVAngular, kAAngular);
Models.differentialDriveFromSysId(kVLinear, kALinear, kVAngular, kAAngular);
for (int currentLeftVelocity = -4; currentLeftVelocity <= 4; currentLeftVelocity += 2) {
for (int currentRightVelocity = -4; currentRightVelocity <= 4; currentRightVelocity += 2) {
for (int nextLeftVelocity = -4; nextLeftVelocity <= 4; nextLeftVelocity += 2) {

8
wpimath/src/test/java/org/wpilib/math/controller/ImplicitModelFollowerTest.java
View File

@@ -12,14 +12,14 @@ import org.wpilib.math.linalg.Matrix;
import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.system.Models;
class ImplicitModelFollowerTest {
@Test
void testSameModel() {
final double dt = 0.005;
var plant = LinearSystemId.identifyDrivetrainSystem(1.0, 1.0, 1.0, 1.0);
var plant = Models.differentialDriveFromSysId(1.0, 1.0, 1.0, 1.0);
var imf = new ImplicitModelFollower<>(plant, plant);
@@ -61,10 +61,10 @@ class ImplicitModelFollowerTest {
void testSlowerRefModel() {
final double dt = 0.005;
var plant = LinearSystemId.identifyDrivetrainSystem(1.0, 1.0, 1.0, 1.0);
var plant = Models.differentialDriveFromSysId(1.0, 1.0, 1.0, 1.0);
// Linear acceleration is slower, but angular acceleration is the same
var plantRef = LinearSystemId.identifyDrivetrainSystem(1.0, 2.0, 1.0, 1.0);
var plantRef = Models.differentialDriveFromSysId(1.0, 2.0, 1.0, 1.0);
var imf = new ImplicitModelFollower<>(plant, plantRef);

4
wpimath/src/test/java/org/wpilib/math/controller/LTVDifferentialDriveControllerTest.java
View File

@@ -18,8 +18,8 @@ import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.numbers.N5;
import org.wpilib.math.system.LinearSystem;
import org.wpilib.math.system.Models;
import org.wpilib.math.system.NumericalIntegration;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.trajectory.TrajectoryConfig;
import org.wpilib.math.trajectory.TrajectoryGenerator;
import org.wpilib.math.util.MathUtil;
@@ -52,7 +52,7 @@ class LTVDifferentialDriveControllerTest {
private static final double kAngularV = 1.382; // V/(m/s)
private static final double kAngularA = 0.08495; // V/(m/s²)
private static final LinearSystem<N2, N2, N2> plant =
LinearSystemId.identifyDrivetrainSystem(kLinearV, kLinearA, kAngularV, kAngularA);
Models.differentialDriveFromSysId(kLinearV, kLinearA, kAngularV, kAngularA);
private static final double kTrackwidth = 0.9;
private static Matrix<N5, N1> dynamics(Matrix<N5, N1> x, Matrix<N2, N1> u) {

12
wpimath/src/test/java/org/wpilib/math/controller/LinearQuadraticRegulatorTest.java
View File

@@ -10,9 +10,9 @@ import org.junit.jupiter.api.Test;
import org.wpilib.math.linalg.MatBuilder;
import org.wpilib.math.linalg.Matrix;
import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.system.DCMotor;
import org.wpilib.math.system.Discretization;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.system.Models;
import org.wpilib.math.util.Nat;
import org.wpilib.math.util.Num;
@@ -25,7 +25,7 @@ class LinearQuadraticRegulatorTest {
var r = 0.0181864;
var G = 1.0;
var plant = LinearSystemId.createElevatorSystem(motors, m, r, G);
var plant = Models.elevatorFromPhysicalConstants(motors, m, r, G);
var qElms = VecBuilder.fill(0.02, 0.4);
var rElms = VecBuilder.fill(12.0);
@@ -42,7 +42,7 @@ class LinearQuadraticRegulatorTest {
var dt = 0.020;
var plant =
LinearSystemId.createElevatorSystem(
Models.elevatorFromPhysicalConstants(
DCMotor.getVex775Pro(4), 8.0, 0.75 * 25.4 / 1000.0, 14.67);
var K =
@@ -61,7 +61,7 @@ class LinearQuadraticRegulatorTest {
var r = 0.4;
var G = 100.0;
var plant = LinearSystemId.createSingleJointedArmSystem(motors, 1d / 3d * m * r * r, G);
var plant = Models.singleJointedArmFromPhysicalConstants(motors, 1d / 3d * m * r * r, G);
var qElms = VecBuilder.fill(0.01745, 0.08726);
var rElms = VecBuilder.fill(12.0);
@@ -160,7 +160,7 @@ class LinearQuadraticRegulatorTest {
var dt = 0.02;
var plant =
LinearSystemId.createElevatorSystem(
Models.elevatorFromPhysicalConstants(
DCMotor.getVex775Pro(4), 8.0, 0.75 * 25.4 / 1000.0, 14.67);
var regulator =

8
wpimath/src/test/java/org/wpilib/math/controller/LinearSystemLoopTest.java
View File

@@ -14,10 +14,10 @@ import org.wpilib.math.linalg.Matrix;
import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.system.DCMotor;
import org.wpilib.math.system.LinearSystem;
import org.wpilib.math.system.LinearSystemLoop;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.system.Models;
import org.wpilib.math.trajectory.TrapezoidProfile;
import org.wpilib.math.util.Nat;
@@ -27,7 +27,7 @@ class LinearSystemLoopTest {
private static final Random random = new Random();
LinearSystem<N2, N1, N2> m_plant =
LinearSystemId.createElevatorSystem(DCMotor.getVex775Pro(2), 5, 0.0181864, 1.0);
Models.elevatorFromPhysicalConstants(DCMotor.getVex775Pro(2), 5, 0.0181864, 1.0);
@SuppressWarnings("unchecked")
KalmanFilter<N2, N1, N1> m_observer =
@@ -95,7 +95,7 @@ class LinearSystemLoopTest {
@Test
void testFlywheelEnabled() {
LinearSystem<N1, N1, N1> plant =
LinearSystemId.createFlywheelSystem(DCMotor.getNEO(2), 0.00289, 1.0);
Models.flywheelFromPhysicalConstants(DCMotor.getNEO(2), 0.00289, 1.0);
KalmanFilter<N1, N1, N1> observer =
new KalmanFilter<>(
Nat.N1(), Nat.N1(), plant, VecBuilder.fill(1.0), VecBuilder.fill(kPositionStddev), kDt);

2
wpimath/src/test/java/org/wpilib/math/estimator/ExtendedKalmanFilterTest.java
View File

@@ -18,9 +18,9 @@ import org.wpilib.math.numbers.N2;
import org.wpilib.math.numbers.N3;
import org.wpilib.math.numbers.N5;
import org.wpilib.math.random.Normal;
import org.wpilib.math.system.DCMotor;
import org.wpilib.math.system.NumericalIntegration;
import org.wpilib.math.system.NumericalJacobian;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.trajectory.TrajectoryConfig;
import org.wpilib.math.trajectory.TrajectoryGenerator;
import org.wpilib.math.util.Nat;

6
wpimath/src/test/java/org/wpilib/math/estimator/KalmanFilterTest.java
View File

@@ -19,9 +19,9 @@ import org.wpilib.math.numbers.N1;
import org.wpilib.math.numbers.N2;
import org.wpilib.math.numbers.N3;
import org.wpilib.math.numbers.N6;
import org.wpilib.math.system.DCMotor;
import org.wpilib.math.system.LinearSystem;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.system.Models;
import org.wpilib.math.trajectory.TrajectoryConfig;
import org.wpilib.math.trajectory.TrajectoryGenerator;
import org.wpilib.math.util.Nat;
@@ -41,7 +41,7 @@ class KalmanFilterTest {
var m = 5.0;
var r = 0.0181864;
var G = 1.0;
elevatorPlant = LinearSystemId.createElevatorSystem(motors, m, r, G);
elevatorPlant = Models.elevatorFromPhysicalConstants(motors, m, r, G);
}
// A swerve drive system where the states are [x, y, theta, vx, vy, vTheta]ᵀ,

6
wpimath/src/test/java/org/wpilib/math/estimator/MerweUKFTest.java
View File

@@ -23,11 +23,11 @@ import org.wpilib.math.numbers.N3;
import org.wpilib.math.numbers.N4;
import org.wpilib.math.numbers.N5;
import org.wpilib.math.random.Normal;
import org.wpilib.math.system.DCMotor;
import org.wpilib.math.system.Discretization;
import org.wpilib.math.system.Models;
import org.wpilib.math.system.NumericalIntegration;
import org.wpilib.math.system.NumericalJacobian;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.trajectory.TrajectoryConfig;
import org.wpilib.math.trajectory.TrajectoryGenerator;
import org.wpilib.math.util.Nat;
@@ -222,7 +222,7 @@ class MerweUKFTest {
@Test
void testLinearUKF() {
var dt = 0.020;
var plant = LinearSystemId.identifyVelocitySystem(0.02, 0.006);
var plant = Models.flywheelFromSysId(0.02, 0.006);
var observer =
new MerweUKF<>(
Nat.N1(),

6
wpimath/src/test/java/org/wpilib/math/estimator/S3UKFTest.java
View File

@@ -23,11 +23,11 @@ import org.wpilib.math.numbers.N3;
import org.wpilib.math.numbers.N4;
import org.wpilib.math.numbers.N5;
import org.wpilib.math.random.Normal;
import org.wpilib.math.system.DCMotor;
import org.wpilib.math.system.Discretization;
import org.wpilib.math.system.Models;
import org.wpilib.math.system.NumericalIntegration;
import org.wpilib.math.system.NumericalJacobian;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.trajectory.TrajectoryConfig;
import org.wpilib.math.trajectory.TrajectoryGenerator;
import org.wpilib.math.util.Nat;
@@ -222,7 +222,7 @@ class S3UKFTest {
@Test
void testLinearUKF() {
var dt = 0.020;
var plant = LinearSystemId.identifyVelocitySystem(0.02, 0.006);
var plant = Models.flywheelFromSysId(0.02, 0.006);
var observer =
new S3UKF<>(
Nat.N1(),

79
wpimath/src/test/java/org/wpilib/math/system/LinearSystemIDTest.java → wpimath/src/test/java/org/wpilib/math/system/ModelsTest.java
View File

@@ -9,17 +9,36 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import org.wpilib.math.linalg.MatBuilder;
import org.wpilib.math.linalg.Matrix;
import org.wpilib.math.linalg.VecBuilder;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.plant.LinearSystemId;
import org.wpilib.math.util.Nat;
class LinearSystemIDTest {
class ModelsTest {
@Test
void testDrivetrainVelocitySystem() {
void testFlywheelFromPhysicalConstants() {
var model = Models.flywheelFromPhysicalConstants(DCMotor.getNEO(2), 0.00032, 1.0);
assertTrue(model.getA().isEqual(VecBuilder.fill(-26.87032), 0.001));
assertTrue(model.getB().isEqual(VecBuilder.fill(1354.166667), 0.001));
assertTrue(model.getC().isEqual(VecBuilder.fill(1), 0.001));
assertTrue(model.getD().isEqual(VecBuilder.fill(0), 0.001));
}
@Test
void testFlywheelFromSysId() {
var kv = 1.0;
var ka = 0.5;
var model = Models.flywheelFromSysId(kv, ka);
assertEquals(model.getA(), VecBuilder.fill(-kv / ka));
assertEquals(model.getB(), VecBuilder.fill(1 / ka));
}
@Test
void testDifferentialDriveFromPhysicalConstants() {
var model =
LinearSystemId.createDrivetrainVelocitySystem(DCMotor.getNEO(4), 70, 0.05, 0.4, 6.0, 6);
Models.differentialDriveFromPhysicalConstants(DCMotor.getNEO(4), 70, 0.05, 0.4, 6.0, 6);
assertTrue(
model
.getA()
@@ -41,8 +60,8 @@ class LinearSystemIDTest {
}
@Test
void testElevatorSystem() {
var model = LinearSystemId.createElevatorSystem(DCMotor.getNEO(2), 5, 0.05, 12);
void testElevatorFromPhysicalConstants() {
var model = Models.elevatorFromPhysicalConstants(DCMotor.getNEO(2), 5, 0.05, 12);
assertTrue(
model.getA().isEqual(MatBuilder.fill(Nat.N2(), Nat.N2(), 0, 1, 0, -99.05473), 0.001));
@@ -54,52 +73,24 @@ class LinearSystemIDTest {
}
@Test
void testFlywheelSystem() {
var model = LinearSystemId.createFlywheelSystem(DCMotor.getNEO(2), 0.00032, 1.0);
assertTrue(model.getA().isEqual(VecBuilder.fill(-26.87032), 0.001));
assertTrue(model.getB().isEqual(VecBuilder.fill(1354.166667), 0.001));
assertTrue(model.getC().isEqual(VecBuilder.fill(1), 0.001));
assertTrue(model.getD().isEqual(VecBuilder.fill(0), 0.001));
}
@Test
void testDCMotorSystem() {
var model = LinearSystemId.createDCMotorSystem(DCMotor.getNEO(2), 0.00032, 1.0);
assertTrue(
model.getA().isEqual(MatBuilder.fill(Nat.N2(), Nat.N2(), 0, 1, 0, -26.87032), 0.001));
assertTrue(model.getB().isEqual(VecBuilder.fill(0, 1354.166667), 0.001));
assertTrue(model.getC().isEqual(Matrix.eye(Nat.N2()), 0.001));
assertTrue(model.getD().isEqual(new Matrix<>(Nat.N2(), Nat.N1()), 0.001));
}
@Test
void testIdentifyPositionSystem() {
// By controls engineering in frc,
// x-dot = [0 1 | 0 -kv/ka] x = [0 | 1/ka] u
void testElevatorFromSysId() {
var kv = 1.0;
var ka = 0.5;
var model = LinearSystemId.identifyPositionSystem(kv, ka);
var model = Models.elevatorFromSysId(kv, ka);
assertEquals(model.getA(), MatBuilder.fill(Nat.N2(), Nat.N2(), 0, 1, 0, -kv / ka));
assertEquals(model.getB(), VecBuilder.fill(0, 1 / ka));
}
@Test
void testIdentifyVelocitySystem() {
// By controls engineering in frc,
// V = kv * velocity + ka * acceleration
// x-dot = -kv/ka * v + 1/ka \cdot V
void testSingleJointedArmFromSysId() {
var kv = 1.0;
var ka = 0.5;
var model = LinearSystemId.identifyVelocitySystem(kv, ka);
assertEquals(model.getA(), VecBuilder.fill(-kv / ka));
assertEquals(model.getB(), VecBuilder.fill(1 / ka));
var model = Models.singleJointedArmFromSysId(kv, ka);
assertTrue(
model.getA().isEqual(MatBuilder.fill(Nat.N2(), Nat.N2(), 0.0, 1.0, 0.0, -kv / ka), 0.001));
assertTrue(model.getB().isEqual(MatBuilder.fill(Nat.N2(), Nat.N1(), 0.0, 1.0 / ka), 0.001));
}
}

6
wpimath/src/test/java/org/wpilib/math/system/plant/proto/DCMotorProtoTest.java → wpimath/src/test/java/org/wpilib/math/system/proto/DCMotorProtoTest.java
View File

@@ -2,13 +2,13 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package org.wpilib.math.system.plant.proto;
package org.wpilib.math.system.proto;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import org.wpilib.math.proto.Plant.ProtobufDCMotor;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.proto.System.ProtobufDCMotor;
import org.wpilib.math.system.DCMotor;
class DCMotorProtoTest {
private static final DCMotor DATA = new DCMotor(1.91, 19.1, 1.74, 1.74, 22.9, 3);

4
wpimath/src/test/java/org/wpilib/math/system/plant/struct/DCMotorStructTest.java → wpimath/src/test/java/org/wpilib/math/system/struct/DCMotorStructTest.java
View File

@@ -2,14 +2,14 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package org.wpilib.math.system.plant.struct;
package org.wpilib.math.system.struct;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.junit.jupiter.api.Test;
import org.wpilib.math.system.plant.DCMotor;
import org.wpilib.math.system.DCMotor;
class DCMotorStructTest {
private static final DCMotor DATA = new DCMotor(1.91, 19.1, 1.74, 1.74, 22.9, 3);

7
wpimath/src/test/native/cpp/StateSpaceTest.cpp
View File

@@ -11,10 +11,10 @@
#include "wpi/math/controller/LinearQuadraticRegulator.hpp"
#include "wpi/math/estimator/KalmanFilter.hpp"
#include "wpi/math/linalg/EigenCore.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/LinearSystem.hpp"
#include "wpi/math/system/LinearSystemLoop.hpp"
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/units/time.hpp"
namespace wpi::math {
@@ -36,7 +36,8 @@ class StateSpaceTest : public testing::Test {
// Gear ratio
constexpr double G = 40.0 / 40.0;
return wpi::math::LinearSystemId::ElevatorSystem(motors, m, r, G).Slice(0);
return wpi::math::Models::ElevatorFromPhysicalConstants(motors, m, r, G)
.Slice(0);
}();
LinearQuadraticRegulator<2, 1> controller{plant, {0.02, 0.4}, {12.0}, kDt};
KalmanFilter<2, 1, 1> observer{plant, {0.05, 1.0}, {0.0001}, kDt};

18
wpimath/src/test/native/cpp/controller/DifferentialDriveAccelerationLimiterTest.cpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/units/math.hpp"
namespace wpi::math {
@@ -19,8 +19,8 @@ TEST(DifferentialDriveAccelerationLimiterTest, LowLimits) {
using Kv_t = decltype(1_V / 1_mps);
using Ka_t = decltype(1_V / 1_mps_sq);
auto plant = LinearSystemId::IdentifyDrivetrainSystem(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
auto plant = Models::DifferentialDriveFromSysId(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
DifferentialDriveAccelerationLimiter accelLimiter{plant, trackwidth, maxA,
maxAlpha};
@@ -111,8 +111,8 @@ TEST(DifferentialDriveAccelerationLimiterTest, HighLimits) {
using Kv_t = decltype(1_V / 1_mps);
using Ka_t = decltype(1_V / 1_mps_sq);
auto plant = LinearSystemId::IdentifyDrivetrainSystem(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
auto plant = Models::DifferentialDriveFromSysId(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
// Limits are so high, they don't get hit, so states of constrained and
// unconstrained systems should match
@@ -181,8 +181,8 @@ TEST(DifferentialDriveAccelerationLimiterTest, SeparateMinMaxLowLimits) {
using Kv_t = decltype(1_V / 1_mps);
using Ka_t = decltype(1_V / 1_mps_sq);
auto plant = LinearSystemId::IdentifyDrivetrainSystem(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
auto plant = Models::DifferentialDriveFromSysId(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
DifferentialDriveAccelerationLimiter accelLimiter{plant, trackwidth, minA,
maxA, maxAlpha};
@@ -240,8 +240,8 @@ TEST(DifferentialDriveAccelerationLimiterTest, SeparateMinMaxLowLimits) {
TEST(DifferentialDriveAccelerationLimiterTest, MinAccelGreaterThanMaxAccel) {
using Kv_t = decltype(1_V / 1_mps);
using Ka_t = decltype(1_V / 1_mps_sq);
auto plant = LinearSystemId::IdentifyDrivetrainSystem(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
auto plant = Models::DifferentialDriveFromSysId(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
EXPECT_NO_THROW({
DifferentialDriveAccelerationLimiter accelLimiter(plant, 1_m, 1_mps_sq,
1_rad_per_s_sq);

11
wpimath/src/test/native/cpp/controller/DifferentialDriveFeedforwardTest.cpp
View File

@@ -4,13 +4,10 @@
#include "wpi/math/controller/DifferentialDriveFeedforward.hpp"
#include <cmath>
#include <Eigen/Core>
#include <gtest/gtest.h>
#include "wpi/math/controller/LinearPlantInversionFeedforward.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/units/acceleration.hpp"
#include "wpi/units/length.hpp"
#include "wpi/units/time.hpp"
@@ -26,7 +23,7 @@ TEST(DifferentialDriveFeedforwardTest, CalculateWithTrackwidth) {
wpi::math::DifferentialDriveFeedforward differentialDriveFeedforward{
kVLinear, kALinear, kVAngular, kAAngular, trackwidth};
wpi::math::LinearSystem<2, 2, 2> plant =
wpi::math::LinearSystemId::IdentifyDrivetrainSystem(
wpi::math::Models::DifferentialDriveFromSysId(
kVLinear, kALinear, kVAngular, kAAngular, trackwidth);
for (auto currentLeftVelocity = -4_mps; currentLeftVelocity <= 4_mps;
currentLeftVelocity += 2_mps) {
@@ -60,8 +57,8 @@ TEST(DifferentialDriveFeedforwardTest, CalculateWithoutTrackwidth) {
wpi::math::DifferentialDriveFeedforward differentialDriveFeedforward{
kVLinear, kALinear, kVAngular, kAAngular};
wpi::math::LinearSystem<2, 2, 2> plant =
wpi::math::LinearSystemId::IdentifyDrivetrainSystem(kVLinear, kALinear,
kVAngular, kAAngular);
wpi::math::Models::DifferentialDriveFromSysId(kVLinear, kALinear,
kVAngular, kAAngular);
for (auto currentLeftVelocity = -4_mps; currentLeftVelocity <= 4_mps;
currentLeftVelocity += 2_mps) {
for (auto currentRightVelocity = -4_mps; currentRightVelocity <= 4_mps;

4
wpimath/src/test/native/cpp/controller/ElevatorFeedforwardTest.cpp
View File

@@ -4,15 +4,13 @@
#include "wpi/math/controller/ElevatorFeedforward.hpp"
#include <cmath>
#include <gtest/gtest.h>
#include "wpi/math/controller/LinearPlantInversionFeedforward.hpp"
#include "wpi/math/linalg/EigenCore.hpp"
#include "wpi/units/acceleration.hpp"
#include "wpi/units/length.hpp"
#include "wpi/units/time.hpp"
#include "wpi/units/velocity.hpp"
static constexpr auto Ks = 0.5_V;
static constexpr auto Kv = 1.5_V * 1_s / 1_m;

14
wpimath/src/test/native/cpp/controller/ImplicitModelFollowerTest.cpp
View File

@@ -6,7 +6,7 @@
#include <gtest/gtest.h>
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/Models.hpp"
namespace wpi::math {
@@ -15,8 +15,8 @@ TEST(ImplicitModelFollowerTest, SameModel) {
using Kv_t = decltype(1_V / 1_mps);
using Ka_t = decltype(1_V / 1_mps_sq);
auto plant = LinearSystemId::IdentifyDrivetrainSystem(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
auto plant = Models::DifferentialDriveFromSysId(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
ImplicitModelFollower<2, 2> imf{plant, plant};
@@ -60,12 +60,12 @@ TEST(ImplicitModelFollowerTest, SlowerRefModel) {
using Kv_t = decltype(1_V / 1_mps);
using Ka_t = decltype(1_V / 1_mps_sq);
auto plant = LinearSystemId::IdentifyDrivetrainSystem(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
auto plant = Models::DifferentialDriveFromSysId(Kv_t{1.0}, Ka_t{1.0},
Kv_t{1.0}, Ka_t{1.0});
// Linear acceleration is slower, but angular acceleration is the same
auto plantRef = LinearSystemId::IdentifyDrivetrainSystem(
Kv_t{1.0}, Ka_t{2.0}, Kv_t{1.0}, Ka_t{1.0});
auto plantRef = Models::DifferentialDriveFromSysId(Kv_t{1.0}, Ka_t{2.0},
Kv_t{1.0}, Ka_t{1.0});
ImplicitModelFollower<2, 2> imf{plant, plantRef};

4
wpimath/src/test/native/cpp/controller/LTVDifferentialDriveControllerTest.cpp
View File

@@ -8,8 +8,8 @@
#include <gtest/gtest.h>
#include "wpi/math/system/Models.hpp"
#include "wpi/math/system/NumericalIntegration.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/math/util/MathUtil.hpp"
#include "wpi/units/math.hpp"
@@ -46,7 +46,7 @@ static constexpr auto kLinearV = 3.02_V / 1_mps;
static constexpr auto kLinearA = 0.642_V / 1_mps_sq;
static constexpr auto kAngularV = 1.382_V / 1_mps;
static constexpr auto kAngularA = 0.08495_V / 1_mps_sq;
static auto plant = wpi::math::LinearSystemId::IdentifyDrivetrainSystem(
static auto plant = wpi::math::Models::DifferentialDriveFromSysId(
kLinearV, kLinearA, kAngularV, kAngularA);
static constexpr auto kTrackwidth = 0.9_m;

2
wpimath/src/test/native/cpp/controller/LinearPlantInversionFeedforwardTest.cpp
View File

@@ -4,8 +4,6 @@
#include "wpi/math/controller/LinearPlantInversionFeedforward.hpp"
#include <cmath>
#include <gtest/gtest.h>
#include "wpi/math/linalg/EigenCore.hpp"

17
wpimath/src/test/native/cpp/controller/LinearQuadraticRegulatorTest.cpp
View File

@@ -4,14 +4,12 @@
#include "wpi/math/controller/LinearQuadraticRegulator.hpp"
#include <cmath>
#include <gtest/gtest.h>
#include "wpi/math/linalg/EigenCore.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/LinearSystem.hpp"
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/units/time.hpp"
namespace wpi::math {
@@ -29,7 +27,8 @@ TEST(LinearQuadraticRegulatorTest, ElevatorGains) {
// Gear ratio
constexpr double G = 40.0 / 40.0;
return wpi::math::LinearSystemId::ElevatorSystem(motors, m, r, G).Slice(0);
return wpi::math::Models::ElevatorFromPhysicalConstants(motors, m, r, G)
.Slice(0);
}();
Matrixd<1, 2> K =
LinearQuadraticRegulator<2, 1>{plant, {0.02, 0.4}, {12.0}, 5_ms}.K();
@@ -51,7 +50,7 @@ TEST(LinearQuadraticRegulatorTest, ArmGains) {
// Gear ratio
constexpr double G = 100.0;
return wpi::math::LinearSystemId::SingleJointedArmSystem(
return wpi::math::Models::SingleJointedArmFromPhysicalConstants(
motors, 1.0 / 3.0 * m * r * r, G)
.Slice(0);
}();
@@ -77,7 +76,8 @@ TEST(LinearQuadraticRegulatorTest, FourMotorElevator) {
// Gear ratio
constexpr double G = 14.67;
return wpi::math::LinearSystemId::ElevatorSystem(motors, m, r, G).Slice(0);
return wpi::math::Models::ElevatorFromPhysicalConstants(motors, m, r, G)
.Slice(0);
}();
Matrixd<1, 2> K =
LinearQuadraticRegulator<2, 1>{plant, {0.1, 0.2}, {12.0}, 20_ms}.K();
@@ -179,7 +179,8 @@ TEST(LinearQuadraticRegulatorTest, LatencyCompensate) {
// Gear ratio
constexpr double G = 14.67;
return wpi::math::LinearSystemId::ElevatorSystem(motors, m, r, G).Slice(0);
return wpi::math::Models::ElevatorFromPhysicalConstants(motors, m, r, G)
.Slice(0);
}();
LinearQuadraticRegulator<2, 1> controller{plant, {0.1, 0.2}, {12.0}, 20_ms};

2
wpimath/src/test/native/cpp/controller/SimpleMotorFeedforwardTest.cpp
View File

@@ -4,8 +4,6 @@
#include "wpi/math/controller/SimpleMotorFeedforward.hpp"
#include <cmath>
#include <gtest/gtest.h>
#include "wpi/math/controller/LinearPlantInversionFeedforward.hpp"

1
wpimath/src/test/native/cpp/estimator/DifferentialDrivePoseEstimator3dTest.cpp
View File

@@ -16,7 +16,6 @@
#include "wpi/math/geometry/Rotation2d.hpp"
#include "wpi/math/kinematics/DifferentialDriveKinematics.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/math/util/StateSpaceUtil.hpp"
#include "wpi/units/angle.hpp"
#include "wpi/units/length.hpp"
#include "wpi/units/time.hpp"

1
wpimath/src/test/native/cpp/estimator/DifferentialDrivePoseEstimatorTest.cpp
View File

@@ -17,7 +17,6 @@
#include "wpi/math/geometry/Rotation2d.hpp"
#include "wpi/math/kinematics/DifferentialDriveKinematics.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/math/util/StateSpaceUtil.hpp"
#include "wpi/units/angle.hpp"
#include "wpi/units/length.hpp"
#include "wpi/units/time.hpp"

2
wpimath/src/test/native/cpp/estimator/ExtendedKalmanFilterTest.cpp
View File

@@ -12,8 +12,8 @@
#include "wpi/math/linalg/EigenCore.hpp"
#include "wpi/math/random/Normal.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/NumericalJacobian.hpp"
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/units/moment_of_inertia.hpp"

6
wpimath/src/test/native/cpp/estimator/KalmanFilterTest.cpp
View File

@@ -10,14 +10,14 @@
#include <Eigen/Core>
#include <gtest/gtest.h>
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/units/moment_of_inertia.hpp"
#include "wpi/units/time.hpp"
TEST(KalmanFilterTest, Flywheel) {
auto motor = wpi::math::DCMotor::NEO();
auto flywheel =
wpi::math::LinearSystemId::FlywheelSystem(motor, 1_kg_sq_m, 1.0);
wpi::math::Models::FlywheelFromPhysicalConstants(motor, 1_kg_sq_m, 1.0);
wpi::math::KalmanFilter<1, 1, 1> kf{flywheel, {1}, {1}, 5_ms};
}

9
wpimath/src/test/native/cpp/estimator/MerweUKFTest.cpp
View File

@@ -15,11 +15,11 @@
#include "wpi/math/estimator/AngleStatistics.hpp"
#include "wpi/math/linalg/EigenCore.hpp"
#include "wpi/math/random/Normal.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/Discretization.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/math/system/NumericalIntegration.hpp"
#include "wpi/math/system/NumericalJacobian.hpp"
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/units/moment_of_inertia.hpp"
@@ -183,9 +183,8 @@ TEST(MerweUKFTest, DriveConvergence) {
TEST(MerweUKFTest, LinearUKF) {
constexpr wpi::units::second_t dt = 20_ms;
auto plant =
wpi::math::LinearSystemId::IdentifyVelocitySystem<wpi::units::meters>(
0.02_V / 1_mps, 0.006_V / 1_mps_sq);
auto plant = wpi::math::Models::FlywheelFromSysId(0.02_V / 1_rad_per_s,
0.006_V / 1_rad_per_s_sq);
wpi::math::MerweUKF<1, 1, 1> observer{
[&](const wpi::math::Vectord<1>& x, const wpi::math::Vectord<1>& u) {
return plant.A() * x + plant.B() * u;

9
wpimath/src/test/native/cpp/estimator/S3UKFTest.cpp
View File

@@ -15,11 +15,11 @@
#include "wpi/math/estimator/AngleStatistics.hpp"
#include "wpi/math/linalg/EigenCore.hpp"
#include "wpi/math/random/Normal.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/Discretization.hpp"
#include "wpi/math/system/Models.hpp"
#include "wpi/math/system/NumericalIntegration.hpp"
#include "wpi/math/system/NumericalJacobian.hpp"
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/units/moment_of_inertia.hpp"
@@ -183,9 +183,8 @@ TEST(S3UKFTest, DriveConvergence) {
TEST(S3UKFTest, LinearUKF) {
constexpr wpi::units::second_t dt = 20_ms;
auto plant =
wpi::math::LinearSystemId::IdentifyVelocitySystem<wpi::units::meters>(
0.02_V / 1_mps, 0.006_V / 1_mps_sq);
auto plant = wpi::math::Models::FlywheelFromSysId(0.02_V / 1_rad_per_s,
0.006_V / 1_rad_per_s_sq);
wpi::math::S3UKF<1, 1, 1> observer{
[&](const wpi::math::Vectord<1>& x, const wpi::math::Vectord<1>& u) {
return plant.A() * x + plant.B() * u;

1
wpimath/src/test/native/cpp/estimator/SwerveDrivePoseEstimator3dTest.cpp
View File

@@ -16,7 +16,6 @@
#include "wpi/math/kinematics/SwerveDriveKinematics.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/util/print.hpp"
#include "wpi/util/timestamp.h"
void testFollowTrajectory(
const wpi::math::SwerveDriveKinematics<4>& kinematics,

1
wpimath/src/test/native/cpp/estimator/SwerveDrivePoseEstimatorTest.cpp
View File

@@ -17,7 +17,6 @@
#include "wpi/math/kinematics/SwerveDriveKinematics.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
#include "wpi/util/print.hpp"
#include "wpi/util/timestamp.h"
void testFollowTrajectory(
const wpi::math::SwerveDriveKinematics<4>& kinematics,

116
wpimath/src/test/native/cpp/system/LinearSystemIdTest.cpp → wpimath/src/test/native/cpp/system/ModelsTest.cpp
View File

@@ -2,22 +2,54 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include "wpi/math/system/plant/LinearSystemId.hpp"
#include "wpi/math/system/Models.hpp"
#include <gtest/gtest.h>
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/math/system/LinearSystem.hpp"
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/units/length.hpp"
#include "wpi/units/mass.hpp"
TEST(LinearSystemIDTest, IdentifyDrivetrainVelocitySystem) {
TEST(ModelsTest, FlywheelFromPhysicalConstants) {
#if __GNUC__ <= 11
auto model = wpi::math::LinearSystemId::DrivetrainVelocitySystem(
auto model = wpi::math::Models::FlywheelFromPhysicalConstants(
wpi::math::DCMotor::NEO(2), 0.00032_kg_sq_m, 1.0);
#else
constexpr auto model = wpi::math::Models::FlywheelFromPhysicalConstants(
wpi::math::DCMotor::NEO(2), 0.00032_kg_sq_m, 1.0);
#endif
ASSERT_TRUE(model.A().isApprox(wpi::math::Matrixd<1, 1>{-26.87032}, 0.001));
ASSERT_TRUE(model.B().isApprox(wpi::math::Matrixd<1, 1>{1354.166667}, 0.001));
ASSERT_TRUE(model.C().isApprox(wpi::math::Matrixd<1, 1>{1.0}, 0.001));
ASSERT_TRUE(model.D().isApprox(wpi::math::Matrixd<1, 1>{0.0}, 0.001));
}
TEST(ModelsTest, FlywheelFromSysId) {
constexpr double kv = 1.0;
constexpr double ka = 0.5;
#if __GNUC__ <= 11
auto model = wpi::math::Models::FlywheelFromSysId(kv * 1_V / 1_rad_per_s,
ka * 1_V / 1_rad_per_s_sq);
#else
constexpr auto model = wpi::math::Models::FlywheelFromSysId(
kv * 1_V / 1_rad_per_s, ka * 1_V / 1_rad_per_s_sq);
#endif
ASSERT_TRUE(model.A().isApprox(wpi::math::Matrixd<1, 1>{-kv / ka}, 0.001));
ASSERT_TRUE(model.B().isApprox(wpi::math::Matrixd<1, 1>{1.0 / ka}, 0.001));
}
TEST(ModelsTest, DifferentialDriveFromPhysicalConstants) {
#if __GNUC__ <= 11
auto model = wpi::math::Models::DifferentialDriveFromPhysicalConstants(
wpi::math::DCMotor::NEO(4), 70_kg, 0.05_m, 0.4_m, 6.0_kg_sq_m, 6.0);
#else
constexpr auto model = wpi::math::LinearSystemId::DrivetrainVelocitySystem(
wpi::math::DCMotor::NEO(4), 70_kg, 0.05_m, 0.4_m, 6.0_kg_sq_m, 6.0);
constexpr auto model =
wpi::math::Models::DifferentialDriveFromPhysicalConstants(
wpi::math::DCMotor::NEO(4), 70_kg, 0.05_m, 0.4_m, 6.0_kg_sq_m, 6.0);
#endif
ASSERT_TRUE(model.A().isApprox(
@@ -31,8 +63,8 @@ TEST(LinearSystemIDTest, IdentifyDrivetrainVelocitySystem) {
wpi::math::Matrixd<2, 2>{{0.0, 0.0}, {0.0, 0.0}}, 0.001));
}
TEST(LinearSystemIDTest, ElevatorSystem) {
auto model = wpi::math::LinearSystemId::ElevatorSystem(
TEST(ModelsTest, ElevatorFromPhysicalConstants) {
auto model = wpi::math::Models::ElevatorFromPhysicalConstants(
wpi::math::DCMotor::NEO(2), 5_kg, 0.05_m, 12)
.Slice(0);
ASSERT_TRUE(model.A().isApprox(
@@ -42,53 +74,16 @@ TEST(LinearSystemIDTest, ElevatorSystem) {
ASSERT_TRUE(model.D().isApprox(wpi::math::Matrixd<1, 1>{0.0}, 0.001));
}
TEST(LinearSystemIDTest, FlywheelSystem) {
#if __GNUC__ <= 11
auto model = wpi::math::LinearSystemId::FlywheelSystem(
wpi::math::DCMotor::NEO(2), 0.00032_kg_sq_m, 1.0);
#else
constexpr auto model = wpi::math::LinearSystemId::FlywheelSystem(
wpi::math::DCMotor::NEO(2), 0.00032_kg_sq_m, 1.0);
#endif
ASSERT_TRUE(model.A().isApprox(wpi::math::Matrixd<1, 1>{-26.87032}, 0.001));
ASSERT_TRUE(model.B().isApprox(wpi::math::Matrixd<1, 1>{1354.166667}, 0.001));
ASSERT_TRUE(model.C().isApprox(wpi::math::Matrixd<1, 1>{1.0}, 0.001));
ASSERT_TRUE(model.D().isApprox(wpi::math::Matrixd<1, 1>{0.0}, 0.001));
}
TEST(LinearSystemIDTest, DCMotorSystem) {
#if __GNUC__ <= 11
auto model = wpi::math::LinearSystemId::DCMotorSystem(
wpi::math::DCMotor::NEO(2), 0.00032_kg_sq_m, 1.0);
#else
constexpr auto model = wpi::math::LinearSystemId::DCMotorSystem(
wpi::math::DCMotor::NEO(2), 0.00032_kg_sq_m, 1.0);
#endif
ASSERT_TRUE(model.A().isApprox(
wpi::math::Matrixd<2, 2>{{0, 1}, {0, -26.87032}}, 0.001));
ASSERT_TRUE(
model.B().isApprox(wpi::math::Matrixd<2, 1>{0, 1354.166667}, 0.001));
ASSERT_TRUE(model.C().isApprox(
wpi::math::Matrixd<2, 2>{{1.0, 0.0}, {0.0, 1.0}}, 0.001));
ASSERT_TRUE(model.D().isApprox(wpi::math::Matrixd<2, 1>{0.0, 0.0}, 0.001));
}
TEST(LinearSystemIDTest, IdentifyPositionSystem) {
// By controls engineering in frc,
// x-dot = [0 1 | 0 -kv/ka] x = [0 | 1/ka] u
TEST(ModelsTest, ElevatorFromSysId) {
constexpr double kv = 1.0;
constexpr double ka = 0.5;
#if __GNUC__ <= 11
auto model =
wpi::math::LinearSystemId::IdentifyPositionSystem<wpi::units::meter>(
kv * 1_V / 1_mps, ka * 1_V / 1_mps_sq);
auto model = wpi::math::Models::ElevatorFromSysId(kv * 1_V / 1_mps,
ka * 1_V / 1_mps_sq);
#else
constexpr auto model =
wpi::math::LinearSystemId::IdentifyPositionSystem<wpi::units::meter>(
kv * 1_V / 1_mps, ka * 1_V / 1_mps_sq);
constexpr auto model = wpi::math::Models::ElevatorFromSysId(
kv * 1_V / 1_mps, ka * 1_V / 1_mps_sq);
#endif
ASSERT_TRUE(model.A().isApprox(
@@ -97,23 +92,20 @@ TEST(LinearSystemIDTest, IdentifyPositionSystem) {
model.B().isApprox(wpi::math::Matrixd<2, 1>{0.0, 1.0 / ka}, 0.001));
}
TEST(LinearSystemIDTest, IdentifyVelocitySystem) {
// By controls engineering in frc,
// V = kv * velocity + ka * acceleration
// x-dot = -kv/ka * v + 1/ka \cdot V
TEST(ModelsTest, SingleJointedArmFromSysId) {
constexpr double kv = 1.0;
constexpr double ka = 0.5;
#if __GNUC__ <= 11
auto model =
wpi::math::LinearSystemId::IdentifyVelocitySystem<wpi::units::meter>(
kv * 1_V / 1_mps, ka * 1_V / 1_mps_sq);
auto model = wpi::math::Models::SingleJointedArmFromSysId(
kv * 1_V / 1_rad_per_s, ka * 1_V / 1_rad_per_s_sq);
#else
constexpr auto model =
wpi::math::LinearSystemId::IdentifyVelocitySystem<wpi::units::meter>(
kv * 1_V / 1_mps, ka * 1_V / 1_mps_sq);
constexpr auto model = wpi::math::Models::SingleJointedArmFromSysId(
kv * 1_V / 1_rad_per_s, ka * 1_V / 1_rad_per_s_sq);
#endif
ASSERT_TRUE(model.A().isApprox(wpi::math::Matrixd<1, 1>{-kv / ka}, 0.001));
ASSERT_TRUE(model.B().isApprox(wpi::math::Matrixd<1, 1>{1.0 / ka}, 0.001));
ASSERT_TRUE(model.A().isApprox(
wpi::math::Matrixd<2, 2>{{0.0, 1.0}, {0.0, -kv / ka}}, 0.001));
ASSERT_TRUE(
model.B().isApprox(wpi::math::Matrixd<2, 1>{0.0, 1.0 / ka}, 0.001));
}

2
wpimath/src/test/native/cpp/system/plant/proto/DCMotorProtoTest.cpp → wpimath/src/test/native/cpp/system/proto/DCMotorProtoTest.cpp
View File

@@ -4,7 +4,7 @@
#include <gtest/gtest.h>
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/DCMotor.hpp"
#include "wpi/util/SmallVector.hpp"
using namespace wpi::math;

2
wpimath/src/test/native/cpp/system/plant/struct/DCMotorStructTest.cpp → wpimath/src/test/native/cpp/system/struct/DCMotorStructTest.cpp
View File

@@ -4,7 +4,7 @@
#include <gtest/gtest.h>
#include "wpi/math/system/plant/DCMotor.hpp"
#include "wpi/math/system/DCMotor.hpp"
using namespace wpi::math;