Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update wpilibc to use new NetworkTables package and interfaces.

Browse Source
This commit is contained in:
Peter Johnson
2017-09-02 00:17:43 -07:00
parent 4e80570c4c
commit 040a8c6bcc
74 changed files with 937 additions and 721 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
wpilibc/src/main/native/cpp/ADXL345_I2C.cpp
View File

@@ -85,15 +85,26 @@ std::string ADXL345_I2C::GetSmartDashboardType() const {
return "3AxisAccelerometer";
}
void ADXL345_I2C::InitTable(std::shared_ptr<ITable> subtable) {
void ADXL345_I2C::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
m_table = subtable;
UpdateTable();
if (m_table) {
m_xEntry = m_table->GetEntry("X");
m_yEntry = m_table->GetEntry("Y");
m_zEntry = m_table->GetEntry("Z");
UpdateTable();
} else {
m_xEntry = nt::NetworkTableEntry();
m_yEntry = nt::NetworkTableEntry();
m_zEntry = nt::NetworkTableEntry();
}
}
void ADXL345_I2C::UpdateTable() {
m_table->PutNumber("X", GetX());
m_table->PutNumber("Y", GetY());
m_table->PutNumber("Z", GetZ());
if (m_xEntry) m_xEntry.SetDouble(GetX());
if (m_yEntry) m_yEntry.SetDouble(GetY());
if (m_zEntry) m_zEntry.SetDouble(GetZ());
}
std::shared_ptr<ITable> ADXL345_I2C::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> ADXL345_I2C::GetTable() const {
return m_table;
}

29
wpilibc/src/main/native/cpp/ADXL345_SPI.cpp
View File

@@ -112,17 +112,26 @@ std::string ADXL345_SPI::GetSmartDashboardType() const {
return "3AxisAccelerometer";
}
void ADXL345_SPI::InitTable(std::shared_ptr<ITable> subtable) {
void ADXL345_SPI::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
m_table = subtable;
UpdateTable();
}
void ADXL345_SPI::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("X", GetX());
m_table->PutNumber("Y", GetY());
m_table->PutNumber("Z", GetZ());
if (m_table) {
m_xEntry = m_table->GetEntry("X");
m_yEntry = m_table->GetEntry("Y");
m_zEntry = m_table->GetEntry("Z");
UpdateTable();
} else {
m_xEntry = nt::NetworkTableEntry();
m_yEntry = nt::NetworkTableEntry();
m_zEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> ADXL345_SPI::GetTable() const { return m_table; }
void ADXL345_SPI::UpdateTable() {
if (m_xEntry) m_xEntry.SetDouble(GetX());
if (m_yEntry) m_yEntry.SetDouble(GetY());
if (m_zEntry) m_zEntry.SetDouble(GetZ());
}
std::shared_ptr<nt::NetworkTable> ADXL345_SPI::GetTable() const {
return m_table;
}

27
wpilibc/src/main/native/cpp/ADXL362.cpp
View File

@@ -167,17 +167,24 @@ std::string ADXL362::GetSmartDashboardType() const {
return "3AxisAccelerometer";
}
void ADXL362::InitTable(std::shared_ptr<ITable> subtable) {
void ADXL362::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
m_table = subtable;
UpdateTable();
}
void ADXL362::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("X", GetX());
m_table->PutNumber("Y", GetY());
m_table->PutNumber("Z", GetZ());
if (m_table) {
m_xEntry = m_table->GetEntry("X");
m_yEntry = m_table->GetEntry("Y");
m_zEntry = m_table->GetEntry("Z");
UpdateTable();
} else {
m_xEntry = nt::NetworkTableEntry();
m_yEntry = nt::NetworkTableEntry();
m_zEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> ADXL362::GetTable() const { return m_table; }
void ADXL362::UpdateTable() {
if (m_xEntry) m_xEntry.SetDouble(GetX());
if (m_yEntry) m_yEntry.SetDouble(GetY());
if (m_zEntry) m_zEntry.SetDouble(GetZ());
}
std::shared_ptr<nt::NetworkTable> ADXL362::GetTable() const { return m_table; }

16
wpilibc/src/main/native/cpp/AnalogAccelerometer.cpp
View File

@@ -117,9 +117,7 @@ void AnalogAccelerometer::SetZero(double zero) { m_zeroGVoltage = zero; }
double AnalogAccelerometer::PIDGet() { return GetAcceleration(); }
void AnalogAccelerometer::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", GetAcceleration());
}
if (m_valueEntry) m_valueEntry.SetDouble(GetAcceleration());
}
void AnalogAccelerometer::StartLiveWindowMode() {}
@@ -130,11 +128,17 @@ std::string AnalogAccelerometer::GetSmartDashboardType() const {
return "Accelerometer";
}
void AnalogAccelerometer::InitTable(std::shared_ptr<ITable> subTable) {
void AnalogAccelerometer::InitTable(
std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> AnalogAccelerometer::GetTable() const {
std::shared_ptr<nt::NetworkTable> AnalogAccelerometer::GetTable() const {
return m_table;
}

17
wpilibc/src/main/native/cpp/AnalogInput.cpp
View File

@@ -419,9 +419,7 @@ double AnalogInput::PIDGet() {
}
void AnalogInput::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", GetAverageVoltage());
}
if (m_valueEntry) m_valueEntry.SetDouble(GetAverageVoltage());
}
void AnalogInput::StartLiveWindowMode() {}
@@ -432,9 +430,16 @@ std::string AnalogInput::GetSmartDashboardType() const {
return "Analog Input";
}
void AnalogInput::InitTable(std::shared_ptr<ITable> subTable) {
void AnalogInput::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> AnalogInput::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> AnalogInput::GetTable() const {
return m_table;
}

17
wpilibc/src/main/native/cpp/AnalogOutput.cpp
View File

@@ -94,9 +94,7 @@ double AnalogOutput::GetVoltage() const {
}
void AnalogOutput::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", GetVoltage());
}
if (m_valueEntry) m_valueEntry.SetDouble(GetVoltage());
}
void AnalogOutput::StartLiveWindowMode() {}
@@ -107,9 +105,16 @@ std::string AnalogOutput::GetSmartDashboardType() const {
return "Analog Output";
}
void AnalogOutput::InitTable(std::shared_ptr<ITable> subTable) {
void AnalogOutput::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> AnalogOutput::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> AnalogOutput::GetTable() const {
return m_table;
}

20
wpilibc/src/main/native/cpp/AnalogPotentiometer.cpp
View File

@@ -86,17 +86,21 @@ std::string AnalogPotentiometer::GetSmartDashboardType() const {
/**
* Live Window code, only does anything if live window is activated.
*/
void AnalogPotentiometer::InitTable(std::shared_ptr<ITable> subtable) {
void AnalogPotentiometer::InitTable(
std::shared_ptr<nt::NetworkTable> subtable) {
m_table = subtable;
UpdateTable();
}
void AnalogPotentiometer::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", Get());
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> AnalogPotentiometer::GetTable() const {
void AnalogPotentiometer::UpdateTable() {
if (m_valueEntry) m_valueEntry.SetDouble(Get());
}
std::shared_ptr<nt::NetworkTable> AnalogPotentiometer::GetTable() const {
return m_table;
}

26
wpilibc/src/main/native/cpp/BuiltInAccelerometer.cpp
View File

@@ -58,19 +58,27 @@ std::string BuiltInAccelerometer::GetSmartDashboardType() const {
return "3AxisAccelerometer";
}
void BuiltInAccelerometer::InitTable(std::shared_ptr<ITable> subtable) {
void BuiltInAccelerometer::InitTable(
std::shared_ptr<nt::NetworkTable> subtable) {
m_table = subtable;
UpdateTable();
}
void BuiltInAccelerometer::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("X", GetX());
m_table->PutNumber("Y", GetY());
m_table->PutNumber("Z", GetZ());
m_xEntry = m_table->GetEntry("X");
m_yEntry = m_table->GetEntry("Y");
m_zEntry = m_table->GetEntry("Z");
UpdateTable();
} else {
m_xEntry = nt::NetworkTableEntry();
m_yEntry = nt::NetworkTableEntry();
m_zEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> BuiltInAccelerometer::GetTable() const {
void BuiltInAccelerometer::UpdateTable() {
if (m_xEntry) m_xEntry.SetDouble(GetX());
if (m_yEntry) m_yEntry.SetDouble(GetY());
if (m_zEntry) m_zEntry.SetDouble(GetZ());
}
std::shared_ptr<nt::NetworkTable> BuiltInAccelerometer::GetTable() const {
return m_table;
}

21
wpilibc/src/main/native/cpp/Buttons/NetworkButton.cpp
View File

@@ -8,23 +8,18 @@
#include "Buttons/NetworkButton.h"
#include "networktables/NetworkTable.h"
#include "networktables/NetworkTableInstance.h"
using namespace frc;
NetworkButton::NetworkButton(const std::string& tableName,
const std::string& field)
: // TODO how is this supposed to work???
m_netTable(NetworkTable::GetTable(tableName)),
m_field(field) {}
NetworkButton::NetworkButton(llvm::StringRef tableName, llvm::StringRef field)
: NetworkButton(nt::NetworkTableInstance::GetDefault().GetTable(tableName),
field) {}
NetworkButton::NetworkButton(std::shared_ptr<ITable> table,
const std::string& field)
: m_netTable(table), m_field(field) {}
NetworkButton::NetworkButton(std::shared_ptr<nt::NetworkTable> table,
llvm::StringRef field)
: m_entry(table->GetEntry(field)) {}
bool NetworkButton::Get() {
/*if (m_netTable->isConnected())
return m_netTable->GetBoolean(m_field.c_str());
else
return false;*/
return m_netTable->GetBoolean(m_field, false);
return m_entry.GetInstance().IsConnected() && m_entry.GetBoolean(false);
}

19
wpilibc/src/main/native/cpp/Buttons/Trigger.cpp
View File

@@ -15,13 +15,7 @@
using namespace frc;
bool Trigger::Grab() {
if (Get()) {
return true;
} else if (m_table != nullptr) {
return m_table->GetBoolean("pressed", false);
} else {
return false;
}
return Get() || (m_pressedEntry && m_pressedEntry.GetBoolean(false));
}
void Trigger::WhenActive(Command* command) {
@@ -51,11 +45,14 @@ void Trigger::ToggleWhenActive(Command* command) {
std::string Trigger::GetSmartDashboardType() const { return "Button"; }
void Trigger::InitTable(std::shared_ptr<ITable> subtable) {
void Trigger::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
m_table = subtable;
if (m_table != nullptr) {
m_table->PutBoolean("pressed", Get());
if (m_table) {
m_pressedEntry = m_table->GetEntry("pressed");
m_pressedEntry.SetBoolean(Get());
} else {
m_pressedEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Trigger::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Trigger::GetTable() const { return m_table; }

112
wpilibc/src/main/native/cpp/CameraServer.cpp
View File

@@ -12,6 +12,7 @@
#include "Utility.h"
#include "WPIErrors.h"
#include "networktables/NetworkTableInstance.h"
#include "ntcore_cpp.h"
using namespace frc;
@@ -61,7 +62,8 @@ static std::string MakeStreamValue(llvm::StringRef address, int port) {
return rv;
}
std::shared_ptr<ITable> CameraServer::GetSourceTable(CS_Source source) {
std::shared_ptr<nt::NetworkTable> CameraServer::GetSourceTable(
CS_Source source) {
std::lock_guard<std::mutex> lock(m_mutex);
return m_tables.lookup(source);
}
@@ -140,7 +142,7 @@ void CameraServer::UpdateStreamValues() {
// Set table value
auto values = GetSinkStreamValues(sink);
if (!values.empty()) table->PutStringArray("streams", values);
if (!values.empty()) table->GetEntry("streams").SetStringArray(values);
}
}
@@ -153,7 +155,7 @@ void CameraServer::UpdateStreamValues() {
if (table) {
// Set table value
auto values = GetSourceStreamValues(source);
if (!values.empty()) table->PutStringArray("streams", values);
if (!values.empty()) table->GetEntry("streams").SetStringArray(values);
}
}
}
@@ -258,8 +260,8 @@ static inline llvm::StringRef Concatenate(llvm::StringRef lhs,
return oss.str();
}
static void PutSourcePropertyValue(ITable* table, const cs::VideoEvent& event,
bool isNew) {
static void PutSourcePropertyValue(nt::NetworkTable* table,
const cs::VideoEvent& event, bool isNew) {
llvm::SmallString<64> name;
llvm::SmallString<64> infoName;
if (llvm::StringRef{event.name}.startswith("raw_")) {
@@ -276,34 +278,35 @@ static void PutSourcePropertyValue(ITable* table, const cs::VideoEvent& event,
llvm::SmallString<64> buf;
CS_Status status = 0;
nt::NetworkTableEntry entry = table->GetEntry(name);
switch (event.propertyKind) {
case cs::VideoProperty::kBoolean:
if (isNew)
table->SetDefaultBoolean(name, event.value != 0);
entry.SetDefaultBoolean(event.value != 0);
else
table->PutBoolean(name, event.value != 0);
entry.SetBoolean(event.value != 0);
break;
case cs::VideoProperty::kInteger:
case cs::VideoProperty::kEnum:
if (isNew) {
table->SetDefaultNumber(name, event.value);
table->PutNumber(Concatenate(infoName, "/min", buf),
cs::GetPropertyMin(event.propertyHandle, &status));
table->PutNumber(Concatenate(infoName, "/max", buf),
cs::GetPropertyMax(event.propertyHandle, &status));
table->PutNumber(Concatenate(infoName, "/step", buf),
cs::GetPropertyStep(event.propertyHandle, &status));
table->PutNumber(Concatenate(infoName, "/default", buf),
cs::GetPropertyDefault(event.propertyHandle, &status));
entry.SetDefaultDouble(event.value);
table->GetEntry(Concatenate(infoName, "/min", buf))
.SetDouble(cs::GetPropertyMin(event.propertyHandle, &status));
table->GetEntry(Concatenate(infoName, "/max", buf))
.SetDouble(cs::GetPropertyMax(event.propertyHandle, &status));
table->GetEntry(Concatenate(infoName, "/step", buf))
.SetDouble(cs::GetPropertyStep(event.propertyHandle, &status));
table->GetEntry(Concatenate(infoName, "/default", buf))
.SetDouble(cs::GetPropertyDefault(event.propertyHandle, &status));
} else {
table->PutNumber(name, event.value);
entry.SetDouble(event.value);
}
break;
case cs::VideoProperty::kString:
if (isNew)
table->SetDefaultString(name, event.valueStr);
entry.SetDefaultString(event.valueStr);
else
table->PutString(name, event.valueStr);
entry.SetString(event.valueStr);
break;
default:
break;
@@ -311,7 +314,8 @@ static void PutSourcePropertyValue(ITable* table, const cs::VideoEvent& event,
}
CameraServer::CameraServer()
: m_publishTable{NetworkTable::GetTable(kPublishName)},
: m_publishTable{nt::NetworkTableInstance::GetDefault().GetTable(
kPublishName)},
m_nextPort(kBasePort) {
// We publish sources to NetworkTables using the following structure:
// "/CameraPublisher/{Source.Name}/" - root
@@ -337,28 +341,30 @@ CameraServer::CameraServer()
m_tables.insert(std::make_pair(event.sourceHandle, table));
}
llvm::SmallString<64> buf;
table->PutString("source",
MakeSourceValue(event.sourceHandle, buf));
table->GetEntry("source").SetString(
MakeSourceValue(event.sourceHandle, buf));
llvm::SmallString<64> descBuf;
table->PutString(
"description",
cs::GetSourceDescription(event.sourceHandle, descBuf, &status));
table->PutBoolean("connected", cs::IsSourceConnected(
event.sourceHandle, &status));
table->PutStringArray("streams",
GetSourceStreamValues(event.sourceHandle));
table->GetEntry("description")
.SetString(cs::GetSourceDescription(event.sourceHandle, descBuf,
&status));
table->GetEntry("connected")
.SetBoolean(cs::IsSourceConnected(event.sourceHandle, &status));
table->GetEntry("streams").SetStringArray(
GetSourceStreamValues(event.sourceHandle));
auto mode = cs::GetSourceVideoMode(event.sourceHandle, &status);
table->SetDefaultString("mode", VideoModeToString(mode));
table->PutStringArray("modes",
GetSourceModeValues(event.sourceHandle));
table->GetEntry("mode").SetDefaultString(VideoModeToString(mode));
table->GetEntry("modes").SetStringArray(
GetSourceModeValues(event.sourceHandle));
break;
}
case cs::VideoEvent::kSourceDestroyed: {
auto table = GetSourceTable(event.sourceHandle);
if (table) {
table->PutString("source", "");
table->PutStringArray("streams", std::vector<std::string>{});
table->PutStringArray("modes", std::vector<std::string>{});
table->GetEntry("source").SetString("");
table->GetEntry("streams").SetStringArray(
std::vector<std::string>{});
table->GetEntry("modes").SetStringArray(
std::vector<std::string>{});
}
break;
}
@@ -367,28 +373,29 @@ CameraServer::CameraServer()
if (table) {
// update the description too (as it may have changed)
llvm::SmallString<64> descBuf;
table->PutString("description",
cs::GetSourceDescription(event.sourceHandle,
descBuf, &status));
table->PutBoolean("connected", true);
table->GetEntry("description")
.SetString(cs::GetSourceDescription(event.sourceHandle,
descBuf, &status));
table->GetEntry("connected").SetBoolean(true);
}
break;
}
case cs::VideoEvent::kSourceDisconnected: {
auto table = GetSourceTable(event.sourceHandle);
if (table) table->PutBoolean("connected", false);
if (table) table->GetEntry("connected").SetBoolean(false);
break;
}
case cs::VideoEvent::kSourceVideoModesUpdated: {
auto table = GetSourceTable(event.sourceHandle);
if (table)
table->PutStringArray("modes",
GetSourceModeValues(event.sourceHandle));
table->GetEntry("modes").SetStringArray(
GetSourceModeValues(event.sourceHandle));
break;
}
case cs::VideoEvent::kSourceVideoModeChanged: {
auto table = GetSourceTable(event.sourceHandle);
if (table) table->PutString("mode", VideoModeToString(event.mode));
if (table)
table->GetEntry("mode").SetString(VideoModeToString(event.mode));
break;
}
case cs::VideoEvent::kSourcePropertyCreated: {
@@ -409,7 +416,7 @@ CameraServer::CameraServer()
name += "/choices";
auto choices =
cs::GetEnumPropertyChoices(event.propertyHandle, &status);
table->PutStringArray(name, choices);
table->GetEntry(name).SetStringArray(choices);
}
break;
}
@@ -432,12 +439,11 @@ CameraServer::CameraServer()
// synchronization issues, so just update to current setting if someone
// else tries to change it.
llvm::SmallString<64> buf;
m_tableListener = nt::AddEntryListener(
m_tableListener = nt::NetworkTableInstance::GetDefault().AddEntryListener(
Concatenate(kPublishName, "/", buf),
[=](unsigned int uid, llvm::StringRef key,
std::shared_ptr<nt::Value> value, unsigned int flags) {
[=](const nt::EntryNotification& event) {
llvm::StringRef relativeKey =
key.substr(llvm::StringRef(kPublishName).size() + 1);
event.name.substr(llvm::StringRef(kPublishName).size() + 1);
// get source (sourceName/...)
auto subKeyIndex = relativeKey.find('/');
@@ -451,10 +457,10 @@ CameraServer::CameraServer()
// handle standard names
llvm::StringRef propName;
nt::NetworkTableEntry entry{event.entry};
if (relativeKey == "mode") {
// reset to current mode
nt::SetEntryValue(key, nt::Value::MakeString(VideoModeToString(
sourceIt->second.GetVideoMode())));
entry.SetString(VideoModeToString(sourceIt->second.GetVideoMode()));
return;
} else if (relativeKey.startswith("Property/")) {
propName = relativeKey.substr(9);
@@ -470,14 +476,14 @@ CameraServer::CameraServer()
case cs::VideoProperty::kNone:
return;
case cs::VideoProperty::kBoolean:
nt::SetEntryValue(key, nt::Value::MakeBoolean(property.Get() != 0));
entry.SetBoolean(property.Get() != 0);
return;
case cs::VideoProperty::kInteger:
case cs::VideoProperty::kEnum:
nt::SetEntryValue(key, nt::Value::MakeDouble(property.Get()));
entry.SetDouble(property.Get());
return;
case cs::VideoProperty::kString:
nt::SetEntryValue(key, nt::Value::MakeString(property.GetString()));
entry.SetString(property.GetString());
return;
default:
return;

46
wpilibc/src/main/native/cpp/Commands/Command.cpp
View File

@@ -67,7 +67,7 @@ Command::Command(const std::string& name, double timeout) {
}
Command::~Command() {
if (m_table != nullptr) m_table->RemoveTableListener(this);
if (m_runningListener != 0) m_runningEntry.RemoveListener(m_runningListener);
}
/**
@@ -146,7 +146,7 @@ void Command::Removed() {
m_initialized = false;
m_canceled = false;
m_running = false;
if (m_table != nullptr) m_table->PutBoolean(kRunning, false);
if (m_runningEntry) m_runningEntry.SetBoolean(false);
}
/**
@@ -297,9 +297,7 @@ void Command::SetParent(CommandGroup* parent) {
} else {
LockChanges();
m_parent = parent;
if (m_table != nullptr) {
m_table->PutBoolean(kIsParented, true);
}
if (m_isParentedEntry) m_isParentedEntry.SetBoolean(true);
}
}
@@ -325,7 +323,7 @@ void Command::ClearRequirements() { m_requirements.clear(); }
void Command::StartRunning() {
m_running = true;
m_startTime = -1;
if (m_table != nullptr) m_table->PutBoolean(kRunning, true);
if (m_runningEntry) m_runningEntry.SetBoolean(true);
}
/**
@@ -435,25 +433,27 @@ std::string Command::GetName() const { return m_name; }
std::string Command::GetSmartDashboardType() const { return "Command"; }
void Command::InitTable(std::shared_ptr<ITable> subtable) {
if (m_table != nullptr) m_table->RemoveTableListener(this);
void Command::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
if (m_runningListener != 0) m_runningEntry.RemoveListener(m_runningListener);
m_table = subtable;
if (m_table != nullptr) {
m_table->PutString(kName, GetName());
m_table->PutBoolean(kRunning, IsRunning());
m_table->PutBoolean(kIsParented, m_parent != nullptr);
m_table->AddTableListener(kRunning, this, false);
m_table->GetEntry(kName).SetString(GetName());
m_runningEntry = m_table->GetEntry(kRunning);
m_runningEntry.SetBoolean(IsRunning());
m_isParentedEntry = m_table->GetEntry(kIsParented);
m_isParentedEntry.SetBoolean(m_parent != nullptr);
m_runningListener = m_runningEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsBoolean()) return;
if (event.value->GetBoolean()) {
if (!IsRunning()) Start();
} else {
if (IsRunning()) Cancel();
}
},
NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
std::shared_ptr<ITable> Command::GetTable() const { return m_table; }
void Command::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (!value->IsBoolean()) return;
if (value->GetBoolean()) {
if (!IsRunning()) Start();
} else {
if (IsRunning()) Cancel();
}
}
std::shared_ptr<nt::NetworkTable> Command::GetTable() const { return m_table; }

2
wpilibc/src/main/native/cpp/Commands/PIDCommand.cpp
View File

@@ -67,7 +67,7 @@ double PIDCommand::GetPosition() { return ReturnPIDInput(); }
std::string PIDCommand::GetSmartDashboardType() const { return "PIDCommand"; }
void PIDCommand::InitTable(std::shared_ptr<ITable> subtable) {
void PIDCommand::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
m_controller->InitTable(subtable);
Command::InitTable(subtable);
}

2
wpilibc/src/main/native/cpp/Commands/PIDSubsystem.cpp
View File

@@ -242,7 +242,7 @@ double PIDSubsystem::PIDGet() { return ReturnPIDInput(); }
std::string PIDSubsystem::GetSmartDashboardType() const { return "PIDCommand"; }
void PIDSubsystem::InitTable(std::shared_ptr<ITable> subtable) {
void PIDSubsystem::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
m_controller->InitTable(subtable);
Subsystem::InitTable(subtable);
}

33
wpilibc/src/main/native/cpp/Commands/Scheduler.cpp
View File

@@ -219,6 +219,9 @@ void Scheduler::ResetAll() {
m_additions.clear();
m_commands.clear();
m_table = nullptr;
m_namesEntry = nt::NetworkTableEntry();
m_idsEntry = nt::NetworkTableEntry();
m_cancelEntry = nt::NetworkTableEntry();
}
/**
@@ -228,7 +231,7 @@ void Scheduler::ResetAll() {
void Scheduler::UpdateTable() {
if (m_table != nullptr) {
// Get the list of possible commands to cancel
auto new_toCancel = m_table->GetValue("Cancel");
auto new_toCancel = m_cancelEntry.GetValue();
if (new_toCancel)
toCancel = new_toCancel->GetDoubleArray();
else
@@ -248,7 +251,7 @@ void Scheduler::UpdateTable() {
}
}
toCancel.resize(0);
m_table->PutValue("Cancel", nt::Value::MakeDoubleArray(toCancel));
m_cancelEntry.SetDoubleArray(toCancel);
}
// Set the running commands
@@ -261,8 +264,8 @@ void Scheduler::UpdateTable() {
commands.push_back(c->GetName());
ids.push_back(c->GetID());
}
m_table->PutValue("Names", nt::Value::MakeStringArray(commands));
m_table->PutValue("Ids", nt::Value::MakeDoubleArray(ids));
m_namesEntry.SetStringArray(commands);
m_idsEntry.SetDoubleArray(ids);
}
}
}
@@ -273,12 +276,22 @@ std::string Scheduler::GetType() const { return "Scheduler"; }
std::string Scheduler::GetSmartDashboardType() const { return "Scheduler"; }
void Scheduler::InitTable(std::shared_ptr<ITable> subTable) {
void Scheduler::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
m_table->PutValue("Names", nt::Value::MakeStringArray(commands));
m_table->PutValue("Ids", nt::Value::MakeDoubleArray(ids));
m_table->PutValue("Cancel", nt::Value::MakeDoubleArray(toCancel));
if (m_table) {
m_namesEntry = m_table->GetEntry("Names");
m_idsEntry = m_table->GetEntry("Ids");
m_cancelEntry = m_table->GetEntry("Cancel");
m_namesEntry.SetStringArray(commands);
m_idsEntry.SetDoubleArray(ids);
m_cancelEntry.SetDoubleArray(toCancel);
} else {
m_namesEntry = nt::NetworkTableEntry();
m_idsEntry = nt::NetworkTableEntry();
m_cancelEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Scheduler::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Scheduler::GetTable() const {
return m_table;
}

35
wpilibc/src/main/native/cpp/Commands/Subsystem.cpp
View File

@@ -66,10 +66,10 @@ void Subsystem::SetDefaultCommand(Command* command) {
}
if (m_table != nullptr) {
if (m_defaultCommand != nullptr) {
m_table->PutBoolean("hasDefault", true);
m_table->PutString("default", m_defaultCommand->GetName());
m_hasDefaultEntry.SetBoolean(true);
m_defaultEntry.SetString(m_defaultCommand->GetName());
} else {
m_table->PutBoolean("hasDefault", false);
m_hasDefaultEntry.SetBoolean(false);
}
}
}
@@ -121,10 +121,10 @@ void Subsystem::ConfirmCommand() {
if (m_currentCommandChanged) {
if (m_table != nullptr) {
if (m_currentCommand != nullptr) {
m_table->PutBoolean("hasCommand", true);
m_table->PutString("command", m_currentCommand->GetName());
m_hasCommandEntry.SetBoolean(true);
m_commandEntry.SetString(m_currentCommand->GetName());
} else {
m_table->PutBoolean("hasCommand", false);
m_hasCommandEntry.SetBoolean(false);
}
}
m_currentCommandChanged = false;
@@ -135,22 +135,29 @@ std::string Subsystem::GetName() const { return m_name; }
std::string Subsystem::GetSmartDashboardType() const { return "Subsystem"; }
void Subsystem::InitTable(std::shared_ptr<ITable> subtable) {
void Subsystem::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
m_table = subtable;
if (m_table != nullptr) {
m_hasDefaultEntry = m_table->GetEntry("hasDefault");
m_defaultEntry = m_table->GetEntry("default");
m_hasCommandEntry = m_table->GetEntry("hasCommand");
m_commandEntry = m_table->GetEntry("command");
if (m_defaultCommand != nullptr) {
m_table->PutBoolean("hasDefault", true);
m_table->PutString("default", m_defaultCommand->GetName());
m_hasDefaultEntry.SetBoolean(true);
m_defaultEntry.SetString(m_defaultCommand->GetName());
} else {
m_table->PutBoolean("hasDefault", false);
m_hasDefaultEntry.SetBoolean(false);
}
if (m_currentCommand != nullptr) {
m_table->PutBoolean("hasCommand", true);
m_table->PutString("command", m_currentCommand->GetName());
m_hasCommandEntry.SetBoolean(true);
m_commandEntry.SetString(m_currentCommand->GetName());
} else {
m_table->PutBoolean("hasCommand", false);
m_hasCommandEntry.SetBoolean(false);
}
}
}
std::shared_ptr<ITable> Subsystem::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Subsystem::GetTable() const {
return m_table;
}

57
wpilibc/src/main/native/cpp/Compressor.cpp
View File

@@ -32,6 +32,13 @@ Compressor::Compressor(int pcmID) : m_module(pcmID) {
SetClosedLoopControl(true);
}
/**
* Destructor.
*/
Compressor::~Compressor() {
if (m_enabledListener != 0) m_enabledEntry.RemoveListener(m_enabledListener);
}
/**
* Starts closed-loop control. Note that closed loop control is enabled by
* default.
@@ -300,30 +307,46 @@ void Compressor::ClearAllPCMStickyFaults() {
}
void Compressor::UpdateTable() {
if (m_table) {
m_table->PutBoolean("Enabled", Enabled());
m_table->PutBoolean("Pressure switch", GetPressureSwitchValue());
if (m_enabledEntry) m_enabledEntry.SetBoolean(Enabled());
if (m_pressureSwitchEntry)
m_pressureSwitchEntry.SetBoolean(GetPressureSwitchValue());
}
void Compressor::StartLiveWindowMode() {
if (m_enabledEntry) {
m_enabledListener = m_enabledEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsBoolean()) return;
if (event.value->GetBoolean())
Start();
else
Stop();
},
NT_NOTIFY_IMMEDIATE | NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
void Compressor::StartLiveWindowMode() {}
void Compressor::StopLiveWindowMode() {}
void Compressor::StopLiveWindowMode() {
if (m_enabledListener != 0) {
m_enabledEntry.RemoveListener(m_enabledListener);
m_enabledListener = 0;
}
}
std::string Compressor::GetSmartDashboardType() const { return "Compressor"; }
void Compressor::InitTable(std::shared_ptr<ITable> subTable) {
void Compressor::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_enabledEntry = m_table->GetEntry("Enabled");
m_pressureSwitchEntry = m_table->GetEntry("Pressure switch");
UpdateTable();
} else {
m_enabledEntry = nt::NetworkTableEntry();
m_pressureSwitchEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Compressor::GetTable() const { return m_table; }
void Compressor::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (!value->IsBoolean()) return;
if (value->GetBoolean())
Start();
else
Stop();
std::shared_ptr<nt::NetworkTable> Compressor::GetTable() const {
return m_table;
}

15
wpilibc/src/main/native/cpp/Counter.cpp
View File

@@ -603,9 +603,7 @@ void Counter::SetReverseDirection(bool reverseDirection) {
}
void Counter::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", Get());
}
if (m_valueEntry) m_valueEntry.SetDouble(Get());
}
void Counter::StartLiveWindowMode() {}
@@ -614,9 +612,14 @@ void Counter::StopLiveWindowMode() {}
std::string Counter::GetSmartDashboardType() const { return "Counter"; }
void Counter::InitTable(std::shared_ptr<ITable> subTable) {
void Counter::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Counter::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Counter::GetTable() const { return m_table; }

17
wpilibc/src/main/native/cpp/DigitalInput.cpp
View File

@@ -104,9 +104,7 @@ AnalogTriggerType DigitalInput::GetAnalogTriggerTypeForRouting() const {
}
void DigitalInput::UpdateTable() {
if (m_table != nullptr) {
m_table->PutBoolean("Value", Get());
}
if (m_valueEntry) m_valueEntry.SetBoolean(Get());
}
void DigitalInput::StartLiveWindowMode() {}
@@ -117,9 +115,16 @@ std::string DigitalInput::GetSmartDashboardType() const {
return "DigitalInput";
}
void DigitalInput::InitTable(std::shared_ptr<ITable> subTable) {
void DigitalInput::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> DigitalInput::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> DigitalInput::GetTable() const {
return m_table;
}

35
wpilibc/src/main/native/cpp/DigitalOutput.cpp
View File

@@ -57,7 +57,7 @@ DigitalOutput::DigitalOutput(int channel) {
* Free the resources associated with a digital output.
*/
DigitalOutput::~DigitalOutput() {
if (m_table != nullptr) m_table->RemoveTableListener(this);
if (m_valueListener != 0) m_valueEntry.RemoveListener(m_valueListener);
if (StatusIsFatal()) return;
// Disable the PWM in case it was running.
DisablePWM();
@@ -232,23 +232,23 @@ AnalogTriggerType DigitalOutput::GetAnalogTriggerTypeForRouting() const {
return (AnalogTriggerType)0;
}
void DigitalOutput::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (!value->IsBoolean()) return;
Set(value->GetBoolean());
}
void DigitalOutput::UpdateTable() {}
void DigitalOutput::StartLiveWindowMode() {
if (m_table != nullptr) {
m_table->AddTableListener("Value", this, true);
if (m_valueEntry) {
m_valueListener = m_valueEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsBoolean()) return;
Set(event.value->GetBoolean());
},
NT_NOTIFY_IMMEDIATE | NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
void DigitalOutput::StopLiveWindowMode() {
if (m_table != nullptr) {
m_table->RemoveTableListener(this);
if (m_valueListener != 0) {
m_valueEntry.RemoveListener(m_valueListener);
m_valueListener = 0;
}
}
@@ -256,9 +256,16 @@ std::string DigitalOutput::GetSmartDashboardType() const {
return "Digital Output";
}
void DigitalOutput::InitTable(std::shared_ptr<ITable> subTable) {
void DigitalOutput::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table != nullptr) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> DigitalOutput::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> DigitalOutput::GetTable() const {
return m_table;
}

62
wpilibc/src/main/native/cpp/DoubleSolenoid.cpp
View File

@@ -99,7 +99,7 @@ DoubleSolenoid::DoubleSolenoid(int moduleNumber, int forwardChannel,
DoubleSolenoid::~DoubleSolenoid() {
HAL_FreeSolenoidPort(m_forwardHandle);
HAL_FreeSolenoidPort(m_reverseHandle);
if (m_table != nullptr) m_table->RemoveTableListener(this);
if (m_valueListener != 0) m_valueEntry.RemoveListener(m_valueListener);
}
/**
@@ -181,37 +181,44 @@ bool DoubleSolenoid::IsRevSolenoidBlackListed() const {
return (blackList & m_reverseMask) ? 1 : 0;
}
void DoubleSolenoid::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value,
bool isNew) {
if (!value->IsString()) return;
Value lvalue = kOff;
if (value->GetString() == "Forward")
lvalue = kForward;
else if (value->GetString() == "Reverse")
lvalue = kReverse;
Set(lvalue);
}
void DoubleSolenoid::UpdateTable() {
if (m_table != nullptr) {
m_table->PutString(
"Value", (Get() == kForward ? "Forward"
: (Get() == kReverse ? "Reverse" : "Off")));
if (m_valueEntry) {
switch (Get()) {
case kForward:
m_valueEntry.SetString("Forward");
break;
case kReverse:
m_valueEntry.SetString("Reverse");
break;
default:
m_valueEntry.SetString("Off");
break;
}
}
}
void DoubleSolenoid::StartLiveWindowMode() {
Set(kOff);
if (m_table != nullptr) {
m_table->AddTableListener("Value", this, true);
if (m_valueEntry) {
m_valueListener = m_valueEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsString()) return;
Value lvalue = kOff;
if (event.value->GetString() == "Forward")
lvalue = kForward;
else if (event.value->GetString() == "Reverse")
lvalue = kReverse;
Set(lvalue);
},
NT_NOTIFY_IMMEDIATE | NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
void DoubleSolenoid::StopLiveWindowMode() {
Set(kOff);
if (m_table != nullptr) {
m_table->RemoveTableListener(this);
if (m_valueListener != 0) {
m_valueEntry.RemoveListener(m_valueListener);
m_valueListener = 0;
}
}
@@ -219,9 +226,16 @@ std::string DoubleSolenoid::GetSmartDashboardType() const {
return "Double Solenoid";
}
void DoubleSolenoid::InitTable(std::shared_ptr<ITable> subTable) {
void DoubleSolenoid::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> DoubleSolenoid::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> DoubleSolenoid::GetTable() const {
return m_table;
}

23
wpilibc/src/main/native/cpp/Encoder.cpp
View File

@@ -480,14 +480,14 @@ int Encoder::GetFPGAIndex() const {
}
void Encoder::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Speed", GetRate());
m_table->PutNumber("Distance", GetDistance());
if (m_speedEntry) m_speedEntry.SetDouble(GetRate());
if (m_distanceEntry) m_distanceEntry.SetDouble(GetDistance());
if (m_distancePerTickEntry) {
int32_t status = 0;
double distancePerPulse =
HAL_GetEncoderDistancePerPulse(m_encoder, &status);
wpi_setErrorWithContext(status, HAL_GetErrorMessage(status));
m_table->PutNumber("Distance per Tick", distancePerPulse);
m_distancePerTickEntry.SetDouble(distancePerPulse);
}
}
@@ -505,9 +505,18 @@ std::string Encoder::GetSmartDashboardType() const {
return "Encoder";
}
void Encoder::InitTable(std::shared_ptr<ITable> subTable) {
void Encoder::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_speedEntry = m_table->GetEntry("Speed");
m_distanceEntry = m_table->GetEntry("Distance");
m_distancePerTickEntry = m_table->GetEntry("Distance per Tick");
UpdateTable();
} else {
m_speedEntry = nt::NetworkTableEntry();
m_distanceEntry = nt::NetworkTableEntry();
m_distancePerTickEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Encoder::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Encoder::GetTable() const { return m_table; }

15
wpilibc/src/main/native/cpp/GyroBase.cpp
View File

@@ -30,9 +30,7 @@ double GyroBase::PIDGet() {
}
void GyroBase::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", GetAngle());
}
if (m_valueEntry) m_valueEntry.SetDouble(GetAngle());
}
void GyroBase::StartLiveWindowMode() {}
@@ -41,9 +39,14 @@ void GyroBase::StopLiveWindowMode() {}
std::string GyroBase::GetSmartDashboardType() const { return "Gyro"; }
void GyroBase::InitTable(std::shared_ptr<ITable> subTable) {
void GyroBase::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> GyroBase::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> GyroBase::GetTable() const { return m_table; }

19
wpilibc/src/main/native/cpp/LiveWindow/LiveWindow.cpp
View File

@@ -13,6 +13,7 @@
#include <llvm/raw_ostream.h>
#include "networktables/NetworkTable.h"
#include "networktables/NetworkTableInstance.h"
using namespace frc;
@@ -33,8 +34,10 @@ LiveWindow* LiveWindow::GetInstance() {
* Allocate the necessary tables.
*/
LiveWindow::LiveWindow() : m_scheduler(Scheduler::GetInstance()) {
m_liveWindowTable = NetworkTable::GetTable("LiveWindow");
m_liveWindowTable =
nt::NetworkTableInstance::GetDefault().GetTable("LiveWindow");
m_statusTable = m_liveWindowTable->GetSubTable("~STATUS~");
m_enabledEntry = m_statusTable->GetEntry("LW Enabled");
}
/**
@@ -61,7 +64,7 @@ void LiveWindow::SetEnabled(bool enabled) {
m_scheduler->SetEnabled(true);
}
m_enabled = enabled;
m_statusTable->PutBoolean("LW Enabled", m_enabled);
m_enabledEntry.SetBoolean(m_enabled);
}
/**
@@ -228,13 +231,13 @@ void LiveWindow::InitializeLiveWindowComponents() {
LiveWindowComponent c = elem.second;
std::string subsystem = c.subsystem;
std::string name = c.name;
m_liveWindowTable->GetSubTable(subsystem)->PutString("~TYPE~",
"LW Subsystem");
std::shared_ptr<ITable> table(
m_liveWindowTable->GetSubTable(subsystem)->GetEntry("~TYPE~").SetString(
"LW Subsystem");
std::shared_ptr<NetworkTable> table(
m_liveWindowTable->GetSubTable(subsystem)->GetSubTable(name));
table->PutString("~TYPE~", component->GetSmartDashboardType());
table->PutString("Name", name);
table->PutString("Subsystem", subsystem);
table->GetEntry("~TYPE~").SetString(component->GetSmartDashboardType());
table->GetEntry("Name").SetString(name);
table->GetEntry("Subsystem").SetString(subsystem);
component->InitTable(table);
if (c.isSensor) {
m_sensors.push_back(component);

16
wpilibc/src/main/native/cpp/LiveWindow/LiveWindowStatusListener.cpp
View File

@@ -1,16 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2012-2017 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#include "LiveWindow/LiveWindowStatusListener.h"
#include "Commands/Scheduler.h"
using namespace frc;
void LiveWindowStatusListener::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value,
bool isNew) {}

159
wpilibc/src/main/native/cpp/PIDController.cpp
View File

@@ -78,7 +78,7 @@ PIDController::PIDController(double Kp, double Ki, double Kd, double Kf,
PIDController::~PIDController() {
// forcefully stopping the notifier so the callback can successfully run.
m_controlLoop->Stop();
if (m_table != nullptr) m_table->RemoveTableListener(this);
RemoveListeners();
}
/**
@@ -204,11 +204,9 @@ void PIDController::SetPID(double p, double i, double d) {
m_D = d;
}
if (m_table != nullptr) {
m_table->PutNumber("p", m_P);
m_table->PutNumber("i", m_I);
m_table->PutNumber("d", m_D);
}
if (m_pEntry) m_pEntry.SetDouble(m_P);
if (m_iEntry) m_iEntry.SetDouble(m_I);
if (m_dEntry) m_dEntry.SetDouble(m_D);
}
/**
@@ -230,12 +228,10 @@ void PIDController::SetPID(double p, double i, double d, double f) {
m_F = f;
}
if (m_table != nullptr) {
m_table->PutNumber("p", m_P);
m_table->PutNumber("i", m_I);
m_table->PutNumber("d", m_D);
m_table->PutNumber("f", m_F);
}
if (m_pEntry) m_pEntry.SetDouble(m_P);
if (m_iEntry) m_iEntry.SetDouble(m_I);
if (m_dEntry) m_dEntry.SetDouble(m_D);
if (m_fEntry) m_fEntry.SetDouble(m_F);
}
/**
@@ -359,9 +355,7 @@ void PIDController::SetSetpoint(double setpoint) {
m_bufTotal = 0;
}
if (m_table != nullptr) {
m_table->PutNumber("setpoint", m_setpoint);
}
if (m_setpointEntry) m_setpointEntry.SetDouble(m_setpoint);
}
/**
@@ -526,9 +520,7 @@ void PIDController::Enable() {
m_enabled = true;
}
if (m_table != nullptr) {
m_table->PutBoolean("enabled", true);
}
if (m_enabledEntry) m_enabledEntry.SetBoolean(true);
}
/**
@@ -541,9 +533,7 @@ void PIDController::Disable() {
m_enabled = false;
}
if (m_table != nullptr) {
m_table->PutBoolean("enabled", false);
}
if (m_enabledEntry) m_enabledEntry.SetBoolean(false);
}
/**
@@ -570,17 +560,72 @@ std::string PIDController::GetSmartDashboardType() const {
return "PIDController";
}
void PIDController::InitTable(std::shared_ptr<ITable> subtable) {
if (m_table != nullptr) m_table->RemoveTableListener(this);
void PIDController::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
RemoveListeners();
m_table = subtable;
if (m_table != nullptr) {
m_table->PutNumber(kP, GetP());
m_table->PutNumber(kI, GetI());
m_table->PutNumber(kD, GetD());
m_table->PutNumber(kF, GetF());
m_table->PutNumber(kSetpoint, GetSetpoint());
m_table->PutBoolean(kEnabled, IsEnabled());
m_table->AddTableListener(this, false);
if (m_table) {
m_pEntry = m_table->GetEntry(kP);
m_pEntry.SetDouble(GetP());
m_iEntry = m_table->GetEntry(kI);
m_iEntry.SetDouble(GetI());
m_dEntry = m_table->GetEntry(kD);
m_dEntry.SetDouble(GetD());
m_fEntry = m_table->GetEntry(kF);
m_fEntry.SetDouble(GetF());
m_setpointEntry = m_table->GetEntry(kSetpoint);
m_setpointEntry.SetDouble(GetSetpoint());
m_enabledEntry = m_table->GetEntry(kEnabled);
m_enabledEntry.SetBoolean(IsEnabled());
m_pListener = m_pEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsDouble()) return;
std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
m_P = event.value->GetDouble();
},
NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
m_iListener = m_iEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsDouble()) return;
std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
m_I = event.value->GetDouble();
},
NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
m_dListener = m_dEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsDouble()) return;
std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
m_D = event.value->GetDouble();
},
NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
m_fListener = m_fEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsDouble()) return;
std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
m_F = event.value->GetDouble();
},
NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
m_setpointListener = m_setpointEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsDouble()) return;
SetSetpoint(event.value->GetDouble());
},
NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
m_enabledListener = m_enabledEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsBoolean()) return;
if (event.value->GetBoolean()) {
Enable();
} else {
Disable();
}
},
NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
@@ -604,29 +649,8 @@ double PIDController::GetContinuousError(double error) const {
return error;
}
std::shared_ptr<ITable> PIDController::GetTable() const { return m_table; }
void PIDController::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (key == kP || key == kI || key == kD || key == kF) {
if (m_P != m_table->GetNumber(kP, 0.0) ||
m_I != m_table->GetNumber(kI, 0.0) ||
m_D != m_table->GetNumber(kD, 0.0) ||
m_F != m_table->GetNumber(kF, 0.0)) {
SetPID(m_table->GetNumber(kP, 0.0), m_table->GetNumber(kI, 0.0),
m_table->GetNumber(kD, 0.0), m_table->GetNumber(kF, 0.0));
}
} else if (key == kSetpoint && value->IsDouble() &&
m_setpoint != value->GetDouble()) {
SetSetpoint(value->GetDouble());
} else if (key == kEnabled && value->IsBoolean() &&
m_enabled != value->GetBoolean()) {
if (value->GetBoolean()) {
Enable();
} else {
Disable();
}
}
std::shared_ptr<nt::NetworkTable> PIDController::GetTable() const {
return m_table;
}
void PIDController::UpdateTable() {}
@@ -634,3 +658,30 @@ void PIDController::UpdateTable() {}
void PIDController::StartLiveWindowMode() { Disable(); }
void PIDController::StopLiveWindowMode() {}
void PIDController::RemoveListeners() {
if (m_pListener != 0) {
m_pEntry.RemoveListener(m_pListener);
m_pListener = 0;
}
if (m_iListener != 0) {
m_iEntry.RemoveListener(m_iListener);
m_iListener = 0;
}
if (m_dListener != 0) {
m_dEntry.RemoveListener(m_dListener);
m_dListener = 0;
}
if (m_fListener != 0) {
m_fEntry.RemoveListener(m_fListener);
m_fListener = 0;
}
if (m_setpointListener != 0) {
m_setpointEntry.RemoveListener(m_setpointListener);
m_setpointListener = 0;
}
if (m_enabledListener != 0) {
m_enabledEntry.RemoveListener(m_enabledListener);
m_enabledListener = 0;
}
}

37
wpilibc/src/main/native/cpp/PWM.cpp
View File

@@ -73,7 +73,7 @@ PWM::~PWM() {
HAL_FreePWMPort(m_handle, &status);
wpi_setErrorWithContext(status, HAL_GetErrorMessage(status));
if (m_table != nullptr) m_table->RemoveTableListener(this);
if (m_valueListener != 0) m_valueEntry.RemoveListener(m_valueListener);
}
/**
@@ -314,37 +314,40 @@ void PWM::SetZeroLatch() {
wpi_setErrorWithContext(status, HAL_GetErrorMessage(status));
}
void PWM::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (!value->IsDouble()) return;
SetSpeed(value->GetDouble());
}
void PWM::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", GetSpeed());
}
if (m_valueEntry) m_valueEntry.SetDouble(GetSpeed());
}
void PWM::StartLiveWindowMode() {
SetSpeed(0);
if (m_table != nullptr) {
m_table->AddTableListener("Value", this, true);
if (m_valueEntry) {
m_valueListener = m_valueEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsDouble()) return;
SetSpeed(event.value->GetDouble());
},
NT_NOTIFY_IMMEDIATE | NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
void PWM::StopLiveWindowMode() {
SetSpeed(0);
if (m_table != nullptr) {
m_table->RemoveTableListener(this);
if (m_valueListener != 0) {
m_valueEntry.RemoveListener(m_valueListener);
m_valueListener = 0;
}
}
std::string PWM::GetSmartDashboardType() const { return "Speed Controller"; }
void PWM::InitTable(std::shared_ptr<ITable> subTable) {
void PWM::InitTable(std::shared_ptr<NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> PWM::GetTable() const { return m_table; }
std::shared_ptr<NetworkTable> PWM::GetTable() const { return m_table; }

46
wpilibc/src/main/native/cpp/PowerDistributionPanel.cpp
View File

@@ -172,26 +172,11 @@ void PowerDistributionPanel::ClearStickyFaults() {
}
void PowerDistributionPanel::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Chan0", GetCurrent(0));
m_table->PutNumber("Chan1", GetCurrent(1));
m_table->PutNumber("Chan2", GetCurrent(2));
m_table->PutNumber("Chan3", GetCurrent(3));
m_table->PutNumber("Chan4", GetCurrent(4));
m_table->PutNumber("Chan5", GetCurrent(5));
m_table->PutNumber("Chan6", GetCurrent(6));
m_table->PutNumber("Chan7", GetCurrent(7));
m_table->PutNumber("Chan8", GetCurrent(8));
m_table->PutNumber("Chan9", GetCurrent(9));
m_table->PutNumber("Chan10", GetCurrent(10));
m_table->PutNumber("Chan11", GetCurrent(11));
m_table->PutNumber("Chan12", GetCurrent(12));
m_table->PutNumber("Chan13", GetCurrent(13));
m_table->PutNumber("Chan14", GetCurrent(14));
m_table->PutNumber("Chan15", GetCurrent(15));
m_table->PutNumber("Voltage", GetVoltage());
m_table->PutNumber("TotalCurrent", GetTotalCurrent());
for (size_t i = 0; i < sizeof(m_chanEntry) / sizeof(m_chanEntry[0]); ++i) {
if (m_chanEntry[i]) m_chanEntry[i].SetDouble(GetCurrent(i));
}
if (m_voltageEntry) m_voltageEntry.SetDouble(GetVoltage());
if (m_totalCurrentEntry) m_totalCurrentEntry.SetDouble(GetTotalCurrent());
}
void PowerDistributionPanel::StartLiveWindowMode() {}
@@ -202,11 +187,28 @@ std::string PowerDistributionPanel::GetSmartDashboardType() const {
return "PowerDistributionPanel";
}
void PowerDistributionPanel::InitTable(std::shared_ptr<ITable> subTable) {
void PowerDistributionPanel::InitTable(
std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table != nullptr) {
for (size_t i = 0; i < sizeof(m_chanEntry) / sizeof(m_chanEntry[0]); ++i) {
llvm::SmallString<32> buf;
llvm::raw_svector_ostream oss(buf);
oss << "Chan" << i;
m_chanEntry[i] = m_table->GetEntry(oss.str());
}
m_voltageEntry = m_table->GetEntry("Voltage");
m_totalCurrentEntry = m_table->GetEntry("TotalCurrent");
UpdateTable();
} else {
for (size_t i = 0; i < sizeof(m_chanEntry) / sizeof(m_chanEntry[0]); ++i) {
m_chanEntry[i] = nt::NetworkTableEntry();
}
m_voltageEntry = nt::NetworkTableEntry();
m_totalCurrentEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> PowerDistributionPanel::GetTable() const {
std::shared_ptr<nt::NetworkTable> PowerDistributionPanel::GetTable() const {
return m_table;
}

49
wpilibc/src/main/native/cpp/Preferences.cpp
View File

@@ -13,23 +13,20 @@
#include <llvm/StringRef.h>
#include "WPIErrors.h"
#include "networktables/NetworkTableInstance.h"
using namespace frc;
/** The Preferences table name */
static llvm::StringRef kTableName{"Preferences"};
void Preferences::Listener::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value,
bool isNew) {}
void Preferences::Listener::ValueChangedEx(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value,
uint32_t flags) {
source->SetPersistent(key);
}
Preferences::Preferences() : m_table(NetworkTable::GetTable(kTableName)) {
m_table->AddTableListenerEx(&m_listener, NT_NOTIFY_NEW | NT_NOTIFY_IMMEDIATE);
Preferences::Preferences()
: m_table(nt::NetworkTableInstance::GetDefault().GetTable(kTableName)) {
m_listener = m_table->AddEntryListener(
[=](nt::NetworkTable* table, llvm::StringRef name,
nt::NetworkTableEntry entry, std::shared_ptr<nt::Value> value,
int flags) { entry.SetPersistent(); },
NT_NOTIFY_NEW | NT_NOTIFY_IMMEDIATE);
HAL_Report(HALUsageReporting::kResourceType_Preferences, 0);
}
@@ -133,8 +130,9 @@ int64_t Preferences::GetLong(llvm::StringRef key, int64_t defaultValue) {
* @param value the value
*/
void Preferences::PutString(llvm::StringRef key, llvm::StringRef value) {
m_table->PutString(key, value);
m_table->SetPersistent(key);
auto entry = m_table->GetEntry(key);
entry.SetString(value);
entry.SetPersistent();
}
/**
@@ -146,8 +144,9 @@ void Preferences::PutString(llvm::StringRef key, llvm::StringRef value) {
* @param value the value
*/
void Preferences::PutInt(llvm::StringRef key, int value) {
m_table->PutNumber(key, value);
m_table->SetPersistent(key);
auto entry = m_table->GetEntry(key);
entry.SetDouble(value);
entry.SetPersistent();
}
/**
@@ -159,8 +158,9 @@ void Preferences::PutInt(llvm::StringRef key, int value) {
* @param value the value
*/
void Preferences::PutDouble(llvm::StringRef key, double value) {
m_table->PutNumber(key, value);
m_table->SetPersistent(key);
auto entry = m_table->GetEntry(key);
entry.SetDouble(value);
entry.SetPersistent();
}
/**
@@ -172,8 +172,9 @@ void Preferences::PutDouble(llvm::StringRef key, double value) {
* @param value the value
*/
void Preferences::PutFloat(llvm::StringRef key, float value) {
m_table->PutNumber(key, value);
m_table->SetPersistent(key);
auto entry = m_table->GetEntry(key);
entry.SetDouble(value);
entry.SetPersistent();
}
/**
@@ -185,8 +186,9 @@ void Preferences::PutFloat(llvm::StringRef key, float value) {
* @param value the value
*/
void Preferences::PutBoolean(llvm::StringRef key, bool value) {
m_table->PutBoolean(key, value);
m_table->SetPersistent(key);
auto entry = m_table->GetEntry(key);
entry.SetBoolean(value);
entry.SetPersistent();
}
/**
@@ -198,8 +200,9 @@ void Preferences::PutBoolean(llvm::StringRef key, bool value) {
* @param value the value
*/
void Preferences::PutLong(llvm::StringRef key, int64_t value) {
m_table->PutNumber(key, value);
m_table->SetPersistent(key);
auto entry = m_table->GetEntry(key);
entry.SetDouble(value);
entry.SetPersistent();
}
/**

57
wpilibc/src/main/native/cpp/Relay.cpp
View File

@@ -104,7 +104,7 @@ Relay::~Relay() {
if (m_forwardHandle != HAL_kInvalidHandle) HAL_FreeRelayPort(m_forwardHandle);
if (m_reverseHandle != HAL_kInvalidHandle) HAL_FreeRelayPort(m_reverseHandle);
if (m_table != nullptr) m_table->RemoveTableListener(this);
if (m_valueListener != 0) m_valueEntry.RemoveListener(m_valueListener);
}
/**
@@ -273,50 +273,55 @@ void Relay::GetDescription(llvm::raw_ostream& desc) const {
desc << "Relay " << GetChannel();
}
void Relay::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (!value->IsString()) return;
if (value->GetString() == "Off")
Set(kOff);
else if (value->GetString() == "Forward")
Set(kForward);
else if (value->GetString() == "Reverse")
Set(kReverse);
else if (value->GetString() == "On")
Set(kOn);
}
void Relay::UpdateTable() {
if (m_table != nullptr) {
if (m_valueEntry) {
if (Get() == kOn) {
m_table->PutString("Value", "On");
m_valueEntry.SetString("On");
} else if (Get() == kForward) {
m_table->PutString("Value", "Forward");
m_valueEntry.SetString("Forward");
} else if (Get() == kReverse) {
m_table->PutString("Value", "Reverse");
m_valueEntry.SetString("Reverse");
} else {
m_table->PutString("Value", "Off");
m_valueEntry.SetString("Off");
}
}
}
void Relay::StartLiveWindowMode() {
if (m_table != nullptr) {
m_table->AddTableListener("Value", this, true);
if (m_valueEntry) {
m_valueListener = m_valueEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsString()) return;
if (event.value->GetString() == "Off")
Set(kOff);
else if (event.value->GetString() == "Forward")
Set(kForward);
else if (event.value->GetString() == "Reverse")
Set(kReverse);
else if (event.value->GetString() == "On")
Set(kOn);
},
NT_NOTIFY_IMMEDIATE | NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
void Relay::StopLiveWindowMode() {
if (m_table != nullptr) {
m_table->RemoveTableListener(this);
if (m_valueListener != 0) {
m_valueEntry.RemoveListener(m_valueListener);
m_valueListener = 0;
}
}
std::string Relay::GetSmartDashboardType() const { return "Relay"; }
void Relay::InitTable(std::shared_ptr<ITable> subTable) {
void Relay::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Relay::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Relay::GetTable() const { return m_table; }

12
wpilibc/src/main/native/cpp/RobotBase.cpp
View File

@@ -19,7 +19,7 @@
#include "SmartDashboard/SmartDashboard.h"
#include "Utility.h"
#include "WPILibVersion.h"
#include "networktables/NetworkTable.h"
#include "networktables/NetworkTableInstance.h"
using namespace frc;
@@ -42,8 +42,9 @@ RobotBase::RobotBase() : m_ds(DriverStation::GetInstance()) {
RobotState::SetImplementation(DriverStation::GetInstance());
HLUsageReporting::SetImplementation(new HardwareHLReporting());
NetworkTable::SetNetworkIdentity("Robot");
NetworkTable::SetPersistentFilename("/home/lvuser/networktables.ini");
auto inst = nt::NetworkTableInstance::GetDefault();
inst.SetNetworkIdentity("Robot");
inst.StartServer("/home/lvuser/networktables.ini");
SmartDashboard::init();
@@ -57,9 +58,10 @@ RobotBase::RobotBase() : m_ds(DriverStation::GetInstance()) {
}
// First and one-time initialization
NetworkTable::GetTable("LiveWindow")
inst.GetTable("LiveWindow")
->GetSubTable("~STATUS~")
->PutBoolean("LW Enabled", false);
->GetEntry("LW Enabled")
.SetBoolean(false);
LiveWindow::GetInstance()->SetEnabled(false);
}

39
wpilibc/src/main/native/cpp/Servo.cpp
View File

@@ -30,9 +30,7 @@ Servo::Servo(int channel) : SafePWM(channel) {
}
Servo::~Servo() {
if (m_table != nullptr) {
m_table->RemoveTableListener(this);
}
if (m_valueListener != 0) m_valueEntry.RemoveListener(m_valueListener);
}
/**
@@ -98,35 +96,38 @@ double Servo::GetAngle() const {
return GetPosition() * GetServoAngleRange() + kMinServoAngle;
}
void Servo::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (!value->IsDouble()) return;
Set(value->GetDouble());
}
void Servo::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", Get());
}
if (m_valueEntry) m_valueEntry.SetDouble(Get());
}
void Servo::StartLiveWindowMode() {
if (m_table != nullptr) {
m_table->AddTableListener("Value", this, true);
if (m_valueEntry) {
m_valueListener = m_valueEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsDouble()) return;
Set(event.value->GetDouble());
},
NT_NOTIFY_IMMEDIATE | NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
void Servo::StopLiveWindowMode() {
if (m_table != nullptr) {
m_table->RemoveTableListener(this);
if (m_valueListener != 0) {
m_valueEntry.RemoveListener(m_valueListener);
m_valueListener = 0;
}
}
std::string Servo::GetSmartDashboardType() const { return "Servo"; }
void Servo::InitTable(std::shared_ptr<ITable> subTable) {
void Servo::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Servo::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Servo::GetTable() const { return m_table; }

2
wpilibc/src/main/native/cpp/SmartDashboard/SendableChooserBase.cpp
View File

@@ -13,7 +13,7 @@ const char* SendableChooserBase::kDefault = "default";
const char* SendableChooserBase::kOptions = "options";
const char* SendableChooserBase::kSelected = "selected";
std::shared_ptr<ITable> SendableChooserBase::GetTable() const {
std::shared_ptr<nt::NetworkTable> SendableChooserBase::GetTable() const {
return m_table;
}

85
wpilibc/src/main/native/cpp/SmartDashboard/SmartDashboard.cpp
View File

@@ -7,18 +7,21 @@
#include "SmartDashboard/SmartDashboard.h"
#include <map>
#include "HLUsageReporting.h"
#include "SmartDashboard/NamedSendable.h"
#include "WPIErrors.h"
#include "networktables/NetworkTable.h"
#include "networktables/NetworkTableInstance.h"
using namespace frc;
std::shared_ptr<ITable> SmartDashboard::m_table;
std::map<std::shared_ptr<ITable>, Sendable*> SmartDashboard::m_tablesToData;
static std::shared_ptr<nt::NetworkTable> s_table;
static std::map<std::shared_ptr<nt::NetworkTable>, Sendable*> s_tablesToData;
void SmartDashboard::init() {
m_table = NetworkTable::GetTable("SmartDashboard");
s_table = nt::NetworkTableInstance::GetDefault().GetTable("SmartDashboard");
HLUsageReporting::ReportSmartDashboard();
}
@@ -30,7 +33,7 @@ void SmartDashboard::init() {
* @return true if the table as a value assigned to the given key
*/
bool SmartDashboard::ContainsKey(llvm::StringRef key) {
return m_table->ContainsKey(key);
return s_table->ContainsKey(key);
}
/**
@@ -38,7 +41,7 @@ bool SmartDashboard::ContainsKey(llvm::StringRef key) {
* @return keys currently in the table
*/
std::vector<std::string> SmartDashboard::GetKeys(int types) {
return m_table->GetKeys(types);
return s_table->GetKeys(types);
}
/**
@@ -47,7 +50,7 @@ std::vector<std::string> SmartDashboard::GetKeys(int types) {
* @param key the key to make persistent
*/
void SmartDashboard::SetPersistent(llvm::StringRef key) {
m_table->SetPersistent(key);
s_table->GetEntry(key).SetPersistent();
}
/**
@@ -57,7 +60,7 @@ void SmartDashboard::SetPersistent(llvm::StringRef key) {
* @param key the key name
*/
void SmartDashboard::ClearPersistent(llvm::StringRef key) {
m_table->ClearPersistent(key);
s_table->GetEntry(key).ClearPersistent();
}
/**
@@ -67,7 +70,7 @@ void SmartDashboard::ClearPersistent(llvm::StringRef key) {
* @param key the key name
*/
bool SmartDashboard::IsPersistent(llvm::StringRef key) {
return m_table->IsPersistent(key);
return s_table->GetEntry(key).IsPersistent();
}
/**
@@ -78,7 +81,7 @@ bool SmartDashboard::IsPersistent(llvm::StringRef key) {
* @param flags the flags to set (bitmask)
*/
void SmartDashboard::SetFlags(llvm::StringRef key, unsigned int flags) {
m_table->SetFlags(key, flags);
s_table->GetEntry(key).SetFlags(flags);
}
/**
@@ -89,7 +92,7 @@ void SmartDashboard::SetFlags(llvm::StringRef key, unsigned int flags) {
* @param flags the flags to clear (bitmask)
*/
void SmartDashboard::ClearFlags(llvm::StringRef key, unsigned int flags) {
m_table->ClearFlags(key, flags);
s_table->GetEntry(key).ClearFlags(flags);
}
/**
@@ -99,7 +102,7 @@ void SmartDashboard::ClearFlags(llvm::StringRef key, unsigned int flags) {
* @return the flags, or 0 if the key is not defined
*/
unsigned int SmartDashboard::GetFlags(llvm::StringRef key) {
return m_table->GetFlags(key);
return s_table->GetEntry(key).GetFlags();
}
/**
@@ -107,7 +110,7 @@ unsigned int SmartDashboard::GetFlags(llvm::StringRef key) {
*
* @param key the key name
*/
void SmartDashboard::Delete(llvm::StringRef key) { m_table->Delete(key); }
void SmartDashboard::Delete(llvm::StringRef key) { s_table->Delete(key); }
/**
* Maps the specified key to the specified value in this table.
@@ -123,10 +126,10 @@ void SmartDashboard::PutData(llvm::StringRef key, Sendable* data) {
wpi_setGlobalWPIErrorWithContext(NullParameter, "value");
return;
}
std::shared_ptr<ITable> dataTable(m_table->GetSubTable(key));
dataTable->PutString("~TYPE~", data->GetSmartDashboardType());
std::shared_ptr<nt::NetworkTable> dataTable(s_table->GetSubTable(key));
dataTable->GetEntry("~TYPE~").SetString(data->GetSmartDashboardType());
data->InitTable(dataTable);
m_tablesToData[dataTable] = data;
s_tablesToData[dataTable] = data;
}
/**
@@ -153,8 +156,8 @@ void SmartDashboard::PutData(NamedSendable* value) {
* @return the value
*/
Sendable* SmartDashboard::GetData(llvm::StringRef key) {
std::shared_ptr<ITable> subtable(m_table->GetSubTable(key));
Sendable* data = m_tablesToData[subtable];
std::shared_ptr<nt::NetworkTable> subtable(s_table->GetSubTable(key));
Sendable* data = s_tablesToData[subtable];
if (data == nullptr) {
wpi_setGlobalWPIErrorWithContext(SmartDashboardMissingKey, key);
return nullptr;
@@ -175,7 +178,7 @@ Sendable* SmartDashboard::GetData(llvm::StringRef key) {
*/
bool SmartDashboard::PutValue(llvm::StringRef keyName,
std::shared_ptr<nt::Value> value) {
return m_table->PutValue(keyName, value);
return s_table->GetEntry(keyName).SetValue(value);
}
/**
@@ -186,7 +189,7 @@ bool SmartDashboard::PutValue(llvm::StringRef keyName,
*/
bool SmartDashboard::SetDefaultValue(llvm::StringRef key,
std::shared_ptr<nt::Value> defaultValue) {
return m_table->SetDefaultValue(key, defaultValue);
return s_table->GetEntry(key).SetDefaultValue(defaultValue);
}
/**
@@ -197,7 +200,7 @@ bool SmartDashboard::SetDefaultValue(llvm::StringRef key,
* @param value the object to retrieve the value into
*/
std::shared_ptr<nt::Value> SmartDashboard::GetValue(llvm::StringRef keyName) {
return m_table->GetValue(keyName);
return s_table->GetEntry(keyName).GetValue();
}
/**
@@ -211,7 +214,7 @@ std::shared_ptr<nt::Value> SmartDashboard::GetValue(llvm::StringRef keyName) {
* @return False if the table key already exists with a different type
*/
bool SmartDashboard::PutBoolean(llvm::StringRef keyName, bool value) {
return m_table->PutBoolean(keyName, value);
return s_table->GetEntry(keyName).SetBoolean(value);
}
/**
@@ -221,7 +224,7 @@ bool SmartDashboard::PutBoolean(llvm::StringRef keyName, bool value) {
* @returns False if the table key exists with a different type
*/
bool SmartDashboard::SetDefaultBoolean(llvm::StringRef key, bool defaultValue) {
return m_table->SetDefaultBoolean(key, defaultValue);
return s_table->GetEntry(key).SetDefaultBoolean(defaultValue);
}
/**
@@ -233,7 +236,7 @@ bool SmartDashboard::SetDefaultBoolean(llvm::StringRef key, bool defaultValue) {
* @return the value
*/
bool SmartDashboard::GetBoolean(llvm::StringRef keyName, bool defaultValue) {
return m_table->GetBoolean(keyName, defaultValue);
return s_table->GetEntry(keyName).GetBoolean(defaultValue);
}
/**
@@ -247,7 +250,7 @@ bool SmartDashboard::GetBoolean(llvm::StringRef keyName, bool defaultValue) {
* @return False if the table key already exists with a different type
*/
bool SmartDashboard::PutNumber(llvm::StringRef keyName, double value) {
return m_table->PutNumber(keyName, value);
return s_table->GetEntry(keyName).SetDouble(value);
}
/**
@@ -258,7 +261,7 @@ bool SmartDashboard::PutNumber(llvm::StringRef keyName, double value) {
*/
bool SmartDashboard::SetDefaultNumber(llvm::StringRef key,
double defaultValue) {
return m_table->SetDefaultNumber(key, defaultValue);
return s_table->GetEntry(key).SetDefaultDouble(defaultValue);
}
/**
@@ -270,7 +273,7 @@ bool SmartDashboard::SetDefaultNumber(llvm::StringRef key,
* @return the value
*/
double SmartDashboard::GetNumber(llvm::StringRef keyName, double defaultValue) {
return m_table->GetNumber(keyName, defaultValue);
return s_table->GetEntry(keyName).GetDouble(defaultValue);
}
/**
@@ -284,7 +287,7 @@ double SmartDashboard::GetNumber(llvm::StringRef keyName, double defaultValue) {
* @return False if the table key already exists with a different type
*/
bool SmartDashboard::PutString(llvm::StringRef keyName, llvm::StringRef value) {
return m_table->PutString(keyName, value);
return s_table->GetEntry(keyName).SetString(value);
}
/**
@@ -295,7 +298,7 @@ bool SmartDashboard::PutString(llvm::StringRef keyName, llvm::StringRef value) {
*/
bool SmartDashboard::SetDefaultString(llvm::StringRef key,
llvm::StringRef defaultValue) {
return m_table->SetDefaultString(key, defaultValue);
return s_table->GetEntry(key).SetDefaultString(defaultValue);
}
/**
@@ -308,7 +311,7 @@ bool SmartDashboard::SetDefaultString(llvm::StringRef key,
*/
std::string SmartDashboard::GetString(llvm::StringRef keyName,
llvm::StringRef defaultValue) {
return m_table->GetString(keyName, defaultValue);
return s_table->GetEntry(keyName).GetString(defaultValue);
}
/**
@@ -323,7 +326,7 @@ std::string SmartDashboard::GetString(llvm::StringRef keyName,
*/
bool SmartDashboard::PutBooleanArray(llvm::StringRef key,
llvm::ArrayRef<int> value) {
return m_table->PutBooleanArray(key, value);
return s_table->GetEntry(key).SetBooleanArray(value);
}
/**
@@ -334,7 +337,7 @@ bool SmartDashboard::PutBooleanArray(llvm::StringRef key,
*/
bool SmartDashboard::SetDefaultBooleanArray(llvm::StringRef key,
llvm::ArrayRef<int> defaultValue) {
return m_table->SetDefaultBooleanArray(key, defaultValue);
return s_table->GetEntry(key).SetDefaultBooleanArray(defaultValue);
}
/**
@@ -354,7 +357,7 @@ bool SmartDashboard::SetDefaultBooleanArray(llvm::StringRef key,
*/
std::vector<int> SmartDashboard::GetBooleanArray(
llvm::StringRef key, llvm::ArrayRef<int> defaultValue) {
return m_table->GetBooleanArray(key, defaultValue);
return s_table->GetEntry(key).GetBooleanArray(defaultValue);
}
/**
@@ -365,7 +368,7 @@ std::vector<int> SmartDashboard::GetBooleanArray(
*/
bool SmartDashboard::PutNumberArray(llvm::StringRef key,
llvm::ArrayRef<double> value) {
return m_table->PutNumberArray(key, value);
return s_table->GetEntry(key).SetDoubleArray(value);
}
/**
@@ -376,7 +379,7 @@ bool SmartDashboard::PutNumberArray(llvm::StringRef key,
*/
bool SmartDashboard::SetDefaultNumberArray(
llvm::StringRef key, llvm::ArrayRef<double> defaultValue) {
return m_table->SetDefaultNumberArray(key, defaultValue);
return s_table->GetEntry(key).SetDefaultDoubleArray(defaultValue);
}
/**
@@ -392,7 +395,7 @@ bool SmartDashboard::SetDefaultNumberArray(
*/
std::vector<double> SmartDashboard::GetNumberArray(
llvm::StringRef key, llvm::ArrayRef<double> defaultValue) {
return m_table->GetNumberArray(key, defaultValue);
return s_table->GetEntry(key).GetDoubleArray(defaultValue);
}
/**
@@ -403,7 +406,7 @@ std::vector<double> SmartDashboard::GetNumberArray(
*/
bool SmartDashboard::PutStringArray(llvm::StringRef key,
llvm::ArrayRef<std::string> value) {
return m_table->PutStringArray(key, value);
return s_table->GetEntry(key).SetStringArray(value);
}
/**
@@ -414,7 +417,7 @@ bool SmartDashboard::PutStringArray(llvm::StringRef key,
*/
bool SmartDashboard::SetDefaultStringArray(
llvm::StringRef key, llvm::ArrayRef<std::string> defaultValue) {
return m_table->SetDefaultStringArray(key, defaultValue);
return s_table->GetEntry(key).SetDefaultStringArray(defaultValue);
}
/**
@@ -430,7 +433,7 @@ bool SmartDashboard::SetDefaultStringArray(
*/
std::vector<std::string> SmartDashboard::GetStringArray(
llvm::StringRef key, llvm::ArrayRef<std::string> defaultValue) {
return m_table->GetStringArray(key, defaultValue);
return s_table->GetEntry(key).GetStringArray(defaultValue);
}
/**
@@ -440,7 +443,7 @@ std::vector<std::string> SmartDashboard::GetStringArray(
* @return False if the table key already exists with a different type
*/
bool SmartDashboard::PutRaw(llvm::StringRef key, llvm::StringRef value) {
return m_table->PutRaw(key, value);
return s_table->GetEntry(key).SetRaw(value);
}
/**
@@ -451,7 +454,7 @@ bool SmartDashboard::PutRaw(llvm::StringRef key, llvm::StringRef value) {
*/
bool SmartDashboard::SetDefaultRaw(llvm::StringRef key,
llvm::StringRef defaultValue) {
return m_table->SetDefaultRaw(key, defaultValue);
return s_table->GetEntry(key).SetDefaultRaw(defaultValue);
}
/**
@@ -467,5 +470,5 @@ bool SmartDashboard::SetDefaultRaw(llvm::StringRef key,
*/
std::string SmartDashboard::GetRaw(llvm::StringRef key,
llvm::StringRef defaultValue) {
return m_table->GetRaw(key, defaultValue);
return s_table->GetEntry(key).GetRaw(defaultValue);
}

36
wpilibc/src/main/native/cpp/Solenoid.cpp
View File

@@ -68,7 +68,7 @@ Solenoid::Solenoid(int moduleNumber, int channel)
*/
Solenoid::~Solenoid() {
HAL_FreeSolenoidPort(m_solenoidHandle);
if (m_table != nullptr) m_table->RemoveTableListener(this);
if (m_valueListener != 0) m_valueEntry.RemoveListener(m_valueListener);
}
/**
@@ -111,37 +111,37 @@ bool Solenoid::IsBlackListed() const {
return (value != 0);
}
void Solenoid::ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) {
if (!value->IsBoolean()) return;
Set(value->GetBoolean());
}
void Solenoid::UpdateTable() {
if (m_table != nullptr) {
m_table->PutBoolean("Value", Get());
}
if (m_valueEntry) m_valueEntry.SetBoolean(Get());
}
void Solenoid::StartLiveWindowMode() {
Set(false);
if (m_table != nullptr) {
m_table->AddTableListener("Value", this, true);
if (m_valueEntry) {
m_valueEntry.AddListener(
[=](const nt::EntryNotification& event) {
if (!event.value->IsBoolean()) return;
Set(event.value->GetBoolean());
},
NT_NOTIFY_IMMEDIATE | NT_NOTIFY_NEW | NT_NOTIFY_UPDATE);
}
}
void Solenoid::StopLiveWindowMode() {
Set(false);
if (m_table != nullptr) {
m_table->RemoveTableListener(this);
}
if (m_valueListener != 0) m_valueEntry.RemoveListener(m_valueListener);
}
std::string Solenoid::GetSmartDashboardType() const { return "Solenoid"; }
void Solenoid::InitTable(std::shared_ptr<ITable> subTable) {
void Solenoid::InitTable(std::shared_ptr<nt::NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Solenoid::GetTable() const { return m_table; }
std::shared_ptr<nt::NetworkTable> Solenoid::GetTable() const { return m_table; }

15
wpilibc/src/main/native/cpp/Ultrasonic.cpp
View File

@@ -319,8 +319,8 @@ Ultrasonic::DistanceUnit Ultrasonic::GetDistanceUnits() const {
}
void Ultrasonic::UpdateTable() {
if (m_table != nullptr) {
m_table->PutNumber("Value", GetRangeInches());
if (m_valueEntry) {
m_valueEntry.SetDouble(GetRangeInches());
}
}
@@ -330,9 +330,14 @@ void Ultrasonic::StopLiveWindowMode() {}
std::string Ultrasonic::GetSmartDashboardType() const { return "Ultrasonic"; }
void Ultrasonic::InitTable(std::shared_ptr<ITable> subTable) {
void Ultrasonic::InitTable(std::shared_ptr<NetworkTable> subTable) {
m_table = subTable;
UpdateTable();
if (m_table != nullptr) {
m_valueEntry = m_table->GetEntry("Value");
UpdateTable();
} else {
m_valueEntry = nt::NetworkTableEntry();
}
}
std::shared_ptr<ITable> Ultrasonic::GetTable() const { return m_table; }
std::shared_ptr<NetworkTable> Ultrasonic::GetTable() const { return m_table; }

10
wpilibc/src/main/native/include/ADXL345_I2C.h
View File

@@ -13,6 +13,7 @@
#include "I2C.h"
#include "LiveWindow/LiveWindowSendable.h"
#include "interfaces/Accelerometer.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -71,9 +72,9 @@ class ADXL345_I2C : public Accelerometer, public LiveWindowSendable {
virtual AllAxes GetAccelerations();
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
void UpdateTable() override;
std::shared_ptr<ITable> GetTable() const override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
void StartLiveWindowMode() override {}
void StopLiveWindowMode() override {}
@@ -81,7 +82,10 @@ class ADXL345_I2C : public Accelerometer, public LiveWindowSendable {
I2C m_i2c;
private:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_xEntry;
nt::NetworkTableEntry m_yEntry;
nt::NetworkTableEntry m_zEntry;
};
} // namespace frc

10
wpilibc/src/main/native/include/ADXL345_SPI.h
View File

@@ -14,6 +14,7 @@
#include "SPI.h"
#include "SensorBase.h"
#include "interfaces/Accelerometer.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -73,9 +74,9 @@ class ADXL345_SPI : public Accelerometer, public LiveWindowSendable {
virtual AllAxes GetAccelerations();
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
void UpdateTable() override;
std::shared_ptr<ITable> GetTable() const override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
void StartLiveWindowMode() override {}
void StopLiveWindowMode() override {}
@@ -83,7 +84,10 @@ class ADXL345_SPI : public Accelerometer, public LiveWindowSendable {
SPI m_spi;
private:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_xEntry;
nt::NetworkTableEntry m_yEntry;
nt::NetworkTableEntry m_zEntry;
};
} // namespace frc

10
wpilibc/src/main/native/include/ADXL362.h
View File

@@ -14,6 +14,7 @@
#include "SPI.h"
#include "SensorBase.h"
#include "interfaces/Accelerometer.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -52,9 +53,9 @@ class ADXL362 : public Accelerometer, public LiveWindowSendable {
virtual AllAxes GetAccelerations();
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
void UpdateTable() override;
std::shared_ptr<ITable> GetTable() const override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
void StartLiveWindowMode() override {}
void StopLiveWindowMode() override {}
@@ -62,7 +63,10 @@ class ADXL362 : public Accelerometer, public LiveWindowSendable {
SPI m_spi;
double m_gsPerLSB = 0.001;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_xEntry;
nt::NetworkTableEntry m_yEntry;
nt::NetworkTableEntry m_zEntry;
};
} // namespace frc

8
wpilibc/src/main/native/include/AnalogAccelerometer.h
View File

@@ -14,6 +14,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "PIDSource.h"
#include "SensorBase.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -41,8 +42,8 @@ class AnalogAccelerometer : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
private:
void InitAccelerometer();
@@ -51,7 +52,8 @@ class AnalogAccelerometer : public SensorBase,
double m_voltsPerG = 1.0;
double m_zeroGVoltage = 2.5;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
};
} // namespace frc

8
wpilibc/src/main/native/include/AnalogInput.h
View File

@@ -17,6 +17,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "PIDSource.h"
#include "SensorBase.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -81,8 +82,8 @@ class AnalogInput : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
private:
int m_channel;
@@ -90,7 +91,8 @@ class AnalogInput : public SensorBase,
HAL_AnalogInputHandle m_port;
int64_t m_accumulatorOffset;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
};
} // namespace frc

8
wpilibc/src/main/native/include/AnalogOutput.h
View File

@@ -14,6 +14,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "SensorBase.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -33,14 +34,15 @@ class AnalogOutput : public SensorBase, public LiveWindowSendable {
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
protected:
int m_channel;
HAL_AnalogOutputHandle m_port;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
};
} // namespace frc

8
wpilibc/src/main/native/include/AnalogPotentiometer.h
View File

@@ -13,6 +13,7 @@
#include "AnalogInput.h"
#include "LiveWindow/LiveWindowSendable.h"
#include "interfaces/Potentiometer.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -71,9 +72,9 @@ class AnalogPotentiometer : public Potentiometer, public LiveWindowSendable {
* Live Window code, only does anything if live window is activated.
*/
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
void UpdateTable() override;
std::shared_ptr<ITable> GetTable() const override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
/**
* AnalogPotentiometers don't have to do anything special when entering the
@@ -90,7 +91,8 @@ class AnalogPotentiometer : public Potentiometer, public LiveWindowSendable {
private:
std::shared_ptr<AnalogInput> m_analog_input;
double m_fullRange, m_offset;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
};
} // namespace frc

10
wpilibc/src/main/native/include/BuiltInAccelerometer.h
View File

@@ -13,6 +13,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "SensorBase.h"
#include "interfaces/Accelerometer.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -35,14 +36,17 @@ class BuiltInAccelerometer : public Accelerometer,
double GetZ() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<NetworkTable> subtable) override;
void UpdateTable() override;
std::shared_ptr<ITable> GetTable() const override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
void StartLiveWindowMode() override {}
void StopLiveWindowMode() override {}
private:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_xEntry;
nt::NetworkTableEntry m_yEntry;
nt::NetworkTableEntry m_zEntry;
};
} // namespace frc

12
wpilibc/src/main/native/include/Buttons/NetworkButton.h
View File

@@ -8,23 +8,25 @@
#pragma once
#include <memory>
#include <string>
#include <llvm/StringRef.h>
#include "Buttons/Button.h"
#include "networktables/NetworkTable.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
class NetworkButton : public Button {
public:
NetworkButton(const std::string& tableName, const std::string& field);
NetworkButton(std::shared_ptr<ITable> table, const std::string& field);
NetworkButton(llvm::StringRef tableName, llvm::StringRef field);
NetworkButton(std::shared_ptr<nt::NetworkTable> table, llvm::StringRef field);
virtual ~NetworkButton() = default;
virtual bool Get();
private:
std::shared_ptr<ITable> m_netTable;
std::string m_field;
nt::NetworkTableEntry m_entry;
};
} // namespace frc

8
wpilibc/src/main/native/include/Buttons/Trigger.h
View File

@@ -11,6 +11,7 @@
#include <string>
#include "SmartDashboard/Sendable.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -43,12 +44,13 @@ class Trigger : public Sendable {
void CancelWhenActive(Command* command);
void ToggleWhenActive(Command* command);
void InitTable(std::shared_ptr<ITable> subtable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::string GetSmartDashboardType() const override;
protected:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_pressedEntry;
};
} // namespace frc

6
wpilibc/src/main/native/include/CameraServer.h
View File

@@ -293,7 +293,7 @@ class CameraServer : public ErrorBase {
private:
CameraServer();
std::shared_ptr<ITable> GetSourceTable(CS_Source source);
std::shared_ptr<nt::NetworkTable> GetSourceTable(CS_Source source);
std::vector<std::string> GetSinkStreamValues(CS_Sink sink);
std::vector<std::string> GetSourceStreamValues(CS_Source source);
void UpdateStreamValues();
@@ -305,8 +305,8 @@ class CameraServer : public ErrorBase {
std::string m_primarySourceName;
llvm::StringMap<cs::VideoSource> m_sources;
llvm::StringMap<cs::VideoSink> m_sinks;
llvm::DenseMap<CS_Source, std::shared_ptr<ITable>> m_tables;
std::shared_ptr<NetworkTable> m_publishTable;
llvm::DenseMap<CS_Source, std::shared_ptr<nt::NetworkTable>> m_tables;
std::shared_ptr<nt::NetworkTable> m_publishTable;
cs::VideoListener m_videoListener;
int m_tableListener;
int m_nextPort;

17
wpilibc/src/main/native/include/Commands/Command.h
View File

@@ -13,7 +13,7 @@
#include "ErrorBase.h"
#include "SmartDashboard/NamedSendable.h"
#include "tables/ITableListener.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -49,7 +49,7 @@ class Subsystem;
* @see CommandGroup
* @see Subsystem
*/
class Command : public ErrorBase, public NamedSendable, public ITableListener {
class Command : public ErrorBase, public NamedSendable {
friend class CommandGroup;
friend class Scheduler;
@@ -160,14 +160,17 @@ class Command : public ErrorBase, public NamedSendable, public ITableListener {
public:
std::string GetName() const override;
void InitTable(std::shared_ptr<ITable> subtable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::string GetSmartDashboardType() const override;
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
protected:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
private:
nt::NetworkTableEntry m_runningEntry;
nt::NetworkTableEntry m_isParentedEntry;
NT_EntryListener m_runningListener = 0;
};
} // namespace frc

2
wpilibc/src/main/native/include/Commands/PIDCommand.h
View File

@@ -54,7 +54,7 @@ class PIDCommand : public Command, public PIDOutput, public PIDSource {
std::shared_ptr<PIDController> m_controller;
public:
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
std::string GetSmartDashboardType() const override;
};

2
wpilibc/src/main/native/include/Commands/PIDSubsystem.h
View File

@@ -69,7 +69,7 @@ class PIDSubsystem : public Subsystem, public PIDOutput, public PIDSource {
std::shared_ptr<PIDController> m_controller;
public:
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
std::string GetSmartDashboardType() const override;
};

10
wpilibc/src/main/native/include/Commands/Scheduler.h
View File

@@ -21,6 +21,7 @@
#include "SmartDashboard/NamedSendable.h"
#include "SmartDashboard/SmartDashboard.h"
#include "networktables/NetworkTable.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -42,8 +43,8 @@ class Scheduler : public ErrorBase, public NamedSendable {
void UpdateTable();
std::string GetSmartDashboardType() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable);
std::shared_ptr<nt::NetworkTable> GetTable() const;
std::string GetName() const;
std::string GetType() const;
@@ -67,7 +68,10 @@ class Scheduler : public ErrorBase, public NamedSendable {
std::vector<std::string> commands;
std::vector<double> ids;
std::vector<double> toCancel;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_namesEntry;
nt::NetworkTableEntry m_idsEntry;
nt::NetworkTableEntry m_cancelEntry;
bool m_runningCommandsChanged = false;
};

11
wpilibc/src/main/native/include/Commands/Subsystem.h
View File

@@ -12,6 +12,7 @@
#include "ErrorBase.h"
#include "SmartDashboard/NamedSendable.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -42,12 +43,16 @@ class Subsystem : public ErrorBase, public NamedSendable {
public:
std::string GetName() const override;
void InitTable(std::shared_ptr<ITable> subtable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::string GetSmartDashboardType() const override;
protected:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_hasDefaultEntry;
nt::NetworkTableEntry m_defaultEntry;
nt::NetworkTableEntry m_hasCommandEntry;
nt::NetworkTableEntry m_commandEntry;
};
} // namespace frc

19
wpilibc/src/main/native/include/Compressor.h
View File

@@ -14,7 +14,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "SensorBase.h"
#include "tables/ITableListener.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -31,13 +31,11 @@ namespace frc {
* loop control. You can only turn off closed loop control, thereby stopping
* the compressor from operating.
*/
class Compressor : public SensorBase,
public LiveWindowSendable,
public ITableListener {
class Compressor : public SensorBase, public LiveWindowSendable {
public:
// Default PCM ID is 0
explicit Compressor(int pcmID = GetDefaultSolenoidModule());
virtual ~Compressor() = default;
virtual ~Compressor();
void Start();
void Stop();
@@ -62,10 +60,8 @@ class Compressor : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
protected:
HAL_CompressorHandle m_compressorHandle;
@@ -74,7 +70,10 @@ class Compressor : public SensorBase,
void SetCompressor(bool on);
int m_module;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_enabledEntry;
nt::NetworkTableEntry m_pressureSwitchEntry;
NT_EntryListener m_enabledListener = 0;
};
} // namespace frc

8
wpilibc/src/main/native/include/Counter.h
View File

@@ -17,6 +17,7 @@
#include "CounterBase.h"
#include "LiveWindow/LiveWindowSendable.h"
#include "SensorBase.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -98,8 +99,8 @@ class Counter : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
protected:
// Makes the counter count up.
@@ -112,7 +113,8 @@ class Counter : public SensorBase,
private:
int m_index = 0; ///< The index of this counter.
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
friend class DigitalGlitchFilter;
};

8
wpilibc/src/main/native/include/DigitalInput.h
View File

@@ -12,6 +12,7 @@
#include "DigitalSource.h"
#include "LiveWindow/LiveWindowSendable.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -41,14 +42,15 @@ class DigitalInput : public DigitalSource, public LiveWindowSendable {
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
private:
int m_channel;
HAL_DigitalHandle m_handle;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
friend class DigitalGlitchFilter;
};

16
wpilibc/src/main/native/include/DigitalOutput.h
View File

@@ -14,7 +14,7 @@
#include "DigitalSource.h"
#include "LiveWindow/LiveWindowSendable.h"
#include "tables/ITableListener.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -24,9 +24,7 @@ namespace frc {
* elsewhere will allocate channels automatically so for those devices it
* shouldn't be done here.
*/
class DigitalOutput : public DigitalSource,
public ITableListener,
public LiveWindowSendable {
class DigitalOutput : public DigitalSource, public LiveWindowSendable {
public:
explicit DigitalOutput(int channel);
virtual ~DigitalOutput();
@@ -45,21 +43,21 @@ class DigitalOutput : public DigitalSource,
AnalogTriggerType GetAnalogTriggerTypeForRouting() const override;
bool IsAnalogTrigger() const override;
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
private:
int m_channel;
HAL_DigitalHandle m_handle;
HAL_DigitalPWMHandle m_pwmGenerator;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
NT_EntryListener m_valueListener = 0;
};
} // namespace frc

16
wpilibc/src/main/native/include/DoubleSolenoid.h
View File

@@ -14,7 +14,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "SolenoidBase.h"
#include "tables/ITableListener.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -25,9 +25,7 @@ namespace frc {
* The DoubleSolenoid class is typically used for pneumatics solenoids that
* have two positions controlled by two separate channels.
*/
class DoubleSolenoid : public SolenoidBase,
public LiveWindowSendable,
public ITableListener {
class DoubleSolenoid : public SolenoidBase, public LiveWindowSendable {
public:
enum Value { kOff, kForward, kReverse };
@@ -39,14 +37,12 @@ class DoubleSolenoid : public SolenoidBase,
bool IsFwdSolenoidBlackListed() const;
bool IsRevSolenoidBlackListed() const;
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew);
void UpdateTable();
void StartLiveWindowMode();
void StopLiveWindowMode();
std::string GetSmartDashboardType() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable);
std::shared_ptr<nt::NetworkTable> GetTable() const;
private:
int m_forwardChannel; ///< The forward channel on the module to control.
@@ -56,7 +52,9 @@ class DoubleSolenoid : public SolenoidBase,
HAL_SolenoidHandle m_forwardHandle = HAL_kInvalidHandle;
HAL_SolenoidHandle m_reverseHandle = HAL_kInvalidHandle;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
NT_EntryListener m_valueListener = 0;
};
} // namespace frc

10
wpilibc/src/main/native/include/Encoder.h
View File

@@ -17,6 +17,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "PIDSource.h"
#include "SensorBase.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -88,8 +89,8 @@ class Encoder : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
int GetFPGAIndex() const;
@@ -103,7 +104,10 @@ class Encoder : public SensorBase,
std::unique_ptr<DigitalSource> m_indexSource = nullptr;
HAL_EncoderHandle m_encoder = HAL_kInvalidHandle;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_speedEntry;
nt::NetworkTableEntry m_distanceEntry;
nt::NetworkTableEntry m_distancePerTickEntry;
friend class DigitalGlitchFilter;
};

8
wpilibc/src/main/native/include/GyroBase.h
View File

@@ -14,6 +14,7 @@
#include "PIDSource.h"
#include "SensorBase.h"
#include "interfaces/Gyro.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -35,11 +36,12 @@ class GyroBase : public Gyro,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
private:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
};
} // namespace frc

8
wpilibc/src/main/native/include/LiveWindow/LiveWindow.h
View File

@@ -14,7 +14,8 @@
#include "Commands/Scheduler.h"
#include "LiveWindow/LiveWindowSendable.h"
#include "tables/ITable.h"
#include "networktables/NetworkTable.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -75,8 +76,9 @@ class LiveWindow {
std::map<std::shared_ptr<LiveWindowSendable>, LiveWindowComponent>
m_components;
std::shared_ptr<ITable> m_liveWindowTable;
std::shared_ptr<ITable> m_statusTable;
std::shared_ptr<nt::NetworkTable> m_liveWindowTable;
std::shared_ptr<nt::NetworkTable> m_statusTable;
nt::NetworkTableEntry m_enabledEntry;
Scheduler* m_scheduler;

23
wpilibc/src/main/native/include/LiveWindow/LiveWindowStatusListener.h
View File

@@ -1,23 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2012-2017 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#pragma once
#include <memory>
#include "tables/ITable.h"
#include "tables/ITableListener.h"
namespace frc {
class LiveWindowStatusListener : public ITableListener {
public:
virtual void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew);
};
} // namespace frc

27
wpilibc/src/main/native/include/PIDController.h
View File

@@ -21,6 +21,7 @@
#include "PIDInterface.h"
#include "PIDSource.h"
#include "Timer.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -36,9 +37,7 @@ class PIDOutput;
* in the integral and derivative calculations. Therefore, the sample rate
* affects the controller's behavior for a given set of PID constants.
*/
class PIDController : public LiveWindowSendable,
public PIDInterface,
public ITableListener {
class PIDController : public LiveWindowSendable, public PIDInterface {
public:
PIDController(double p, double i, double d, PIDSource* source,
PIDOutput* output, double period = 0.05);
@@ -82,13 +81,26 @@ class PIDController : public LiveWindowSendable,
void Reset() override;
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
protected:
PIDSource* m_pidInput;
PIDOutput* m_pidOutput;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_pEntry;
nt::NetworkTableEntry m_iEntry;
nt::NetworkTableEntry m_dEntry;
nt::NetworkTableEntry m_fEntry;
nt::NetworkTableEntry m_setpointEntry;
nt::NetworkTableEntry m_enabledEntry;
NT_EntryListener m_pListener = 0;
NT_EntryListener m_iListener = 0;
NT_EntryListener m_dListener = 0;
NT_EntryListener m_fListener = 0;
NT_EntryListener m_setpointListener = 0;
NT_EntryListener m_enabledListener = 0;
virtual void Calculate();
virtual double CalculateFeedForward();
double GetContinuousError(double error) const;
@@ -142,13 +154,12 @@ class PIDController : public LiveWindowSendable,
std::unique_ptr<Notifier> m_controlLoop;
Timer m_setpointTimer;
std::shared_ptr<ITable> GetTable() const override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::string GetSmartDashboardType() const override;
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
void RemoveListeners();
};
} // namespace frc

16
wpilibc/src/main/native/include/PWM.h
View File

@@ -16,7 +16,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "SensorBase.h"
#include "tables/ITableListener.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -37,9 +37,7 @@ namespace frc {
* - 1 = minimum pulse width (currently .5ms)
* - 0 = disabled (i.e. PWM output is held low)
*/
class PWM : public SensorBase,
public ITableListener,
public LiveWindowSendable {
class PWM : public SensorBase, public LiveWindowSendable {
public:
/**
* Represents the amount to multiply the minimum servo-pulse pwm period by.
@@ -80,16 +78,16 @@ class PWM : public SensorBase,
int GetChannel() const { return m_channel; }
protected:
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
NT_EntryListener m_valueListener = 0;
private:
int m_channel;

10
wpilibc/src/main/native/include/PowerDistributionPanel.h
View File

@@ -12,6 +12,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "SensorBase.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -37,11 +38,14 @@ class PowerDistributionPanel : public SensorBase, public LiveWindowSendable {
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
private:
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_chanEntry[16];
nt::NetworkTableEntry m_voltageEntry;
nt::NetworkTableEntry m_totalCurrentEntry;
int m_module;
};

13
wpilibc/src/main/native/include/Preferences.h
View File

@@ -15,7 +15,6 @@
#include "ErrorBase.h"
#include "networktables/NetworkTable.h"
#include "tables/ITableListener.h"
namespace frc {
@@ -58,16 +57,8 @@ class Preferences : public ErrorBase {
virtual ~Preferences() = default;
private:
std::shared_ptr<ITable> m_table;
class Listener : public ITableListener {
public:
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
void ValueChangedEx(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value,
uint32_t flags) override;
};
Listener m_listener;
std::shared_ptr<nt::NetworkTable> m_table;
NT_EntryListener m_listener;
};
} // namespace frc

19
wpilibc/src/main/native/include/Relay.h
View File

@@ -16,8 +16,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "MotorSafety.h"
#include "SensorBase.h"
#include "tables/ITable.h"
#include "tables/ITableListener.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -34,10 +33,7 @@ class MotorSafetyHelper;
* independently for something that does not care about voltage polarity (like
* a solenoid).
*/
class Relay : public MotorSafety,
public SensorBase,
public ITableListener,
public LiveWindowSendable {
class Relay : public MotorSafety, public SensorBase, public LiveWindowSendable {
public:
enum Value { kOff, kOn, kForward, kReverse };
enum Direction { kBothDirections, kForwardOnly, kReverseOnly };
@@ -57,16 +53,17 @@ class Relay : public MotorSafety,
void SetSafetyEnabled(bool enabled) override;
void GetDescription(llvm::raw_ostream& desc) const override;
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::shared_ptr<ITable> m_table;
protected:
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
NT_EntryListener m_valueListener = 0;
private:
int m_channel;

12
wpilibc/src/main/native/include/Servo.h
View File

@@ -12,6 +12,7 @@
#include "SafePWM.h"
#include "SpeedController.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -34,16 +35,17 @@ class Servo : public SafePWM {
static double GetMaxAngle() { return kMaxServoAngle; }
static double GetMinAngle() { return kMinServoAngle; }
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew) override;
void UpdateTable() override;
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::shared_ptr<ITable> m_table;
protected:
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
NT_EntryListener m_valueListener = 0;
private:
double GetServoAngleRange() const { return kMaxServoAngle - kMinServoAngle; }

6
wpilibc/src/main/native/include/SmartDashboard/Sendable.h
View File

@@ -10,7 +10,7 @@
#include <memory>
#include <string>
#include "tables/ITable.h"
#include "networktables/NetworkTable.h"
namespace frc {
@@ -20,12 +20,12 @@ class Sendable {
* Initializes a table for this sendable object.
* @param subtable The table to put the values in.
*/
virtual void InitTable(std::shared_ptr<ITable> subtable) = 0;
virtual void InitTable(std::shared_ptr<nt::NetworkTable> subtable) = 0;
/**
* @return the table that is currently associated with the sendable
*/
virtual std::shared_ptr<ITable> GetTable() const = 0;
virtual std::shared_ptr<nt::NetworkTable> GetTable() const = 0;
/**
* @return the string representation of the named data type that will be used

4
wpilibc/src/main/native/include/SmartDashboard/SendableChooser.h
View File

@@ -14,7 +14,7 @@
#include <llvm/StringRef.h>
#include "SmartDashboard/SendableChooserBase.h"
#include "tables/ITable.h"
#include "networktables/NetworkTable.h"
namespace frc {
@@ -53,7 +53,7 @@ class SendableChooser : public SendableChooserBase {
auto GetSelected() -> decltype(_unwrap_smart_ptr(m_choices[""]));
void InitTable(std::shared_ptr<ITable> subtable) override;
void InitTable(std::shared_ptr<nt::NetworkTable> subtable) override;
};
} // namespace frc

7
wpilibc/src/main/native/include/SmartDashboard/SendableChooser.inc
View File

@@ -68,7 +68,7 @@ auto SendableChooser<T>::GetSelected()
}
template <class T>
void SendableChooser<T>::InitTable(std::shared_ptr<ITable> subtable) {
void SendableChooser<T>::InitTable(std::shared_ptr<nt::NetworkTable> subtable) {
std::vector<std::string> keys;
m_table = subtable;
if (m_table != nullptr) {
@@ -79,8 +79,9 @@ void SendableChooser<T>::InitTable(std::shared_ptr<ITable> subtable) {
// Unlike std::map, llvm::StringMap elements are not sorted
std::sort(keys.begin(), keys.end());
m_table->PutValue(kOptions, nt::Value::MakeStringArray(std::move(keys)));
m_table->PutString(kDefault, m_defaultChoice);
m_table->GetEntry(kOptions).SetValue(
nt::Value::MakeStringArray(std::move(keys)));
m_table->GetEntry(kDefault).SetString(m_defaultChoice);
}
}

6
wpilibc/src/main/native/include/SmartDashboard/SendableChooserBase.h
View File

@@ -11,7 +11,7 @@
#include <string>
#include "SmartDashboard/Sendable.h"
#include "tables/ITable.h"
#include "networktables/NetworkTable.h"
namespace frc {
@@ -25,7 +25,7 @@ class SendableChooserBase : public Sendable {
public:
virtual ~SendableChooserBase() = default;
std::shared_ptr<ITable> GetTable() const override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
std::string GetSmartDashboardType() const override;
protected:
@@ -34,7 +34,7 @@ class SendableChooserBase : public Sendable {
static const char* kSelected;
std::string m_defaultChoice;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
};
} // namespace frc

17
wpilibc/src/main/native/include/SmartDashboard/SmartDashboard.h
View File

@@ -7,18 +7,18 @@
#pragma once
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "SensorBase.h"
#include "SmartDashboard/NamedSendable.h"
#include "SmartDashboard/Sendable.h"
#include "tables/ITable.h"
#include "networktables/NetworkTableValue.h"
namespace frc {
class NamedSendable;
class Sendable;
class SmartDashboard : public SensorBase {
public:
static void init();
@@ -86,15 +86,6 @@ class SmartDashboard : public SensorBase {
private:
virtual ~SmartDashboard() = default;
/** The {@link NetworkTable} used by {@link SmartDashboard} */
static std::shared_ptr<ITable> m_table;
/**
* A map linking tables in the SmartDashboard to the
* {@link SmartDashboardData} objects they came from.
*/
static std::map<std::shared_ptr<ITable>, Sendable*> m_tablesToData;
};
} // namespace frc

16
wpilibc/src/main/native/include/Solenoid.h
View File

@@ -14,7 +14,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "SolenoidBase.h"
#include "tables/ITableListener.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -24,9 +24,7 @@ namespace frc {
* The Solenoid class is typically used for pneumatics solenoids, but could be
* used for any device within the current spec of the PCM.
*/
class Solenoid : public SolenoidBase,
public LiveWindowSendable,
public ITableListener {
class Solenoid : public SolenoidBase, public LiveWindowSendable {
public:
explicit Solenoid(int channel);
Solenoid(int moduleNumber, int channel);
@@ -35,19 +33,19 @@ class Solenoid : public SolenoidBase,
virtual bool Get() const;
bool IsBlackListed() const;
void ValueChanged(ITable* source, llvm::StringRef key,
std::shared_ptr<nt::Value> value, bool isNew);
void UpdateTable();
void StartLiveWindowMode();
void StopLiveWindowMode();
std::string GetSmartDashboardType() const;
void InitTable(std::shared_ptr<ITable> subTable);
std::shared_ptr<ITable> GetTable() const;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable);
std::shared_ptr<nt::NetworkTable> GetTable() const;
private:
HAL_SolenoidHandle m_solenoidHandle = HAL_kInvalidHandle;
int m_channel; ///< The channel on the module to control.
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
NT_EntryListener m_valueListener = 0;
};
} // namespace frc

8
wpilibc/src/main/native/include/Ultrasonic.h
View File

@@ -17,6 +17,7 @@
#include "LiveWindow/LiveWindowSendable.h"
#include "PIDSource.h"
#include "SensorBase.h"
#include "networktables/NetworkTableEntry.h"
namespace frc {
@@ -69,8 +70,8 @@ class Ultrasonic : public SensorBase,
void StartLiveWindowMode() override;
void StopLiveWindowMode() override;
std::string GetSmartDashboardType() const override;
void InitTable(std::shared_ptr<ITable> subTable) override;
std::shared_ptr<ITable> GetTable() const override;
void InitTable(std::shared_ptr<nt::NetworkTable> subTable) override;
std::shared_ptr<nt::NetworkTable> GetTable() const override;
private:
void Initialize();
@@ -96,7 +97,8 @@ class Ultrasonic : public SensorBase,
Counter m_counter;
DistanceUnit m_units;
std::shared_ptr<ITable> m_table;
std::shared_ptr<nt::NetworkTable> m_table;
nt::NetworkTableEntry m_valueEntry;
};
} // namespace frc