mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-27 02:01:42 +00:00
Prepends all HAL functions with HAL_ (#146)
This commit is contained in:
Thad House
committed by
Peter Johnson
Peter Johnson
parent
5ad28d58ec
commit
b637b9ee4c
@@ -7,16 +7,16 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
enum AccelerometerRange {
|
||||
kRange_2G = 0,
|
||||
kRange_4G = 1,
|
||||
kRange_8G = 2,
|
||||
enum HAL_AccelerometerRange {
|
||||
HAL_AccelerometerRange_k2G = 0,
|
||||
HAL_AccelerometerRange_k4G = 1,
|
||||
HAL_AccelerometerRange_k8G = 2,
|
||||
};
|
||||
|
||||
extern "C" {
|
||||
void setAccelerometerActive(bool);
|
||||
void setAccelerometerRange(AccelerometerRange);
|
||||
double getAccelerometerX();
|
||||
double getAccelerometerY();
|
||||
double getAccelerometerZ();
|
||||
void HAL_SetAccelerometerActive(bool);
|
||||
void HAL_SetAccelerometerRange(HAL_AccelerometerRange);
|
||||
double HAL_GetAccelerometerX();
|
||||
double HAL_GetAccelerometerY();
|
||||
double HAL_GetAccelerometerZ();
|
||||
}
|
||||
|
||||
@@ -12,18 +12,20 @@
|
||||
#include "Handles.h"
|
||||
|
||||
extern "C" {
|
||||
bool isAccumulatorChannel(HalAnalogInputHandle analog_port_handle,
|
||||
bool HAL_IsAccumulatorChannel(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
void HAL_InitAccumulator(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
void HAL_ResetAccumulator(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
void initAccumulator(HalAnalogInputHandle analog_port_handle, int32_t* status);
|
||||
void resetAccumulator(HalAnalogInputHandle analog_port_handle, int32_t* status);
|
||||
void setAccumulatorCenter(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t center, int32_t* status);
|
||||
void setAccumulatorDeadband(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t deadband, int32_t* status);
|
||||
int64_t getAccumulatorValue(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
uint32_t getAccumulatorCount(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
void getAccumulatorOutput(HalAnalogInputHandle analog_port_handle,
|
||||
int64_t* value, uint32_t* count, int32_t* status);
|
||||
void HAL_SetAccumulatorCenter(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t center, int32_t* status);
|
||||
void HAL_SetAccumulatorDeadband(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t deadband, int32_t* status);
|
||||
int64_t HAL_GetAccumulatorValue(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
uint32_t HAL_GetAccumulatorCount(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
void HAL_GetAccumulatorOutput(HAL_AnalogInputHandle analog_port_handle,
|
||||
int64_t* value, uint32_t* count, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,21 +12,22 @@
|
||||
#include "HAL/Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalGyroHandle initializeAnalogGyro(HalAnalogInputHandle handle,
|
||||
int32_t* status);
|
||||
void setupAnalogGyro(HalGyroHandle handle, int32_t* status);
|
||||
void freeAnalogGyro(HalGyroHandle handle);
|
||||
void setAnalogGyroParameters(HalGyroHandle handle,
|
||||
float voltsPerDegreePerSecond, float offset,
|
||||
uint32_t center, int32_t* status);
|
||||
void setAnalogGyroVoltsPerDegreePerSecond(HalGyroHandle handle,
|
||||
float voltsPerDegreePerSecond,
|
||||
int32_t* status);
|
||||
void resetAnalogGyro(HalGyroHandle handle, int32_t* status);
|
||||
void calibrateAnalogGyro(HalGyroHandle handle, int32_t* status);
|
||||
void setAnalogGyroDeadband(HalGyroHandle handle, float volts, int32_t* status);
|
||||
float getAnalogGyroAngle(HalGyroHandle handle, int32_t* status);
|
||||
double getAnalogGyroRate(HalGyroHandle handle, int32_t* status);
|
||||
float getAnalogGyroOffset(HalGyroHandle handle, int32_t* status);
|
||||
uint32_t getAnalogGyroCenter(HalGyroHandle handle, int32_t* status);
|
||||
HAL_GyroHandle HAL_InitializeAnalogGyro(HAL_AnalogInputHandle handle,
|
||||
int32_t* status);
|
||||
void HAL_SetupAnalogGyro(HAL_GyroHandle handle, int32_t* status);
|
||||
void HAL_FreeAnalogGyro(HAL_GyroHandle handle);
|
||||
void HAL_SetAnalogGyroParameters(HAL_GyroHandle handle,
|
||||
float voltsPerDegreePerSecond, float offset,
|
||||
uint32_t center, int32_t* status);
|
||||
void HAL_SetAnalogGyroVoltsPerDegreePerSecond(HAL_GyroHandle handle,
|
||||
float voltsPerDegreePerSecond,
|
||||
int32_t* status);
|
||||
void HAL_ResetAnalogGyro(HAL_GyroHandle handle, int32_t* status);
|
||||
void HAL_CalibrateAnalogGyro(HAL_GyroHandle handle, int32_t* status);
|
||||
void HAL_SetAnalogGyroDeadband(HAL_GyroHandle handle, float volts,
|
||||
int32_t* status);
|
||||
float HAL_GetAnalogGyroAngle(HAL_GyroHandle handle, int32_t* status);
|
||||
double HAL_GetAnalogGyroRate(HAL_GyroHandle handle, int32_t* status);
|
||||
float HAL_GetAnalogGyroOffset(HAL_GyroHandle handle, int32_t* status);
|
||||
uint32_t HAL_GetAnalogGyroCenter(HAL_GyroHandle handle, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -13,34 +13,34 @@
|
||||
|
||||
extern "C" {
|
||||
// Analog input functions
|
||||
HalAnalogInputHandle initializeAnalogInputPort(HalPortHandle port_handle,
|
||||
int32_t* status);
|
||||
void freeAnalogInputPort(HalAnalogInputHandle analog_port_handle);
|
||||
bool checkAnalogModule(uint8_t module);
|
||||
bool checkAnalogInputChannel(uint32_t pin);
|
||||
HAL_AnalogInputHandle HAL_InitializeAnalogInputPort(HAL_PortHandle port_handle,
|
||||
int32_t* status);
|
||||
void HAL_FreeAnalogInputPort(HAL_AnalogInputHandle analog_port_handle);
|
||||
bool HAL_CheckAnalogModule(uint8_t module);
|
||||
bool HAL_CheckAnalogInputChannel(uint32_t pin);
|
||||
|
||||
void setAnalogSampleRate(double samplesPerSecond, int32_t* status);
|
||||
float getAnalogSampleRate(int32_t* status);
|
||||
void setAnalogAverageBits(HalAnalogInputHandle analog_port_handle,
|
||||
uint32_t bits, int32_t* status);
|
||||
uint32_t getAnalogAverageBits(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
void setAnalogOversampleBits(HalAnalogInputHandle analog_port_handle,
|
||||
uint32_t bits, int32_t* status);
|
||||
uint32_t getAnalogOversampleBits(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int16_t getAnalogValue(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int32_t getAnalogAverageValue(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int32_t getAnalogVoltsToValue(HalAnalogInputHandle analog_port_handle,
|
||||
double voltage, int32_t* status);
|
||||
float getAnalogVoltage(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
float getAnalogAverageVoltage(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
uint32_t getAnalogLSBWeight(HalAnalogInputHandle analog_port_handle,
|
||||
void HAL_SetAnalogSampleRate(double samplesPerSecond, int32_t* status);
|
||||
float HAL_GetAnalogSampleRate(int32_t* status);
|
||||
void HAL_SetAnalogAverageBits(HAL_AnalogInputHandle analog_port_handle,
|
||||
uint32_t bits, int32_t* status);
|
||||
uint32_t HAL_GetAnalogAverageBits(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetAnalogOversampleBits(HAL_AnalogInputHandle analog_port_handle,
|
||||
uint32_t bits, int32_t* status);
|
||||
uint32_t HAL_GetAnalogOversampleBits(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int16_t HAL_GetAnalogValue(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int32_t HAL_GetAnalogAverageValue(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int32_t HAL_GetAnalogVoltsToValue(HAL_AnalogInputHandle analog_port_handle,
|
||||
double voltage, int32_t* status);
|
||||
float HAL_GetAnalogVoltage(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
float HAL_GetAnalogAverageVoltage(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
uint32_t HAL_GetAnalogLSBWeight(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int32_t HAL_GetAnalogOffset(HAL_AnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
int32_t getAnalogOffset(HalAnalogInputHandle analog_port_handle,
|
||||
int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,12 +12,12 @@
|
||||
#include "Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalAnalogOutputHandle initializeAnalogOutputPort(HalPortHandle port_handle,
|
||||
int32_t* status);
|
||||
void freeAnalogOutputPort(HalAnalogOutputHandle analog_output_handle);
|
||||
void setAnalogOutput(HalAnalogOutputHandle analog_output_handle, double voltage,
|
||||
int32_t* status);
|
||||
double getAnalogOutput(HalAnalogOutputHandle analog_output_handle,
|
||||
int32_t* status);
|
||||
bool checkAnalogOutputChannel(uint32_t pin);
|
||||
HAL_AnalogOutputHandle HAL_InitializeAnalogOutputPort(
|
||||
HAL_PortHandle port_handle, int32_t* status);
|
||||
void HAL_FreeAnalogOutputPort(HAL_AnalogOutputHandle analog_output_handle);
|
||||
void HAL_SetAnalogOutput(HAL_AnalogOutputHandle analog_output_handle,
|
||||
double voltage, int32_t* status);
|
||||
double HAL_GetAnalogOutput(HAL_AnalogOutputHandle analog_output_handle,
|
||||
int32_t* status);
|
||||
bool HAL_CheckAnalogOutputChannel(uint32_t pin);
|
||||
}
|
||||
|
||||
@@ -11,31 +11,32 @@
|
||||
|
||||
#include "Handles.h"
|
||||
|
||||
enum AnalogTriggerType {
|
||||
kInWindow = 0,
|
||||
kState = 1,
|
||||
kRisingPulse = 2,
|
||||
kFallingPulse = 3
|
||||
enum HAL_AnalogTriggerType {
|
||||
HAL_Trigger_kInWindow = 0,
|
||||
HAL_Trigger_kState = 1,
|
||||
HAL_Trigger_kRisingPulse = 2,
|
||||
HAL_Trigger_kFallingPulse = 3
|
||||
};
|
||||
|
||||
extern "C" {
|
||||
HalAnalogTriggerHandle initializeAnalogTrigger(HalAnalogInputHandle port_handle,
|
||||
uint32_t* index,
|
||||
int32_t* status);
|
||||
void cleanAnalogTrigger(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
int32_t* status);
|
||||
void setAnalogTriggerLimitsRaw(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
int32_t lower, int32_t upper, int32_t* status);
|
||||
void setAnalogTriggerLimitsVoltage(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
double lower, double upper, int32_t* status);
|
||||
void setAnalogTriggerAveraged(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
bool useAveragedValue, int32_t* status);
|
||||
void setAnalogTriggerFiltered(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
bool useFilteredValue, int32_t* status);
|
||||
bool getAnalogTriggerInWindow(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
int32_t* status);
|
||||
bool getAnalogTriggerTriggerState(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
HAL_AnalogTriggerHandle HAL_InitializeAnalogTrigger(
|
||||
HAL_AnalogInputHandle port_handle, uint32_t* index, int32_t* status);
|
||||
void HAL_CleanAnalogTrigger(HAL_AnalogTriggerHandle analog_trigger_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetAnalogTriggerLimitsRaw(
|
||||
HAL_AnalogTriggerHandle analog_trigger_handle, int32_t lower, int32_t upper,
|
||||
int32_t* status);
|
||||
void HAL_SetAnalogTriggerLimitsVoltage(
|
||||
HAL_AnalogTriggerHandle analog_trigger_handle, double lower, double upper,
|
||||
int32_t* status);
|
||||
void HAL_SetAnalogTriggerAveraged(HAL_AnalogTriggerHandle analog_trigger_handle,
|
||||
bool useAveragedValue, int32_t* status);
|
||||
void HAL_SetAnalogTriggerFiltered(HAL_AnalogTriggerHandle analog_trigger_handle,
|
||||
bool useFilteredValue, int32_t* status);
|
||||
bool HAL_GetAnalogTriggerInWindow(HAL_AnalogTriggerHandle analog_trigger_handle,
|
||||
int32_t* status);
|
||||
bool getAnalogTriggerOutput(HalAnalogTriggerHandle analog_trigger_handle,
|
||||
AnalogTriggerType type, int32_t* status);
|
||||
bool HAL_GetAnalogTriggerTriggerState(
|
||||
HAL_AnalogTriggerHandle analog_trigger_handle, int32_t* status);
|
||||
bool HAL_GetAnalogTriggerOutput(HAL_AnalogTriggerHandle analog_trigger_handle,
|
||||
HAL_AnalogTriggerType type, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,32 +12,33 @@
|
||||
#include "HAL/Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalCompressorHandle initializeCompressor(uint8_t module, int32_t* status);
|
||||
bool checkCompressorModule(uint8_t module);
|
||||
HAL_CompressorHandle HAL_InitializeCompressor(uint8_t module, int32_t* status);
|
||||
bool HAL_CheckCompressorModule(uint8_t module);
|
||||
|
||||
bool getCompressor(HalCompressorHandle compressor_handle, int32_t* status);
|
||||
bool HAL_GetCompressor(HAL_CompressorHandle compressor_handle, int32_t* status);
|
||||
|
||||
void setClosedLoopControl(HalCompressorHandle compressor_handle, bool value,
|
||||
int32_t* status);
|
||||
bool getClosedLoopControl(HalCompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetClosedLoopControl(HAL_CompressorHandle compressor_handle,
|
||||
bool value, int32_t* status);
|
||||
bool HAL_GetClosedLoopControl(HAL_CompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
|
||||
bool getPressureSwitch(HalCompressorHandle compressor_handle, int32_t* status);
|
||||
float getCompressorCurrent(HalCompressorHandle compressor_handle,
|
||||
bool HAL_GetPressureSwitch(HAL_CompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
|
||||
bool getCompressorCurrentTooHighFault(HalCompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
bool getCompressorCurrentTooHighStickyFault(
|
||||
HalCompressorHandle compressor_handle, int32_t* status);
|
||||
bool getCompressorShortedStickyFault(HalCompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
bool getCompressorShortedFault(HalCompressorHandle compressor_handle,
|
||||
float HAL_GetCompressorCurrent(HAL_CompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
bool getCompressorNotConnectedStickyFault(HalCompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
bool getCompressorNotConnectedFault(HalCompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
void clearAllPCMStickyFaults(HalCompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
|
||||
bool HAL_GetCompressorCurrentTooHighFault(
|
||||
HAL_CompressorHandle compressor_handle, int32_t* status);
|
||||
bool HAL_GetCompressorCurrentTooHighStickyFault(
|
||||
HAL_CompressorHandle compressor_handle, int32_t* status);
|
||||
bool HAL_GetCompressorShortedStickyFault(HAL_CompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
bool HAL_GetCompressorShortedFault(HAL_CompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
bool HAL_GetCompressorNotConnectedStickyFault(
|
||||
HAL_CompressorHandle compressor_handle, int32_t* status);
|
||||
bool HAL_GetCompressorNotConnectedFault(HAL_CompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
void HAL_ClearAllPCMStickyFaults(HAL_CompressorHandle compressor_handle,
|
||||
int32_t* status);
|
||||
}
|
||||
|
||||
@@ -10,5 +10,5 @@
|
||||
#include <stdint.h>
|
||||
|
||||
extern "C" {
|
||||
int32_t HAL_getSystemClockTicksPerMicrosecond(void);
|
||||
int32_t HAL_GetSystemClockTicksPerMicrosecond(void);
|
||||
}
|
||||
|
||||
@@ -12,50 +12,58 @@
|
||||
#include "HAL/AnalogTrigger.h"
|
||||
#include "HAL/Handles.h"
|
||||
|
||||
enum Mode {
|
||||
kTwoPulse = 0,
|
||||
kSemiperiod = 1,
|
||||
kPulseLength = 2,
|
||||
kExternalDirection = 3
|
||||
enum HAL_Counter_Mode {
|
||||
HAL_Counter_kTwoPulse = 0,
|
||||
HAL_Counter_kSemiperiod = 1,
|
||||
HAL_Counter_kPulseLength = 2,
|
||||
HAL_Counter_kExternalDirection = 3
|
||||
};
|
||||
|
||||
extern "C" {
|
||||
HalCounterHandle initializeCounter(Mode mode, int32_t* index, int32_t* status);
|
||||
void freeCounter(HalCounterHandle counter_handle, int32_t* status);
|
||||
void setCounterAverageSize(HalCounterHandle counter_handle, int32_t size,
|
||||
int32_t* status);
|
||||
void setCounterUpSource(HalCounterHandle counter_handle,
|
||||
HalHandle digitalSourceHandle,
|
||||
AnalogTriggerType analogTriggerType, int32_t* status);
|
||||
void setCounterUpSourceEdge(HalCounterHandle counter_handle, bool risingEdge,
|
||||
bool fallingEdge, int32_t* status);
|
||||
void clearCounterUpSource(HalCounterHandle counter_handle, int32_t* status);
|
||||
void setCounterDownSource(HalCounterHandle counter_handle,
|
||||
HalHandle digitalSourceHandle,
|
||||
AnalogTriggerType analogTriggerType, int32_t* status);
|
||||
void setCounterDownSourceEdge(HalCounterHandle counter_handle, bool risingEdge,
|
||||
bool fallingEdge, int32_t* status);
|
||||
void clearCounterDownSource(HalCounterHandle counter_handle, int32_t* status);
|
||||
void setCounterUpDownMode(HalCounterHandle counter_handle, int32_t* status);
|
||||
void setCounterExternalDirectionMode(HalCounterHandle counter_handle,
|
||||
int32_t* status);
|
||||
void setCounterSemiPeriodMode(HalCounterHandle counter_handle,
|
||||
bool highSemiPeriod, int32_t* status);
|
||||
void setCounterPulseLengthMode(HalCounterHandle counter_handle,
|
||||
double threshold, int32_t* status);
|
||||
int32_t getCounterSamplesToAverage(HalCounterHandle counter_handle,
|
||||
int32_t* status);
|
||||
void setCounterSamplesToAverage(HalCounterHandle counter_handle,
|
||||
int samplesToAverage, int32_t* status);
|
||||
void resetCounter(HalCounterHandle counter_handle, int32_t* status);
|
||||
int32_t getCounter(HalCounterHandle counter_handle, int32_t* status);
|
||||
double getCounterPeriod(HalCounterHandle counter_handle, int32_t* status);
|
||||
void setCounterMaxPeriod(HalCounterHandle counter_handle, double maxPeriod,
|
||||
int32_t* status);
|
||||
void setCounterUpdateWhenEmpty(HalCounterHandle counter_handle, bool enabled,
|
||||
HAL_CounterHandle HAL_InitializeCounter(HAL_Counter_Mode mode, int32_t* index,
|
||||
int32_t* status);
|
||||
void HAL_FreeCounter(HAL_CounterHandle counter_handle, int32_t* status);
|
||||
void HAL_SetCounterAverageSize(HAL_CounterHandle counter_handle, int32_t size,
|
||||
int32_t* status);
|
||||
bool getCounterStopped(HalCounterHandle counter_handle, int32_t* status);
|
||||
bool getCounterDirection(HalCounterHandle counter_handle, int32_t* status);
|
||||
void setCounterReverseDirection(HalCounterHandle counter_handle,
|
||||
bool reverseDirection, int32_t* status);
|
||||
void HAL_SetCounterUpSource(HAL_CounterHandle counter_handle,
|
||||
HAL_Handle digitalSourceHandle,
|
||||
HAL_AnalogTriggerType analogTriggerType,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterUpSourceEdge(HAL_CounterHandle counter_handle,
|
||||
bool risingEdge, bool fallingEdge,
|
||||
int32_t* status);
|
||||
void HAL_ClearCounterUpSource(HAL_CounterHandle counter_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterDownSource(HAL_CounterHandle counter_handle,
|
||||
HAL_Handle digitalSourceHandle,
|
||||
HAL_AnalogTriggerType analogTriggerType,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterDownSourceEdge(HAL_CounterHandle counter_handle,
|
||||
bool risingEdge, bool fallingEdge,
|
||||
int32_t* status);
|
||||
void HAL_ClearCounterDownSource(HAL_CounterHandle counter_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterUpDownMode(HAL_CounterHandle counter_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterExternalDirectionMode(HAL_CounterHandle counter_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterSemiPeriodMode(HAL_CounterHandle counter_handle,
|
||||
bool highSemiPeriod, int32_t* status);
|
||||
void HAL_SetCounterPulseLengthMode(HAL_CounterHandle counter_handle,
|
||||
double threshold, int32_t* status);
|
||||
int32_t HAL_GetCounterSamplesToAverage(HAL_CounterHandle counter_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterSamplesToAverage(HAL_CounterHandle counter_handle,
|
||||
int samplesToAverage, int32_t* status);
|
||||
void HAL_ResetCounter(HAL_CounterHandle counter_handle, int32_t* status);
|
||||
int32_t HAL_GetCounter(HAL_CounterHandle counter_handle, int32_t* status);
|
||||
double HAL_GetCounterPeriod(HAL_CounterHandle counter_handle, int32_t* status);
|
||||
void HAL_SetCounterMaxPeriod(HAL_CounterHandle counter_handle, double maxPeriod,
|
||||
int32_t* status);
|
||||
void HAL_SetCounterUpdateWhenEmpty(HAL_CounterHandle counter_handle,
|
||||
bool enabled, int32_t* status);
|
||||
bool HAL_GetCounterStopped(HAL_CounterHandle counter_handle, int32_t* status);
|
||||
bool HAL_GetCounterDirection(HAL_CounterHandle counter_handle, int32_t* status);
|
||||
void HAL_SetCounterReverseDirection(HAL_CounterHandle counter_handle,
|
||||
bool reverseDirection, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,30 +12,31 @@
|
||||
#include "Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalDigitalHandle initializeDIOPort(HalPortHandle port_handle, uint8_t input,
|
||||
int32_t* status);
|
||||
void freeDIOPort(HalDigitalHandle dio_port_handle);
|
||||
HAL_DigitalHandle HAL_InitializeDIOPort(HAL_PortHandle port_handle,
|
||||
uint8_t input, int32_t* status);
|
||||
void HAL_FreeDIOPort(HAL_DigitalHandle dio_port_handle);
|
||||
|
||||
HalDigitalPWMHandle allocateDigitalPWM(int32_t* status);
|
||||
void freeDigitalPWM(HalDigitalPWMHandle pwmGenerator, int32_t* status);
|
||||
void setDigitalPWMRate(double rate, int32_t* status);
|
||||
void setDigitalPWMDutyCycle(HalDigitalPWMHandle pwmGenerator, double dutyCycle,
|
||||
int32_t* status);
|
||||
void setDigitalPWMOutputChannel(HalDigitalPWMHandle pwmGenerator, uint32_t pin,
|
||||
int32_t* status);
|
||||
HAL_DigitalPWMHandle HAL_AllocateDigitalPWM(int32_t* status);
|
||||
void HAL_FreeDigitalPWM(HAL_DigitalPWMHandle pwmGenerator, int32_t* status);
|
||||
void HAL_SetDigitalPWMRate(double rate, int32_t* status);
|
||||
void HAL_SetDigitalPWMDutyCycle(HAL_DigitalPWMHandle pwmGenerator,
|
||||
double dutyCycle, int32_t* status);
|
||||
void HAL_SetDigitalPWMOutputChannel(HAL_DigitalPWMHandle pwmGenerator,
|
||||
uint32_t pin, int32_t* status);
|
||||
|
||||
void setDIO(HalDigitalHandle dio_port_handle, short value, int32_t* status);
|
||||
bool getDIO(HalDigitalHandle dio_port_handle, int32_t* status);
|
||||
bool getDIODirection(HalDigitalHandle dio_port_handle, int32_t* status);
|
||||
void pulse(HalDigitalHandle dio_port_handle, double pulseLength,
|
||||
int32_t* status);
|
||||
bool isPulsing(HalDigitalHandle dio_port_handle, int32_t* status);
|
||||
bool isAnyPulsing(int32_t* status);
|
||||
void HAL_SetDIO(HAL_DigitalHandle dio_port_handle, short value,
|
||||
int32_t* status);
|
||||
bool HAL_GetDIO(HAL_DigitalHandle dio_port_handle, int32_t* status);
|
||||
bool HAL_GetDIODirection(HAL_DigitalHandle dio_port_handle, int32_t* status);
|
||||
void HAL_Pulse(HAL_DigitalHandle dio_port_handle, double pulseLength,
|
||||
int32_t* status);
|
||||
bool HAL_IsPulsing(HAL_DigitalHandle dio_port_handle, int32_t* status);
|
||||
bool HAL_IsAnyPulsing(int32_t* status);
|
||||
|
||||
void setFilterSelect(HalDigitalHandle dio_port_handle, int filter_index,
|
||||
int32_t* status);
|
||||
int getFilterSelect(HalDigitalHandle dio_port_handle, int32_t* status);
|
||||
void HAL_SetFilterSelect(HAL_DigitalHandle dio_port_handle, int filter_index,
|
||||
int32_t* status);
|
||||
int HAL_GetFilterSelect(HAL_DigitalHandle dio_port_handle, int32_t* status);
|
||||
|
||||
void setFilterPeriod(int filter_index, uint32_t value, int32_t* status);
|
||||
uint32_t getFilterPeriod(int filter_index, int32_t* status);
|
||||
void HAL_SetFilterPeriod(int filter_index, uint32_t value, int32_t* status);
|
||||
uint32_t HAL_GetFilterPeriod(int filter_index, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -13,55 +13,64 @@
|
||||
#include "HAL/Handles.h"
|
||||
|
||||
extern "C" {
|
||||
enum EncoderIndexingType {
|
||||
enum HAL_EncoderIndexingType {
|
||||
HAL_kResetWhileHigh,
|
||||
HAL_kResetWhileLow,
|
||||
HAL_kResetOnFallingEdge,
|
||||
HAL_kResetOnRisingEdge
|
||||
};
|
||||
enum EncoderEncodingType { HAL_Encoder_k1X, HAL_Encoder_k2X, HAL_Encoder_k4X };
|
||||
enum HAL_EncoderEncodingType {
|
||||
HAL_Encoder_k1X,
|
||||
HAL_Encoder_k2X,
|
||||
HAL_Encoder_k4X
|
||||
};
|
||||
|
||||
HalEncoderHandle initializeEncoder(
|
||||
HalHandle digitalSourceHandleA, AnalogTriggerType analogTriggerTypeA,
|
||||
HalHandle digitalSourceHandleB, AnalogTriggerType analogTriggerTypeB,
|
||||
bool reverseDirection, EncoderEncodingType encodingType, int32_t* status);
|
||||
void freeEncoder(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t getEncoder(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t getEncoderRaw(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t getEncoderEncodingScale(HalEncoderHandle encoder_handle,
|
||||
HAL_EncoderHandle HAL_InitializeEncoder(
|
||||
HAL_Handle digitalSourceHandleA, HAL_AnalogTriggerType analogTriggerTypeA,
|
||||
HAL_Handle digitalSourceHandleB, HAL_AnalogTriggerType analogTriggerTypeB,
|
||||
bool reverseDirection, HAL_EncoderEncodingType encodingType,
|
||||
int32_t* status);
|
||||
void HAL_FreeEncoder(HAL_EncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t HAL_GetEncoder(HAL_EncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t HAL_GetEncoderRaw(HAL_EncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t HAL_GetEncoderEncodingScale(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
void HAL_ResetEncoder(HAL_EncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t HAL_GetEncoderPeriod(HAL_EncoderHandle encoder_handle, int32_t* status);
|
||||
void HAL_SetEncoderMaxPeriod(HAL_EncoderHandle encoder_handle, double maxPeriod,
|
||||
int32_t* status);
|
||||
uint8_t HAL_GetEncoderStopped(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
uint8_t HAL_GetEncoderDirection(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
void resetEncoder(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t getEncoderPeriod(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
void setEncoderMaxPeriod(HalEncoderHandle encoder_handle, double maxPeriod,
|
||||
int32_t* status);
|
||||
uint8_t getEncoderStopped(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
uint8_t getEncoderDirection(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
double getEncoderDistance(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
double getEncoderRate(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
void setEncoderMinRate(HalEncoderHandle encoder_handle, double minRate,
|
||||
int32_t* status);
|
||||
void setEncoderDistancePerPulse(HalEncoderHandle encoder_handle,
|
||||
double distancePerPulse, int32_t* status);
|
||||
void setEncoderReverseDirection(HalEncoderHandle encoder_handle,
|
||||
uint8_t reverseDirection, int32_t* status);
|
||||
void setEncoderSamplesToAverage(HalEncoderHandle encoder_handle,
|
||||
int32_t samplesToAverage, int32_t* status);
|
||||
int32_t getEncoderSamplesToAverage(HalEncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
double HAL_GetEncoderDistance(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
double HAL_GetEncoderRate(HAL_EncoderHandle encoder_handle, int32_t* status);
|
||||
void HAL_SetEncoderMinRate(HAL_EncoderHandle encoder_handle, double minRate,
|
||||
int32_t* status);
|
||||
void HAL_SetEncoderDistancePerPulse(HAL_EncoderHandle encoder_handle,
|
||||
double distancePerPulse, int32_t* status);
|
||||
void HAL_SetEncoderReverseDirection(HAL_EncoderHandle encoder_handle,
|
||||
uint8_t reverseDirection, int32_t* status);
|
||||
void HAL_SetEncoderSamplesToAverage(HAL_EncoderHandle encoder_handle,
|
||||
int32_t samplesToAverage, int32_t* status);
|
||||
int32_t HAL_GetEncoderSamplesToAverage(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
|
||||
void setEncoderIndexSource(HalEncoderHandle encoder_handle,
|
||||
HalHandle digitalSourceHandle,
|
||||
AnalogTriggerType analogTriggerType,
|
||||
EncoderIndexingType type, int32_t* status);
|
||||
void HAL_SetEncoderIndexSource(HAL_EncoderHandle encoder_handle,
|
||||
HAL_Handle digitalSourceHandle,
|
||||
HAL_AnalogTriggerType analogTriggerType,
|
||||
HAL_EncoderIndexingType type, int32_t* status);
|
||||
|
||||
int32_t getEncoderFPGAIndex(HalEncoderHandle encoder_handle, int32_t* status);
|
||||
int32_t HAL_GetEncoderFPGAIndex(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
|
||||
double getEncoderDecodingScaleFactor(HalEncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
double HAL_GetEncoderDecodingScaleFactor(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
|
||||
double getEncoderDistancePerPulse(HalEncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
double HAL_GetEncoderDistancePerPulse(HAL_EncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
|
||||
EncoderEncodingType getEncoderEncodingType(HalEncoderHandle encoder_handle,
|
||||
int32_t* status);
|
||||
HAL_EncoderEncodingType HAL_GetEncoderEncodingType(
|
||||
HAL_EncoderHandle encoder_handle, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -53,7 +53,7 @@ namespace HALUsageReporting = nUsageReporting;
|
||||
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Joystick 24
|
||||
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Custom 25
|
||||
|
||||
struct HALControlWord {
|
||||
struct HAL_ControlWord {
|
||||
uint32_t enabled : 1;
|
||||
uint32_t autonomous : 1;
|
||||
uint32_t test : 1;
|
||||
@@ -63,91 +63,92 @@ struct HALControlWord {
|
||||
uint32_t control_reserved : 26;
|
||||
};
|
||||
|
||||
enum HALAllianceStationID {
|
||||
kHALAllianceStationID_red1,
|
||||
kHALAllianceStationID_red2,
|
||||
kHALAllianceStationID_red3,
|
||||
kHALAllianceStationID_blue1,
|
||||
kHALAllianceStationID_blue2,
|
||||
kHALAllianceStationID_blue3,
|
||||
enum HAL_AllianceStationID {
|
||||
HAL_AllianceStationID_kRed1,
|
||||
HAL_AllianceStationID_kRed2,
|
||||
HAL_AllianceStationID_kRed3,
|
||||
HAL_AllianceStationID_kBlue1,
|
||||
HAL_AllianceStationID_kBlue2,
|
||||
HAL_AllianceStationID_kBlue3,
|
||||
};
|
||||
|
||||
/* The maximum number of axes that will be stored in a single HALJoystickAxes
|
||||
* struct. This is used for allocating buffers, not bounds checking, since
|
||||
* there are usually less axes in practice.
|
||||
*/
|
||||
static const size_t kMaxJoystickAxes = 12;
|
||||
static const size_t kMaxJoystickPOVs = 12;
|
||||
static constexpr size_t HAL_kMaxJoystickAxes = 12;
|
||||
static constexpr size_t HAL_kMaxJoystickPOVs = 12;
|
||||
|
||||
struct HALJoystickAxes {
|
||||
struct HAL_JoystickAxes {
|
||||
uint16_t count;
|
||||
float axes[kMaxJoystickAxes];
|
||||
float axes[HAL_kMaxJoystickAxes];
|
||||
};
|
||||
|
||||
struct HALJoystickPOVs {
|
||||
struct HAL_JoystickPOVs {
|
||||
uint16_t count;
|
||||
int16_t povs[kMaxJoystickPOVs];
|
||||
int16_t povs[HAL_kMaxJoystickPOVs];
|
||||
};
|
||||
|
||||
struct HALJoystickButtons {
|
||||
struct HAL_JoystickButtons {
|
||||
uint32_t buttons;
|
||||
uint8_t count;
|
||||
};
|
||||
|
||||
struct HALJoystickDescriptor {
|
||||
struct HAL_JoystickDescriptor {
|
||||
uint8_t isXbox;
|
||||
uint8_t type;
|
||||
char name[256];
|
||||
uint8_t axisCount;
|
||||
uint8_t axisTypes[kMaxJoystickAxes];
|
||||
uint8_t axisTypes[HAL_kMaxJoystickAxes];
|
||||
uint8_t buttonCount;
|
||||
uint8_t povCount;
|
||||
};
|
||||
|
||||
extern "C" {
|
||||
HalPortHandle getPort(uint8_t pin);
|
||||
HalPortHandle getPortWithModule(uint8_t module, uint8_t pin);
|
||||
const char* getHALErrorMessage(int32_t code);
|
||||
HAL_PortHandle HAL_GetPort(uint8_t pin);
|
||||
HAL_PortHandle HAL_GetPortWithModule(uint8_t module, uint8_t pin);
|
||||
const char* HAL_GetErrorMessage(int32_t code);
|
||||
|
||||
uint16_t getFPGAVersion(int32_t* status);
|
||||
uint32_t getFPGARevision(int32_t* status);
|
||||
uint64_t getFPGATime(int32_t* status);
|
||||
uint16_t HAL_GetFPGAVersion(int32_t* status);
|
||||
uint32_t HAL_GetFPGARevision(int32_t* status);
|
||||
uint64_t HAL_GetFPGATime(int32_t* status);
|
||||
|
||||
bool getFPGAButton(int32_t* status);
|
||||
bool HAL_GetFPGAButton(int32_t* status);
|
||||
|
||||
int HALSetErrorData(const char* errors, int errorsLength, int wait_ms);
|
||||
int HALSendError(int isError, int32_t errorCode, int isLVCode,
|
||||
const char* details, const char* location,
|
||||
const char* callStack, int printMsg);
|
||||
int HAL_SetErrorData(const char* errors, int errorsLength, int wait_ms);
|
||||
int HAL_SendError(int isError, int32_t errorCode, int isLVCode,
|
||||
const char* details, const char* location,
|
||||
const char* callStack, int printMsg);
|
||||
|
||||
int HALGetControlWord(HALControlWord* data);
|
||||
int HALGetAllianceStation(enum HALAllianceStationID* allianceStation);
|
||||
int HALGetJoystickAxes(uint8_t joystickNum, HALJoystickAxes* axes);
|
||||
int HALGetJoystickPOVs(uint8_t joystickNum, HALJoystickPOVs* povs);
|
||||
int HALGetJoystickButtons(uint8_t joystickNum, HALJoystickButtons* buttons);
|
||||
int HALGetJoystickDescriptor(uint8_t joystickNum, HALJoystickDescriptor* desc);
|
||||
int HALGetJoystickIsXbox(uint8_t joystickNum);
|
||||
int HALGetJoystickType(uint8_t joystickNum);
|
||||
char* HALGetJoystickName(uint8_t joystickNum);
|
||||
int HALGetJoystickAxisType(uint8_t joystickNum, uint8_t axis);
|
||||
int HALSetJoystickOutputs(uint8_t joystickNum, uint32_t outputs,
|
||||
uint16_t leftRumble, uint16_t rightRumble);
|
||||
int HALGetMatchTime(float* matchTime);
|
||||
int HAL_GetControlWord(HAL_ControlWord* data);
|
||||
int HAL_GetAllianceStation(enum HAL_AllianceStationID* allianceStation);
|
||||
int HAL_GetJoystickAxes(uint8_t joystickNum, HAL_JoystickAxes* axes);
|
||||
int HAL_GetJoystickPOVs(uint8_t joystickNum, HAL_JoystickPOVs* povs);
|
||||
int HAL_GetJoystickButtons(uint8_t joystickNum, HAL_JoystickButtons* buttons);
|
||||
int HAL_GetJoystickDescriptor(uint8_t joystickNum,
|
||||
HAL_JoystickDescriptor* desc);
|
||||
int HAL_GetJoystickIsXbox(uint8_t joystickNum);
|
||||
int HAL_GetJoystickType(uint8_t joystickNum);
|
||||
char* HAL_GetJoystickName(uint8_t joystickNum);
|
||||
int HAL_GetJoystickAxisType(uint8_t joystickNum, uint8_t axis);
|
||||
int HAL_SetJoystickOutputs(uint8_t joystickNum, uint32_t outputs,
|
||||
uint16_t leftRumble, uint16_t rightRumble);
|
||||
int HAL_GetMatchTime(float* matchTime);
|
||||
|
||||
void HALSetNewDataSem(MULTIWAIT_ID sem);
|
||||
void HAL_SetNewDataSem(MULTIWAIT_ID sem);
|
||||
|
||||
bool HALGetSystemActive(int32_t* status);
|
||||
bool HALGetBrownedOut(int32_t* status);
|
||||
bool HAL_GetSystemActive(int32_t* status);
|
||||
bool HAL_GetBrownedOut(int32_t* status);
|
||||
|
||||
int HALInitialize(int mode = 0);
|
||||
void HALNetworkCommunicationObserveUserProgramStarting();
|
||||
void HALNetworkCommunicationObserveUserProgramDisabled();
|
||||
void HALNetworkCommunicationObserveUserProgramAutonomous();
|
||||
void HALNetworkCommunicationObserveUserProgramTeleop();
|
||||
void HALNetworkCommunicationObserveUserProgramTest();
|
||||
int HAL_Initialize(int mode = 0);
|
||||
void HAL_NetworkCommunicationObserveUserProgramStarting();
|
||||
void HAL_NetworkCommunicationObserveUserProgramDisabled();
|
||||
void HAL_NetworkCommunicationObserveUserProgramAutonomous();
|
||||
void HAL_NetworkCommunicationObserveUserProgramTeleop();
|
||||
void HAL_NetworkCommunicationObserveUserProgramTest();
|
||||
|
||||
uint32_t HALReport(uint8_t resource, uint8_t instanceNumber,
|
||||
uint8_t context = 0, const char* feature = nullptr);
|
||||
uint32_t HAL_Report(uint8_t resource, uint8_t instanceNumber,
|
||||
uint8_t context = 0, const char* feature = nullptr);
|
||||
}
|
||||
|
||||
// TODO: HACKS for now...
|
||||
|
||||
@@ -9,36 +9,36 @@
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#define HAL_INVALID_HANDLE 0
|
||||
#define HAL_kInvalidHandle 0
|
||||
|
||||
typedef int32_t HalHandle;
|
||||
typedef int32_t HAL_Handle;
|
||||
|
||||
typedef HalHandle HalPortHandle;
|
||||
typedef HAL_Handle HAL_PortHandle;
|
||||
|
||||
typedef HalHandle HalInterruptHandle;
|
||||
typedef HAL_Handle HAL_InterruptHandle;
|
||||
|
||||
typedef HalHandle HalNotifierHandle;
|
||||
typedef HAL_Handle HAL_NotifierHandle;
|
||||
|
||||
typedef HalHandle HalAnalogOutputHandle;
|
||||
typedef HAL_Handle HAL_AnalogOutputHandle;
|
||||
|
||||
typedef HalHandle HalAnalogInputHandle;
|
||||
typedef HAL_Handle HAL_AnalogInputHandle;
|
||||
|
||||
typedef HalHandle HalAnalogTriggerHandle;
|
||||
typedef HAL_Handle HAL_AnalogTriggerHandle;
|
||||
|
||||
typedef HalHandle HalRelayHandle;
|
||||
typedef HAL_Handle HAL_RelayHandle;
|
||||
|
||||
typedef HalHandle HalDigitalHandle;
|
||||
typedef HAL_Handle HAL_DigitalHandle;
|
||||
|
||||
typedef HalHandle HalDigitalPWMHandle;
|
||||
typedef HAL_Handle HAL_DigitalPWMHandle;
|
||||
|
||||
typedef HalHandle HalCounterHandle;
|
||||
typedef HAL_Handle HAL_CounterHandle;
|
||||
|
||||
typedef HalHandle HalCompressorHandle;
|
||||
typedef HAL_Handle HAL_CompressorHandle;
|
||||
|
||||
typedef HalHandle HalSolenoidHandle;
|
||||
typedef HAL_Handle HAL_SolenoidHandle;
|
||||
|
||||
typedef HalHandle HalFPGAEncoderHandle;
|
||||
typedef HAL_Handle HAL_FPGAEncoderHandle;
|
||||
|
||||
typedef HalHandle HalEncoderHandle;
|
||||
typedef HAL_Handle HAL_EncoderHandle;
|
||||
|
||||
typedef HalHandle HalGyroHandle;
|
||||
typedef HAL_Handle HAL_GyroHandle;
|
||||
|
||||
@@ -10,13 +10,13 @@
|
||||
#include <stdint.h>
|
||||
|
||||
extern "C" {
|
||||
void i2CInitialize(uint8_t port, int32_t* status);
|
||||
int32_t i2CTransaction(uint8_t port, uint8_t deviceAddress, uint8_t* dataToSend,
|
||||
uint8_t sendSize, uint8_t* dataReceived,
|
||||
uint8_t receiveSize);
|
||||
int32_t i2CWrite(uint8_t port, uint8_t deviceAddress, uint8_t* dataToSend,
|
||||
uint8_t sendSize);
|
||||
int32_t i2CRead(uint8_t port, uint8_t deviceAddress, uint8_t* buffer,
|
||||
uint8_t count);
|
||||
void i2CClose(uint8_t port);
|
||||
void HAL_I2CInitialize(uint8_t port, int32_t* status);
|
||||
int32_t HAL_I2CTransaction(uint8_t port, uint8_t deviceAddress,
|
||||
uint8_t* dataToSend, uint8_t sendSize,
|
||||
uint8_t* dataReceived, uint8_t receiveSize);
|
||||
int32_t HAL_I2CWrite(uint8_t port, uint8_t deviceAddress, uint8_t* dataToSend,
|
||||
uint8_t sendSize);
|
||||
int32_t HAL_I2CRead(uint8_t port, uint8_t deviceAddress, uint8_t* buffer,
|
||||
uint8_t count);
|
||||
void HAL_I2CClose(uint8_t port);
|
||||
}
|
||||
|
||||
@@ -16,24 +16,28 @@ extern "C" {
|
||||
typedef void (*InterruptHandlerFunction)(uint32_t interruptAssertedMask,
|
||||
void* param);
|
||||
|
||||
HalInterruptHandle initializeInterrupts(bool watcher, int32_t* status);
|
||||
void cleanInterrupts(HalInterruptHandle interrupt_handle, int32_t* status);
|
||||
HAL_InterruptHandle HAL_InitializeInterrupts(bool watcher, int32_t* status);
|
||||
void HAL_CleanInterrupts(HAL_InterruptHandle interrupt_handle, int32_t* status);
|
||||
|
||||
uint32_t waitForInterrupt(HalInterruptHandle interrupt_handle, double timeout,
|
||||
bool ignorePrevious, int32_t* status);
|
||||
void enableInterrupts(HalInterruptHandle interrupt_handle, int32_t* status);
|
||||
void disableInterrupts(HalInterruptHandle interrupt_handle, int32_t* status);
|
||||
double readRisingTimestamp(HalInterruptHandle interrupt_handle,
|
||||
int32_t* status);
|
||||
double readFallingTimestamp(HalInterruptHandle interrupt_handle,
|
||||
int32_t* status);
|
||||
void requestInterrupts(HalInterruptHandle interrupt_handle,
|
||||
HalHandle digitalSourceHandle,
|
||||
AnalogTriggerType analogTriggerType, int32_t* status);
|
||||
void attachInterruptHandler(HalInterruptHandle interrupt_handle,
|
||||
InterruptHandlerFunction handler, void* param,
|
||||
int32_t* status);
|
||||
void setInterruptUpSourceEdge(HalInterruptHandle interrupt_handle,
|
||||
bool risingEdge, bool fallingEdge,
|
||||
uint32_t HAL_WaitForInterrupt(HAL_InterruptHandle interrupt_handle,
|
||||
double timeout, bool ignorePrevious,
|
||||
int32_t* status);
|
||||
void HAL_EnableInterrupts(HAL_InterruptHandle interrupt_handle,
|
||||
int32_t* status);
|
||||
void HAL_DisableInterrupts(HAL_InterruptHandle interrupt_handle,
|
||||
int32_t* status);
|
||||
double HAL_ReadRisingTimestamp(HAL_InterruptHandle interrupt_handle,
|
||||
int32_t* status);
|
||||
double HAL_ReadFallingTimestamp(HAL_InterruptHandle interrupt_handle,
|
||||
int32_t* status);
|
||||
void HAL_RequestInterrupts(HAL_InterruptHandle interrupt_handle,
|
||||
HAL_Handle digitalSourceHandle,
|
||||
HAL_AnalogTriggerType analogTriggerType,
|
||||
int32_t* status);
|
||||
void HAL_AttachInterruptHandler(HAL_InterruptHandle interrupt_handle,
|
||||
InterruptHandlerFunction handler, void* param,
|
||||
int32_t* status);
|
||||
void HAL_SetInterruptUpSourceEdge(HAL_InterruptHandle interrupt_handle,
|
||||
bool risingEdge, bool fallingEdge,
|
||||
int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,11 +12,11 @@
|
||||
#include "Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalNotifierHandle initializeNotifier(void (*process)(uint64_t, void*),
|
||||
void* param, int32_t* status);
|
||||
void cleanNotifier(HalNotifierHandle notifier_handle, int32_t* status);
|
||||
void* getNotifierParam(HalNotifierHandle notifier_handle, int32_t* status);
|
||||
void updateNotifierAlarm(HalNotifierHandle notifier_handle,
|
||||
uint64_t triggerTime, int32_t* status);
|
||||
void stopNotifierAlarm(HalNotifierHandle notifier_handle, int32_t* status);
|
||||
HAL_NotifierHandle HAL_InitializeNotifier(void (*process)(uint64_t, void*),
|
||||
void* param, int32_t* status);
|
||||
void HAL_CleanNotifier(HAL_NotifierHandle notifier_handle, int32_t* status);
|
||||
void* HAL_GetNotifierParam(HAL_NotifierHandle notifier_handle, int32_t* status);
|
||||
void HAL_UpdateNotifierAlarm(HAL_NotifierHandle notifier_handle,
|
||||
uint64_t triggerTime, int32_t* status);
|
||||
void HAL_StopNotifierAlarm(HAL_NotifierHandle notifier_handle, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -10,13 +10,14 @@
|
||||
#include <stdint.h>
|
||||
|
||||
extern "C" {
|
||||
void initializePDP(uint8_t module);
|
||||
double getPDPTemperature(uint8_t module, int32_t* status);
|
||||
double getPDPVoltage(uint8_t module, int32_t* status);
|
||||
double getPDPChannelCurrent(uint8_t module, uint8_t channel, int32_t* status);
|
||||
double getPDPTotalCurrent(uint8_t module, int32_t* status);
|
||||
double getPDPTotalPower(uint8_t module, int32_t* status);
|
||||
double getPDPTotalEnergy(uint8_t module, int32_t* status);
|
||||
void resetPDPTotalEnergy(uint8_t module, int32_t* status);
|
||||
void clearPDPStickyFaults(uint8_t module, int32_t* status);
|
||||
void HAL_InitializePDP(uint8_t module);
|
||||
double HAL_GetPDPTemperature(uint8_t module, int32_t* status);
|
||||
double HAL_GetPDPVoltage(uint8_t module, int32_t* status);
|
||||
double HAL_GetPDPChannelCurrent(uint8_t module, uint8_t channel,
|
||||
int32_t* status);
|
||||
double HAL_GetPDPTotalCurrent(uint8_t module, int32_t* status);
|
||||
double HAL_GetPDPTotalPower(uint8_t module, int32_t* status);
|
||||
double HAL_GetPDPTotalEnergy(uint8_t module, int32_t* status);
|
||||
void HAL_ResetPDPTotalEnergy(uint8_t module, int32_t* status);
|
||||
void HAL_ClearPDPStickyFaults(uint8_t module, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,36 +12,39 @@
|
||||
#include "HAL/Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalDigitalHandle initializePWMPort(HalPortHandle port_handle, int32_t* status);
|
||||
void freePWMPort(HalDigitalHandle pwm_port_handle, int32_t* status);
|
||||
HAL_DigitalHandle HAL_InitializePWMPort(HAL_PortHandle port_handle,
|
||||
int32_t* status);
|
||||
void HAL_FreePWMPort(HAL_DigitalHandle pwm_port_handle, int32_t* status);
|
||||
|
||||
bool checkPWMChannel(uint8_t pin);
|
||||
bool HAL_CheckPWMChannel(uint8_t pin);
|
||||
|
||||
void setPWMConfig(HalDigitalHandle pwm_port_handle, double maxPwm,
|
||||
double deadbandMaxPwm, double centerPwm,
|
||||
double deadbandMinPwm, double minPwm, int32_t* status);
|
||||
void setPWMConfigRaw(HalDigitalHandle pwm_port_handle, int32_t maxPwm,
|
||||
int32_t deadbandMaxPwm, int32_t centerPwm,
|
||||
int32_t deadbandMinPwm, int32_t minPwm, int32_t* status);
|
||||
void getPWMConfigRaw(HalDigitalHandle pwm_port_handle, int32_t* maxPwm,
|
||||
int32_t* deadbandMaxPwm, int32_t* centerPwm,
|
||||
int32_t* deadbandMinPwm, int32_t* minPwm, int32_t* status);
|
||||
void setPWMEliminateDeadband(HalDigitalHandle pwm_port_handle,
|
||||
uint8_t eliminateDeadband, int32_t* status);
|
||||
uint8_t getPWMEliminateDeadband(HalDigitalHandle pwm_port_handle,
|
||||
int32_t* status);
|
||||
void setPWMRaw(HalDigitalHandle pwm_port_handle, uint16_t value,
|
||||
int32_t* status);
|
||||
void setPWMSpeed(HalDigitalHandle pwm_port_handle, float speed,
|
||||
int32_t* status);
|
||||
void setPWMPosition(HalDigitalHandle pwm_port_handle, float position,
|
||||
int32_t* status);
|
||||
void setPWMDisabled(HalDigitalHandle pwm_port_handle, int32_t* status);
|
||||
uint16_t getPWMRaw(HalDigitalHandle pwm_port_handle, int32_t* status);
|
||||
float getPWMSpeed(HalDigitalHandle pwm_port_handle, int32_t* status);
|
||||
float getPWMPosition(HalDigitalHandle pwm_port_handle, int32_t* status);
|
||||
void latchPWMZero(HalDigitalHandle pwm_port_handle, int32_t* status);
|
||||
void setPWMPeriodScale(HalDigitalHandle pwm_port_handle, uint32_t squelchMask,
|
||||
int32_t* status);
|
||||
uint16_t getLoopTiming(int32_t* status);
|
||||
void HAL_SetPWMConfig(HAL_DigitalHandle pwm_port_handle, double maxPwm,
|
||||
double deadbandMaxPwm, double centerPwm,
|
||||
double deadbandMinPwm, double minPwm, int32_t* status);
|
||||
void HAL_SetPWMConfigRaw(HAL_DigitalHandle pwm_port_handle, int32_t maxPwm,
|
||||
int32_t deadbandMaxPwm, int32_t centerPwm,
|
||||
int32_t deadbandMinPwm, int32_t minPwm,
|
||||
int32_t* status);
|
||||
void HAL_GetPWMConfigRaw(HAL_DigitalHandle pwm_port_handle, int32_t* maxPwm,
|
||||
int32_t* deadbandMaxPwm, int32_t* centerPwm,
|
||||
int32_t* deadbandMinPwm, int32_t* minPwm,
|
||||
int32_t* status);
|
||||
void HAL_SetPWMEliminateDeadband(HAL_DigitalHandle pwm_port_handle,
|
||||
uint8_t eliminateDeadband, int32_t* status);
|
||||
uint8_t HAL_GetPWMEliminateDeadband(HAL_DigitalHandle pwm_port_handle,
|
||||
int32_t* status);
|
||||
void HAL_SetPWMRaw(HAL_DigitalHandle pwm_port_handle, uint16_t value,
|
||||
int32_t* status);
|
||||
void HAL_SetPWMSpeed(HAL_DigitalHandle pwm_port_handle, float speed,
|
||||
int32_t* status);
|
||||
void HAL_SetPWMPosition(HAL_DigitalHandle pwm_port_handle, float position,
|
||||
int32_t* status);
|
||||
void HAL_SetPWMDisabled(HAL_DigitalHandle pwm_port_handle, int32_t* status);
|
||||
uint16_t HAL_GetPWMRaw(HAL_DigitalHandle pwm_port_handle, int32_t* status);
|
||||
float HAL_GetPWMSpeed(HAL_DigitalHandle pwm_port_handle, int32_t* status);
|
||||
float HAL_GetPWMPosition(HAL_DigitalHandle pwm_port_handle, int32_t* status);
|
||||
void HAL_LatchPWMZero(HAL_DigitalHandle pwm_port_handle, int32_t* status);
|
||||
void HAL_SetPWMPeriodScale(HAL_DigitalHandle pwm_port_handle,
|
||||
uint32_t squelchMask, int32_t* status);
|
||||
uint16_t HAL_GetLoopTiming(int32_t* status);
|
||||
}
|
||||
|
||||
@@ -10,23 +10,23 @@
|
||||
#include <stdint.h>
|
||||
|
||||
extern "C" {
|
||||
int32_t HAL_getNumAccumulators(void);
|
||||
int32_t HAL_getNumAnalogTriggers(void);
|
||||
int32_t HAL_getNumAnalogInputs(void);
|
||||
int32_t HAL_getNumAnalogOutputs(void);
|
||||
int32_t HAL_getNumCounters(void);
|
||||
int32_t HAL_getNumDigitalHeaders(void);
|
||||
int32_t HAL_getNumPWMHeaders(void);
|
||||
int32_t HAL_getNumDigitalPins(void);
|
||||
int32_t HAL_getNumPWMPins(void);
|
||||
int32_t HAL_getNumDigitalPWMOutputs(void);
|
||||
int32_t HAL_getNumEncoders(void);
|
||||
int32_t HAL_getNumInterrupts(void);
|
||||
int32_t HAL_getNumRelayPins(void);
|
||||
int32_t HAL_getNumRelayHeaders(void);
|
||||
int32_t HAL_getNumPCMModules(void);
|
||||
int32_t HAL_getNumSolenoidPins(void);
|
||||
int32_t HAL_getNumPDPModules(void);
|
||||
int32_t HAL_getNumPDPChannels(void);
|
||||
int32_t HAL_getNumCanTalons(void);
|
||||
int32_t HAL_GetNumAccumulators(void);
|
||||
int32_t HAL_GetNumAnalogTriggers(void);
|
||||
int32_t HAL_GetNumAnalogInputs(void);
|
||||
int32_t HAL_GetNumAnalogOutputs(void);
|
||||
int32_t HAL_GetNumCounters(void);
|
||||
int32_t HAL_GetNumDigitalHeaders(void);
|
||||
int32_t HAL_GetNumPWMHeaders(void);
|
||||
int32_t HAL_GetNumDigitalPins(void);
|
||||
int32_t HAL_GetNumPWMPins(void);
|
||||
int32_t HAL_GetNumDigitalPWMOutputs(void);
|
||||
int32_t HAL_GetNumEncoders(void);
|
||||
int32_t HAL_GetNumInterrupts(void);
|
||||
int32_t HAL_GetNumRelayPins(void);
|
||||
int32_t HAL_GetNumRelayHeaders(void);
|
||||
int32_t HAL_GetNumPCMModules(void);
|
||||
int32_t HAL_GetNumSolenoidPins(void);
|
||||
int32_t HAL_GetNumPDPModules(void);
|
||||
int32_t HAL_GetNumPDPChannels(void);
|
||||
int32_t HAL_GetNumCanTalons(void);
|
||||
}
|
||||
|
||||
@@ -10,18 +10,18 @@
|
||||
#include <stdint.h>
|
||||
|
||||
extern "C" {
|
||||
float getVinVoltage(int32_t* status);
|
||||
float getVinCurrent(int32_t* status);
|
||||
float getUserVoltage6V(int32_t* status);
|
||||
float getUserCurrent6V(int32_t* status);
|
||||
bool getUserActive6V(int32_t* status);
|
||||
int getUserCurrentFaults6V(int32_t* status);
|
||||
float getUserVoltage5V(int32_t* status);
|
||||
float getUserCurrent5V(int32_t* status);
|
||||
bool getUserActive5V(int32_t* status);
|
||||
int getUserCurrentFaults5V(int32_t* status);
|
||||
float getUserVoltage3V3(int32_t* status);
|
||||
float getUserCurrent3V3(int32_t* status);
|
||||
bool getUserActive3V3(int32_t* status);
|
||||
int getUserCurrentFaults3V3(int32_t* status);
|
||||
float HAL_GetVinVoltage(int32_t* status);
|
||||
float HAL_GetVinCurrent(int32_t* status);
|
||||
float HAL_GetUserVoltage6V(int32_t* status);
|
||||
float HAL_GetUserCurrent6V(int32_t* status);
|
||||
bool HAL_GetUserActive6V(int32_t* status);
|
||||
int HAL_GetUserCurrentFaults6V(int32_t* status);
|
||||
float HAL_GetUserVoltage5V(int32_t* status);
|
||||
float HAL_GetUserCurrent5V(int32_t* status);
|
||||
bool HAL_GetUserActive5V(int32_t* status);
|
||||
int HAL_GetUserCurrentFaults5V(int32_t* status);
|
||||
float HAL_GetUserVoltage3V3(int32_t* status);
|
||||
float HAL_GetUserCurrent3V3(int32_t* status);
|
||||
bool HAL_GetUserActive3V3(int32_t* status);
|
||||
int HAL_GetUserCurrentFaults3V3(int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,12 +12,12 @@
|
||||
#include "Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalRelayHandle initializeRelayPort(HalPortHandle port_handle, uint8_t fwd,
|
||||
int32_t* status);
|
||||
void freeRelayPort(HalRelayHandle relay_port_handle);
|
||||
HAL_RelayHandle HAL_InitializeRelayPort(HAL_PortHandle port_handle, uint8_t fwd,
|
||||
int32_t* status);
|
||||
void HAL_FreeRelayPort(HAL_RelayHandle relay_port_handle);
|
||||
|
||||
bool checkRelayChannel(uint8_t pin);
|
||||
bool HAL_CheckRelayChannel(uint8_t pin);
|
||||
|
||||
void setRelay(HalRelayHandle relay_port_handle, bool on, int32_t* status);
|
||||
bool getRelay(HalRelayHandle relay_port_handle, int32_t* status);
|
||||
void HAL_SetRelay(HAL_RelayHandle relay_port_handle, bool on, int32_t* status);
|
||||
bool HAL_GetRelay(HAL_RelayHandle relay_port_handle, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -14,33 +14,34 @@
|
||||
priority_recursive_mutex& spiGetSemaphore(uint8_t port);
|
||||
|
||||
extern "C" {
|
||||
void spiInitialize(uint8_t port, int32_t* status);
|
||||
int32_t spiTransaction(uint8_t port, uint8_t* dataToSend, uint8_t* dataReceived,
|
||||
uint8_t size);
|
||||
int32_t spiWrite(uint8_t port, uint8_t* dataToSend, uint8_t sendSize);
|
||||
int32_t spiRead(uint8_t port, uint8_t* buffer, uint8_t count);
|
||||
void spiClose(uint8_t port);
|
||||
void spiSetSpeed(uint8_t port, uint32_t speed);
|
||||
void spiSetOpts(uint8_t port, int msb_first, int sample_on_trailing,
|
||||
int clk_idle_high);
|
||||
void spiSetChipSelectActiveHigh(uint8_t port, int32_t* status);
|
||||
void spiSetChipSelectActiveLow(uint8_t port, int32_t* status);
|
||||
int32_t spiGetHandle(uint8_t port);
|
||||
void spiSetHandle(uint8_t port, int32_t handle);
|
||||
void HAL_SpiInitialize(uint8_t port, int32_t* status);
|
||||
int32_t HAL_SpiTransaction(uint8_t port, uint8_t* dataToSend,
|
||||
uint8_t* dataReceived, uint8_t size);
|
||||
int32_t HAL_SpiWrite(uint8_t port, uint8_t* dataToSend, uint8_t sendSize);
|
||||
int32_t HAL_SpiRead(uint8_t port, uint8_t* buffer, uint8_t count);
|
||||
void HAL_SpiClose(uint8_t port);
|
||||
void HAL_SpiSetSpeed(uint8_t port, uint32_t speed);
|
||||
void HAL_SpiSetOpts(uint8_t port, int msb_first, int sample_on_trailing,
|
||||
int clk_idle_high);
|
||||
void HAL_SpiSetChipSelectActiveHigh(uint8_t port, int32_t* status);
|
||||
void HAL_SpiSetChipSelectActiveLow(uint8_t port, int32_t* status);
|
||||
int32_t HAL_SpiGetHandle(uint8_t port);
|
||||
void HAL_SpiSetHandle(uint8_t port, int32_t handle);
|
||||
|
||||
void spiInitAccumulator(uint8_t port, uint32_t period, uint32_t cmd,
|
||||
uint8_t xfer_size, uint32_t valid_mask,
|
||||
uint32_t valid_value, uint8_t data_shift,
|
||||
uint8_t data_size, bool is_signed, bool big_endian,
|
||||
int32_t* status);
|
||||
void spiFreeAccumulator(uint8_t port, int32_t* status);
|
||||
void spiResetAccumulator(uint8_t port, int32_t* status);
|
||||
void spiSetAccumulatorCenter(uint8_t port, int32_t center, int32_t* status);
|
||||
void spiSetAccumulatorDeadband(uint8_t port, int32_t deadband, int32_t* status);
|
||||
int32_t spiGetAccumulatorLastValue(uint8_t port, int32_t* status);
|
||||
int64_t spiGetAccumulatorValue(uint8_t port, int32_t* status);
|
||||
uint32_t spiGetAccumulatorCount(uint8_t port, int32_t* status);
|
||||
double spiGetAccumulatorAverage(uint8_t port, int32_t* status);
|
||||
void spiGetAccumulatorOutput(uint8_t port, int64_t* value, uint32_t* count,
|
||||
int32_t* status);
|
||||
void HAL_SpiInitAccumulator(uint8_t port, uint32_t period, uint32_t cmd,
|
||||
uint8_t xfer_size, uint32_t valid_mask,
|
||||
uint32_t valid_value, uint8_t data_shift,
|
||||
uint8_t data_size, bool is_signed, bool big_endian,
|
||||
int32_t* status);
|
||||
void HAL_SpiFreeAccumulator(uint8_t port, int32_t* status);
|
||||
void HAL_SpiResetAccumulator(uint8_t port, int32_t* status);
|
||||
void HAL_SpiSetAccumulatorCenter(uint8_t port, int32_t center, int32_t* status);
|
||||
void HAL_SpiSetAccumulatorDeadband(uint8_t port, int32_t deadband,
|
||||
int32_t* status);
|
||||
int32_t HAL_SpiGetAccumulatorLastValue(uint8_t port, int32_t* status);
|
||||
int64_t HAL_SpiGetAccumulatorValue(uint8_t port, int32_t* status);
|
||||
uint32_t HAL_SpiGetAccumulatorCount(uint8_t port, int32_t* status);
|
||||
double HAL_SpiGetAccumulatorAverage(uint8_t port, int32_t* status);
|
||||
void HAL_SpiGetAccumulatorOutput(uint8_t port, int64_t* value, uint32_t* count,
|
||||
int32_t* status);
|
||||
}
|
||||
|
||||
@@ -15,14 +15,14 @@ typedef priority_condition_variable* MULTIWAIT_ID;
|
||||
typedef priority_condition_variable::native_handle_type NATIVE_MULTIWAIT_ID;
|
||||
|
||||
extern "C" {
|
||||
MUTEX_ID initializeMutexNormal();
|
||||
void deleteMutex(MUTEX_ID sem);
|
||||
void takeMutex(MUTEX_ID sem);
|
||||
bool tryTakeMutex(MUTEX_ID sem);
|
||||
void giveMutex(MUTEX_ID sem);
|
||||
MUTEX_ID HAL_InitializeMutexNormal();
|
||||
void HAL_DeleteMutex(MUTEX_ID sem);
|
||||
void HAL_TakeMutex(MUTEX_ID sem);
|
||||
bool HAL_TryTakeMutex(MUTEX_ID sem);
|
||||
void HAL_GiveMutex(MUTEX_ID sem);
|
||||
|
||||
MULTIWAIT_ID initializeMultiWait();
|
||||
void deleteMultiWait(MULTIWAIT_ID sem);
|
||||
void takeMultiWait(MULTIWAIT_ID sem, MUTEX_ID m);
|
||||
void giveMultiWait(MULTIWAIT_ID sem);
|
||||
MULTIWAIT_ID HAL_InitializeMultiWait();
|
||||
void HAL_DeleteMultiWait(MULTIWAIT_ID sem);
|
||||
void HAL_TakeMultiWait(MULTIWAIT_ID sem, MUTEX_ID m);
|
||||
void HAL_GiveMultiWait(MULTIWAIT_ID sem);
|
||||
}
|
||||
|
||||
@@ -10,23 +10,25 @@
|
||||
#include <stdint.h>
|
||||
|
||||
extern "C" {
|
||||
void serialInitializePort(uint8_t port, int32_t* status);
|
||||
void serialSetBaudRate(uint8_t port, uint32_t baud, int32_t* status);
|
||||
void serialSetDataBits(uint8_t port, uint8_t bits, int32_t* status);
|
||||
void serialSetParity(uint8_t port, uint8_t parity, int32_t* status);
|
||||
void serialSetStopBits(uint8_t port, uint8_t stopBits, int32_t* status);
|
||||
void serialSetWriteMode(uint8_t port, uint8_t mode, int32_t* status);
|
||||
void serialSetFlowControl(uint8_t port, uint8_t flow, int32_t* status);
|
||||
void serialSetTimeout(uint8_t port, float timeout, int32_t* status);
|
||||
void serialEnableTermination(uint8_t port, char terminator, int32_t* status);
|
||||
void serialDisableTermination(uint8_t port, int32_t* status);
|
||||
void serialSetReadBufferSize(uint8_t port, uint32_t size, int32_t* status);
|
||||
void serialSetWriteBufferSize(uint8_t port, uint32_t size, int32_t* status);
|
||||
int32_t serialGetBytesReceived(uint8_t port, int32_t* status);
|
||||
uint32_t serialRead(uint8_t port, char* buffer, int32_t count, int32_t* status);
|
||||
uint32_t serialWrite(uint8_t port, const char* buffer, int32_t count,
|
||||
int32_t* status);
|
||||
void serialFlush(uint8_t port, int32_t* status);
|
||||
void serialClear(uint8_t port, int32_t* status);
|
||||
void serialClose(uint8_t port, int32_t* status);
|
||||
void HAL_SerialInitializePort(uint8_t port, int32_t* status);
|
||||
void HAL_SerialSetBaudRate(uint8_t port, uint32_t baud, int32_t* status);
|
||||
void HAL_SerialSetDataBits(uint8_t port, uint8_t bits, int32_t* status);
|
||||
void HAL_SerialSetParity(uint8_t port, uint8_t parity, int32_t* status);
|
||||
void HAL_SerialSetStopBits(uint8_t port, uint8_t stopBits, int32_t* status);
|
||||
void HAL_SerialSetWriteMode(uint8_t port, uint8_t mode, int32_t* status);
|
||||
void HAL_SerialSetFlowControl(uint8_t port, uint8_t flow, int32_t* status);
|
||||
void HAL_SerialSetTimeout(uint8_t port, float timeout, int32_t* status);
|
||||
void HAL_SerialEnableTermination(uint8_t port, char terminator,
|
||||
int32_t* status);
|
||||
void HAL_SerialDisableTermination(uint8_t port, int32_t* status);
|
||||
void HAL_SerialSetReadBufferSize(uint8_t port, uint32_t size, int32_t* status);
|
||||
void HAL_SerialSetWriteBufferSize(uint8_t port, uint32_t size, int32_t* status);
|
||||
int32_t HAL_SerialGetBytesReceived(uint8_t port, int32_t* status);
|
||||
uint32_t HAL_SerialRead(uint8_t port, char* buffer, int32_t count,
|
||||
int32_t* status);
|
||||
uint32_t HAL_SerialWrite(uint8_t port, const char* buffer, int32_t count,
|
||||
int32_t* status);
|
||||
void HAL_SerialFlush(uint8_t port, int32_t* status);
|
||||
void HAL_SerialClear(uint8_t port, int32_t* status);
|
||||
void HAL_SerialClose(uint8_t port, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -12,18 +12,18 @@
|
||||
#include "Handles.h"
|
||||
|
||||
extern "C" {
|
||||
HalSolenoidHandle initializeSolenoidPort(HalPortHandle port_handle,
|
||||
int32_t* status);
|
||||
void freeSolenoidPort(HalSolenoidHandle solenoid_port_handle);
|
||||
bool checkSolenoidModule(uint8_t module);
|
||||
HAL_SolenoidHandle HAL_InitializeSolenoidPort(HAL_PortHandle port_handle,
|
||||
int32_t* status);
|
||||
void HAL_FreeSolenoidPort(HAL_SolenoidHandle solenoid_port_handle);
|
||||
bool HAL_CheckSolenoidModule(uint8_t module);
|
||||
|
||||
bool getSolenoid(HalSolenoidHandle solenoid_port_handle, int32_t* status);
|
||||
uint8_t getAllSolenoids(uint8_t module, int32_t* status);
|
||||
void setSolenoid(HalSolenoidHandle solenoid_port_handle, bool value,
|
||||
int32_t* status);
|
||||
bool HAL_GetSolenoid(HAL_SolenoidHandle solenoid_port_handle, int32_t* status);
|
||||
uint8_t HAL_GetAllSolenoids(uint8_t module, int32_t* status);
|
||||
void HAL_SetSolenoid(HAL_SolenoidHandle solenoid_port_handle, bool value,
|
||||
int32_t* status);
|
||||
|
||||
int getPCMSolenoidBlackList(uint8_t module, int32_t* status);
|
||||
bool getPCMSolenoidVoltageStickyFault(uint8_t module, int32_t* status);
|
||||
bool getPCMSolenoidVoltageFault(uint8_t module, int32_t* status);
|
||||
void clearAllPCMStickyFaults_sol(uint8_t module, int32_t* status);
|
||||
int HAL_GetPCMSolenoidBlackList(uint8_t module, int32_t* status);
|
||||
bool HAL_GetPCMSolenoidVoltageStickyFault(uint8_t module, int32_t* status);
|
||||
bool HAL_GetPCMSolenoidVoltageFault(uint8_t module, int32_t* status);
|
||||
void HAL_ClearAllPCMStickyFaults_sol(uint8_t module, int32_t* status);
|
||||
}
|
||||
|
||||
@@ -28,9 +28,9 @@ extern "C" {
|
||||
// Note: These constants used to be declared extern and were defined in
|
||||
// Task.cpp. This caused issues with the JNI bindings for java, and so the
|
||||
// instantiations were moved here.
|
||||
const int32_t HAL_taskLib_ILLEGAL_PRIORITY = 22; // 22 is EINVAL
|
||||
const int32_t HAL_TaskLib_ILLEGAL_PRIORITY = 22; // 22 is EINVAL
|
||||
|
||||
STATUS verifyTaskID(TASK task);
|
||||
STATUS setTaskPriority(TASK task, int priority); // valid priority [1..99]
|
||||
STATUS getTaskPriority(TASK task, int* priority);
|
||||
STATUS HAL_VerifyTaskID(TASK task);
|
||||
STATUS HAL_SetTaskPriority(TASK task, int priority); // valid priority [1..99]
|
||||
STATUS HAL_GetTaskPriority(TASK task, int* priority);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user