PneumaticsControlModule.hpp

Go to the documentation of this file.

// 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.
 
#pragma once
 
#include <memory>
 
#include "PneumaticsBase.hpp"
#include "wpi/hal/Types.h"
#include "wpi/util/DenseMap.hpp"
#include "wpi/util/mutex.hpp"
 
namespace wpi {
/** Module class for controlling a Cross The Road Electronics Pneumatics Control
 * Module. */
class PneumaticsControlModule : public PneumaticsBase {
 public:
  /**
   * Constructs a PneumaticsControlModule with the default ID (0).
   *
   * @param busId The bus ID.
   */
  explicit PneumaticsControlModule(int busId);
 
  /**
   * Constructs a PneumaticsControlModule.
   *
   * @param busId The bus ID.
   * @param module module number to construct
   */
  PneumaticsControlModule(int busId, int module);
 
  ~PneumaticsControlModule() override = default;
 
  bool GetCompressor() const override;
 
  /**
   * Disables the compressor. The compressor will not turn on until
   * EnableCompressorDigital() is called.
   */
  void DisableCompressor() override;
 
  void EnableCompressorDigital() override;
 
  /**
   * Enables the compressor in digital mode. Analog mode is unsupported by the
   * CTRE PCM.
   *
   * @param minPressure Unsupported.
   * @param maxPressure Unsupported.
   * @see EnableCompressorDigital()
   */
  void EnableCompressorAnalog(
      wpi::units::pounds_per_square_inch_t minPressure,
      wpi::units::pounds_per_square_inch_t maxPressure) override;
 
  /**
   * Enables the compressor in digital mode. Hybrid mode is unsupported by the
   * CTRE PCM.
   *
   * @param minPressure Unsupported.
   * @param maxPressure Unsupported.
   * @see EnableCompressorDigital()
   */
  void EnableCompressorHybrid(
      wpi::units::pounds_per_square_inch_t minPressure,
      wpi::units::pounds_per_square_inch_t maxPressure) override;
 
  CompressorConfigType GetCompressorConfigType() const override;
 
  bool GetPressureSwitch() const override;
 
  wpi::units::ampere_t GetCompressorCurrent() const override;
 
  /**
   * Return whether the compressor current is currently too high.
   *
   * @return True if the compressor current is too high, otherwise false.
   * @see GetCompressorCurrentTooHighStickyFault()
   */
  bool GetCompressorCurrentTooHighFault() const;
 
  /**
   * Returns whether the compressor current has been too high since sticky
   * faults were last cleared. This fault is persistent and can be cleared by
   * ClearAllStickyFaults()
   *
   * @return True if the compressor current has been too high since sticky
   * faults were last cleared.
   * @see GetCompressorCurrentTooHighFault()
   */
  bool GetCompressorCurrentTooHighStickyFault() const;
 
  /**
   * Returns whether the compressor is currently shorted.
   *
   * @return True if the compressor is currently shorted, otherwise false.
   * @see GetCompressorShortedStickyFault()
   */
  bool GetCompressorShortedFault() const;
 
  /**
   * Returns whether the compressor has been shorted since sticky faults were
   * last cleared. This fault is persistent and can be cleared by
   * ClearAllStickyFaults()
   *
   * @return True if the compressor has been shorted since sticky faults were
   * last cleared, otherwise false.
   * @see GetCompressorShortedFault()
   */
  bool GetCompressorShortedStickyFault() const;
 
  /**
   * Returns whether the compressor is currently disconnected.
   *
   * @return True if compressor is currently disconnected, otherwise false.
   * @see GetCompressorNotConnectedStickyFault()
   */
  bool GetCompressorNotConnectedFault() const;
 
  /**
   * Returns whether the compressor has been disconnected since sticky faults
   * were last cleared. This fault is persistent and can be cleared by
   * ClearAllStickyFaults()
   *
   * @return True if the compressor has been disconnected since sticky faults
   * were last cleared, otherwise false.
   * @see GetCompressorNotConnectedFault()
   */
  bool GetCompressorNotConnectedStickyFault() const;
 
  /**
   * Returns whether the solenoid is currently reporting a voltage fault.
   *
   * @return True if solenoid is reporting a fault, otherwise false.
   * @see GetSolenoidVoltageStickyFault()
   */
  bool GetSolenoidVoltageFault() const;
 
  /**
   * Returns whether the solenoid has reported a voltage fault since sticky
   * faults were last cleared. This fault is persistent and can be cleared by
   * ClearAllStickyFaults()
   *
   * @return True if solenoid is reporting a fault, otherwise false.
   * @see GetSolenoidVoltageFault()
   */
  bool GetSolenoidVoltageStickyFault() const;
 
  /** Clears all sticky faults on this device. */
  void ClearAllStickyFaults();
 
  void SetSolenoids(int mask, int values) override;
 
  int GetSolenoids() const override;
 
  int GetModuleNumber() const override;
 
  int GetSolenoidDisabledList() const override;
 
  void FireOneShot(int index) override;
 
  void SetOneShotDuration(int index, wpi::units::second_t duration) override;
 
  bool CheckSolenoidChannel(int channel) const override;
 
  int CheckAndReserveSolenoids(int mask) override;
 
  void UnreserveSolenoids(int mask) override;
 
  bool ReserveCompressor() override;
 
  void UnreserveCompressor() override;
 
  /**
   * Unsupported by the CTRE PCM.
   *
   * @param channel Unsupported.
   * @return 0
   */
  wpi::units::volt_t GetAnalogVoltage(int channel) const override;
 
  /**
   * Unsupported by the CTRE PCM.
   *
   * @param channel Unsupported.
   * @return 0
   */
  wpi::units::pounds_per_square_inch_t GetPressure(int channel) const override;
 
  Solenoid MakeSolenoid(int channel) override;
  DoubleSolenoid MakeDoubleSolenoid(int forwardChannel,
                                    int reverseChannel) override;
  Compressor MakeCompressor() override;
 
  void ReportUsage(std::string_view device, std::string_view data) override;
 
 private:
  class DataStore;
  friend class DataStore;
  friend class PneumaticsBase;
  PneumaticsControlModule(int busId, HAL_CTREPCMHandle handle, int module);
 
  static std::shared_ptr<PneumaticsBase> GetForModule(int busId, int module);
 
  std::shared_ptr<DataStore> m_dataStore;
  HAL_CTREPCMHandle m_handle;
  int m_module;
 
  static wpi::util::mutex m_handleLock;
  static std::unique_ptr<wpi::util::DenseMap<int, std::weak_ptr<DataStore>>[]>
      m_handleMaps;
  static std::weak_ptr<DataStore>& GetDataStore(int busId, int module);
};
}  // namespace wpi