SCRIPT Move cc files

wpilibc/src/main/native/cpp/hardware/discrete/AnalogInput.cpp

@@ -0,0 +1,132 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/AnalogInput.h"
+
+#include <string>
+
+#include <hal/AnalogInput.h>
+#include <hal/HALBase.h>
+#include <hal/Ports.h>
+#include <hal/UsageReporting.h>
+#include <wpi/StackTrace.h>
+#include <wpi/sendable/SendableBuilder.h>
+#include <wpi/sendable/SendableRegistry.h>
+
+#include "frc/Errors.h"
+#include "frc/SensorUtil.h"
+#include "frc/Timer.h"
+
+using namespace frc;
+
+AnalogInput::AnalogInput(int channel) {
+  if (!SensorUtil::CheckAnalogInputChannel(channel)) {
+    throw FRC_MakeError(err::ChannelIndexOutOfRange, "Channel {}", channel);
+  }
+
+  m_channel = channel;
+  int32_t status = 0;
+  std::string stackTrace = wpi::GetStackTrace(1);
+  m_port = HAL_InitializeAnalogInputPort(channel, stackTrace.c_str(), &status);
+  FRC_CheckErrorStatus(status, "Channel {}", channel);
+
+  HAL_ReportUsage("IO", channel, "AnalogInput");
+
+  wpi::SendableRegistry::Add(this, "AnalogInput", channel);
+}
+
+int AnalogInput::GetValue() const {
+  int32_t status = 0;
+  int value = HAL_GetAnalogValue(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return value;
+}
+
+int AnalogInput::GetAverageValue() const {
+  int32_t status = 0;
+  int value = HAL_GetAnalogAverageValue(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return value;
+}
+
+double AnalogInput::GetVoltage() const {
+  int32_t status = 0;
+  double voltage = HAL_GetAnalogVoltage(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return voltage;
+}
+
+double AnalogInput::GetAverageVoltage() const {
+  int32_t status = 0;
+  double voltage = HAL_GetAnalogAverageVoltage(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return voltage;
+}
+
+int AnalogInput::GetChannel() const {
+  return m_channel;
+}
+
+void AnalogInput::SetAverageBits(int bits) {
+  int32_t status = 0;
+  HAL_SetAnalogAverageBits(m_port, bits, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+int AnalogInput::GetAverageBits() const {
+  int32_t status = 0;
+  int averageBits = HAL_GetAnalogAverageBits(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return averageBits;
+}
+
+void AnalogInput::SetOversampleBits(int bits) {
+  int32_t status = 0;
+  HAL_SetAnalogOversampleBits(m_port, bits, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+int AnalogInput::GetOversampleBits() const {
+  int32_t status = 0;
+  int oversampleBits = HAL_GetAnalogOversampleBits(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return oversampleBits;
+}
+
+int AnalogInput::GetLSBWeight() const {
+  int32_t status = 0;
+  int lsbWeight = HAL_GetAnalogLSBWeight(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return lsbWeight;
+}
+
+int AnalogInput::GetOffset() const {
+  int32_t status = 0;
+  int offset = HAL_GetAnalogOffset(m_port, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return offset;
+}
+
+void AnalogInput::SetSampleRate(double samplesPerSecond) {
+  int32_t status = 0;
+  HAL_SetAnalogSampleRate(samplesPerSecond, &status);
+  FRC_CheckErrorStatus(status, "SetSampleRate");
+}
+
+double AnalogInput::GetSampleRate() {
+  int32_t status = 0;
+  double sampleRate = HAL_GetAnalogSampleRate(&status);
+  FRC_CheckErrorStatus(status, "GetSampleRate");
+  return sampleRate;
+}
+
+void AnalogInput::SetSimDevice(HAL_SimDeviceHandle device) {
+  HAL_SetAnalogInputSimDevice(m_port, device);
+}
+
+void AnalogInput::InitSendable(wpi::SendableBuilder& builder) {
+  builder.SetSmartDashboardType("Analog Input");
+  builder.AddDoubleProperty(
+      "Value", [=, this] { return GetAverageVoltage(); }, nullptr);
+}

wpilibc/src/main/native/cpp/hardware/discrete/DigitalInput.cpp

@@ -0,0 +1,55 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/DigitalInput.h"
+
+#include <string>
+
+#include <hal/DIO.h>
+#include <hal/HALBase.h>
+#include <hal/Ports.h>
+#include <hal/UsageReporting.h>
+#include <wpi/StackTrace.h>
+#include <wpi/sendable/SendableBuilder.h>
+#include <wpi/sendable/SendableRegistry.h>
+
+#include "frc/Errors.h"
+#include "frc/SensorUtil.h"
+
+using namespace frc;
+
+DigitalInput::DigitalInput(int channel) {
+  if (!SensorUtil::CheckDigitalChannel(channel)) {
+    throw FRC_MakeError(err::ChannelIndexOutOfRange, "Channel {}", channel);
+  }
+  m_channel = channel;
+
+  int32_t status = 0;
+  std::string stackTrace = wpi::GetStackTrace(1);
+  m_handle = HAL_InitializeDIOPort(channel, true, stackTrace.c_str(), &status);
+  FRC_CheckErrorStatus(status, "Channel {}", channel);
+
+  HAL_ReportUsage("IO", channel, "DigitalInput");
+  wpi::SendableRegistry::Add(this, "DigitalInput", channel);
+}
+
+bool DigitalInput::Get() const {
+  int32_t status = 0;
+  bool value = HAL_GetDIO(m_handle, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return value;
+}
+
+void DigitalInput::SetSimDevice(HAL_SimDeviceHandle device) {
+  HAL_SetDIOSimDevice(m_handle, device);
+}
+
+int DigitalInput::GetChannel() const {
+  return m_channel;
+}
+
+void DigitalInput::InitSendable(wpi::SendableBuilder& builder) {
+  builder.SetSmartDashboardType("Digital Input");
+  builder.AddBooleanProperty("Value", [=, this] { return Get(); }, nullptr);
+}

wpilibc/src/main/native/cpp/hardware/discrete/DigitalOutput.cpp

@@ -0,0 +1,151 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/DigitalOutput.h"
+
+#include <string>
+
+#include <hal/DIO.h>
+#include <hal/HALBase.h>
+#include <hal/Ports.h>
+#include <hal/UsageReporting.h>
+#include <wpi/StackTrace.h>
+#include <wpi/sendable/SendableBuilder.h>
+#include <wpi/sendable/SendableRegistry.h>
+
+#include "frc/Errors.h"
+#include "frc/SensorUtil.h"
+
+using namespace frc;
+
+DigitalOutput::DigitalOutput(int channel) {
+  m_pwmGenerator = HAL_kInvalidHandle;
+  if (!SensorUtil::CheckDigitalChannel(channel)) {
+    throw FRC_MakeError(err::ChannelIndexOutOfRange, "Channel {}", channel);
+  }
+  m_channel = channel;
+
+  int32_t status = 0;
+  std::string stackTrace = wpi::GetStackTrace(1);
+  m_handle = HAL_InitializeDIOPort(channel, false, stackTrace.c_str(), &status);
+  FRC_CheckErrorStatus(status, "Channel {}", channel);
+
+  HAL_ReportUsage("IO", channel, "DigitalOutput");
+  wpi::SendableRegistry::Add(this, "DigitalOutput", channel);
+}
+
+DigitalOutput::~DigitalOutput() {
+  if (m_handle != HAL_kInvalidHandle) {
+    // Disable the PWM in case it was running.
+    try {
+      DisablePWM();
+    } catch (const RuntimeError& e) {
+      e.Report();
+    }
+  }
+}
+
+void DigitalOutput::Set(bool value) {
+  int32_t status = 0;
+  HAL_SetDIO(m_handle, value, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+bool DigitalOutput::Get() const {
+  int32_t status = 0;
+  bool val = HAL_GetDIO(m_handle, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return val;
+}
+
+int DigitalOutput::GetChannel() const {
+  return m_channel;
+}
+
+void DigitalOutput::Pulse(units::second_t pulseLength) {
+  int32_t status = 0;
+  HAL_Pulse(m_handle, pulseLength.value(), &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+bool DigitalOutput::IsPulsing() const {
+  int32_t status = 0;
+  bool value = HAL_IsPulsing(m_handle, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+  return value;
+}
+
+void DigitalOutput::SetPWMRate(double rate) {
+  int32_t status = 0;
+  HAL_SetDigitalPWMRate(rate, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+void DigitalOutput::EnablePPS(double dutyCycle) {
+  if (m_pwmGenerator != HAL_kInvalidHandle) {
+    return;
+  }
+
+  int32_t status = 0;
+
+  m_pwmGenerator = HAL_AllocateDigitalPWM(&status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+
+  HAL_SetDigitalPWMPPS(m_pwmGenerator, dutyCycle, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+
+  HAL_SetDigitalPWMOutputChannel(m_pwmGenerator, m_channel, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+void DigitalOutput::EnablePWM(double initialDutyCycle) {
+  if (m_pwmGenerator != HAL_kInvalidHandle) {
+    return;
+  }
+
+  int32_t status = 0;
+
+  m_pwmGenerator = HAL_AllocateDigitalPWM(&status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+
+  HAL_SetDigitalPWMDutyCycle(m_pwmGenerator, initialDutyCycle, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+
+  HAL_SetDigitalPWMOutputChannel(m_pwmGenerator, m_channel, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+void DigitalOutput::DisablePWM() {
+  if (m_pwmGenerator == HAL_kInvalidHandle) {
+    return;
+  }
+
+  int32_t status = 0;
+
+  // Disable the output by routing to a dead bit.
+  HAL_SetDigitalPWMOutputChannel(m_pwmGenerator,
+                                 SensorUtil::GetNumDigitalChannels(), &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+
+  HAL_FreeDigitalPWM(m_pwmGenerator);
+
+  m_pwmGenerator = HAL_kInvalidHandle;
+}
+
+void DigitalOutput::UpdateDutyCycle(double dutyCycle) {
+  int32_t status = 0;
+  HAL_SetDigitalPWMDutyCycle(m_pwmGenerator, dutyCycle, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+void DigitalOutput::SetSimDevice(HAL_SimDeviceHandle device) {
+  HAL_SetDIOSimDevice(m_handle, device);
+}
+
+void DigitalOutput::InitSendable(wpi::SendableBuilder& builder) {
+  builder.SetSmartDashboardType("Digital Output");
+  builder.AddBooleanProperty(
+      "Value", [=, this] { return Get(); },
+      [=, this](bool value) { Set(value); });
+}

wpilibc/src/main/native/cpp/hardware/discrete/PWM.cpp

@@ -0,0 +1,106 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "frc/PWM.h"
+
+#include <utility>
+
+#include <hal/HALBase.h>
+#include <hal/PWM.h>
+#include <hal/Ports.h>
+#include <hal/UsageReporting.h>
+#include <wpi/StackTrace.h>
+#include <wpi/sendable/SendableBuilder.h>
+#include <wpi/sendable/SendableRegistry.h>
+
+#include "frc/Errors.h"
+#include "frc/SensorUtil.h"
+
+using namespace frc;
+
+PWM::PWM(int channel, bool registerSendable) {
+  if (!SensorUtil::CheckPWMChannel(channel)) {
+    throw FRC_MakeError(err::ChannelIndexOutOfRange, "Channel {}", channel);
+  }
+
+  auto stack = wpi::GetStackTrace(1);
+  int32_t status = 0;
+  m_handle = HAL_InitializePWMPort(channel, stack.c_str(), &status);
+  FRC_CheckErrorStatus(status, "Channel {}", channel);
+
+  m_channel = channel;
+
+  SetDisabled();
+
+  HAL_ReportUsage("IO", channel, "PWM");
+  if (registerSendable) {
+    wpi::SendableRegistry::Add(this, "PWM", channel);
+  }
+}
+
+PWM::~PWM() {
+  if (m_handle != HAL_kInvalidHandle) {
+    SetDisabled();
+  }
+}
+
+void PWM::SetPulseTime(units::microsecond_t time) {
+  int32_t status = 0;
+  HAL_SetPWMPulseTimeMicroseconds(m_handle, time.value(), &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+units::microsecond_t PWM::GetPulseTime() const {
+  int32_t status = 0;
+  double value = HAL_GetPWMPulseTimeMicroseconds(m_handle, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+
+  return units::microsecond_t{value};
+}
+
+void PWM::SetDisabled() {
+  int32_t status = 0;
+  HAL_SetPWMPulseTimeMicroseconds(m_handle, 0, &status);
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+void PWM::SetOutputPeriod(OutputPeriod mult) {
+  int32_t status = 0;
+
+  switch (mult) {
+    case kOutputPeriod_20Ms:
+      HAL_SetPWMOutputPeriod(m_handle, 3,
+                             &status);  // Squelch 3 out of 4 outputs
+      break;
+    case kOutputPeriod_10Ms:
+      HAL_SetPWMOutputPeriod(m_handle, 1,
+                             &status);  // Squelch 1 out of 2 outputs
+      break;
+    case kOutputPeriod_5Ms:
+      HAL_SetPWMOutputPeriod(m_handle, 0,
+                             &status);  // Don't squelch any outputs
+      break;
+    default:
+      throw FRC_MakeError(err::InvalidParameter, "OutputPeriod value {}",
+                          static_cast<int>(mult));
+  }
+
+  FRC_CheckErrorStatus(status, "Channel {}", m_channel);
+}
+
+int PWM::GetChannel() const {
+  return m_channel;
+}
+
+void PWM::SetSimDevice(HAL_SimDeviceHandle device) {
+  HAL_SetPWMSimDevice(m_handle, device);
+}
+
+void PWM::InitSendable(wpi::SendableBuilder& builder) {
+  builder.SetSmartDashboardType("PWM");
+  builder.SetActuator(true);
+  builder.AddDoubleProperty(
+      "Value", [=, this] { return GetPulseTime().value(); },
+      [=, this](double value) { SetPulseTime(units::millisecond_t{value}); });
+}