WPILibC++  2020.3.2
DMASample.h
1 /*----------------------------------------------------------------------------*/
2 /* Copyright (c) 2019 FIRST. All Rights Reserved. */
3 /* Open Source Software - may be modified and shared by FRC teams. The code */
4 /* must be accompanied by the FIRST BSD license file in the root directory of */
5 /* the project. */
6 /*----------------------------------------------------------------------------*/
7 
8 #pragma once
9 
10 #include <type_traits>
11 
12 #include <hal/AnalogInput.h>
13 #include <hal/DMA.h>
14 #include <units/units.h>
15 
16 #include "frc/AnalogInput.h"
17 #include "frc/Counter.h"
18 #include "frc/DMA.h"
19 #include "frc/DutyCycle.h"
20 #include "frc/Encoder.h"
21 
22 namespace frc {
23 class DMASample : public HAL_DMASample {
24  public:
25  HAL_DMAReadStatus Update(const DMA* dma, units::second_t timeout,
26  int32_t* remaining, int32_t* status) {
27  units::millisecond_t ms = timeout;
28  auto timeoutMs = ms.to<int32_t>();
29  return HAL_ReadDMA(dma->dmaHandle, this, timeoutMs, remaining, status);
30  }
31 
32  uint64_t GetTime() const { return timeStamp; }
33 
34  units::second_t GetTimeStamp() const {
35  return units::second_t{static_cast<double>(GetTime()) * 1.0e-6};
36  }
37 
38  int32_t GetEncoderRaw(const Encoder* encoder, int32_t* status) const {
39  return HAL_GetDMASampleEncoderRaw(this, encoder->m_encoder, status);
40  }
41 
42  double GetEncoderDistance(const Encoder* encoder, int32_t* status) const {
43  double val = GetEncoderRaw(encoder, status);
44  val *= encoder->DecodingScaleFactor();
45  val *= encoder->GetDistancePerPulse();
46  return val;
47  }
48 
49  int32_t GetEncoderPeriodRaw(const Encoder* encoder, int32_t* status) const {
50  return HAL_GetDMASampleEncoderPeriodRaw(this, encoder->m_encoder, status);
51  }
52 
53  int32_t GetCounter(const Counter* counter, int32_t* status) const {
54  return HAL_GetDMASampleCounter(this, counter->m_counter, status);
55  }
56 
57  int32_t GetCounterPeriod(const Counter* counter, int32_t* status) const {
58  return HAL_GetDMASampleCounterPeriod(this, counter->m_counter, status);
59  }
60 
61  bool GetDigitalSource(const DigitalSource* digitalSource,
62  int32_t* status) const {
63  return HAL_GetDMASampleDigitalSource(
64  this, digitalSource->GetPortHandleForRouting(), status);
65  }
66 
67  int32_t GetAnalogInputRaw(const AnalogInput* analogInput,
68  int32_t* status) const {
69  return HAL_GetDMASampleAnalogInputRaw(this, analogInput->m_port, status);
70  }
71 
72  double GetAnalogInputVoltage(const AnalogInput* analogInput,
73  int32_t* status) {
75  analogInput->m_port, GetAnalogInputRaw(analogInput, status), status);
76  }
77 
78  int32_t GetAveragedAnalogInputRaw(const AnalogInput* analogInput,
79  int32_t* status) const {
80  return HAL_GetDMASampleAveragedAnalogInputRaw(this, analogInput->m_port,
81  status);
82  }
83 
84  double GetAveragedAnalogInputVoltage(const AnalogInput* analogInput,
85  int32_t* status) {
87  analogInput->m_port, GetAveragedAnalogInputRaw(analogInput, status),
88  status);
89  }
90 
91  void GetAnalogAccumulator(const AnalogInput* analogInput, int64_t* count,
92  int64_t* value, int32_t* status) const {
93  return HAL_GetDMASampleAnalogAccumulator(this, analogInput->m_port, count,
94  value, status);
95  }
96 
97  int32_t GetDutyCycleOutputRaw(const DutyCycle* dutyCycle,
98  int32_t* status) const {
99  return HAL_GetDMASampleDutyCycleOutputRaw(this, dutyCycle->m_handle,
100  status);
101  }
102 
103  double GetDutyCycleOutput(const DutyCycle* dutyCycle, int32_t* status) {
104  return GetDutyCycleOutputRaw(dutyCycle, status) /
105  static_cast<double>(dutyCycle->GetOutputScaleFactor());
106  }
107 };
108 
109 static_assert(std::is_standard_layout_v<frc::DMASample>,
110  "frc::DMASample must have standard layout");
111 } // namespace frc
frc::DMA
Definition: DMA.h:22
frc::DutyCycle::GetOutputScaleFactor
unsigned int GetOutputScaleFactor() const
Get the scale factor of the output.
frc::Encoder::GetDistancePerPulse
double GetDistancePerPulse() const
Get the distance per pulse for this encoder.
frc::DMASample
Definition: DMASample.h:23
HAL_DMASample
Definition: DMA.h:26
frc::DutyCycle
Class to read a duty cycle PWM input.
Definition: DutyCycle.h:35
frc::Encoder
Class to read quad encoders.
Definition: Encoder.h:44
frc::AnalogInput
Analog input class.
Definition: AnalogInput.h:37
frc
A class that enforces constraints on the differential drive kinematics.
Definition: SPIAccelerometerSim.h:16
frc::Counter
Class for counting the number of ticks on a digital input channel.
Definition: Counter.h:37
frc::DigitalSource
DigitalSource Interface.
Definition: DigitalSource.h:25
HAL_GetAnalogValueToVolts
double HAL_GetAnalogValueToVolts(HAL_AnalogInputHandle analogPortHandle, int32_t rawValue, int32_t *status)
Get the analog voltage from a raw value.