Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-01 02:41:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

CMake Changes

Browse Source 
This is the changes made by Patrick Plenefisch converting the native
code to use CMake and the CMake Maven Plugin, as opposed to the
native Maven plugin. This is to allow for compatibility with newer
versions of the GCC toolchain. All the cpp sources were moved from
maven style directories to cpp style directories for CMake.

Change-Id: I67f5e3608948f37c83b0990d232105a3784f8593
This commit is contained in:
Brad Miller
2014-03-24 16:13:08 -04:00
parent 33134bef1d
commit 69d9ad70ab
804 changed files with 586 additions and 9377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
hal/include/HAL/Analog.h Normal file
View File

@@ -0,0 +1,66 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_ANALOG_H
#define HAL_ANALOG_H
extern "C" {
void* initializeAnalogPort(void* port_pointer, int32_t *status);
bool checkAnalogModule(uint8_t module);
bool checkAnalogChannel(uint32_t pin);
void setAnalogSampleRate(double samplesPerSecond, int32_t *status);
float getAnalogSampleRate(int32_t *status);
void setAnalogSampleRateWithModule(uint8_t module, double samplesPerSecond, int32_t *status);
float getAnalogSampleRateWithModule(uint8_t module, int32_t *status);
void setAnalogAverageBits(void* analog_port_pointer, uint32_t bits, int32_t *status);
uint32_t getAnalogAverageBits(void* analog_port_pointer, int32_t *status);
void setAnalogOversampleBits(void* analog_port_pointer, uint32_t bits, int32_t *status);
uint32_t getAnalogOversampleBits(void* analog_port_pointer, int32_t *status);
int16_t getAnalogValue(void* analog_port_pointer, int32_t *status);
int32_t getAnalogAverageValue(void* analog_port_pointer, int32_t *status);
int32_t getAnalogVoltsToValue(void* analog_port_pointer, double voltage, int32_t *status);
float getAnalogVoltage(void* analog_port_pointer, int32_t *status);
float getAnalogAverageVoltage(void* analog_port_pointer, int32_t *status);
uint32_t getAnalogLSBWeight(void* analog_port_pointer, int32_t *status);
int32_t getAnalogOffset(void* analog_port_pointer, int32_t *status);
bool isAccumulatorChannel(void* analog_port_pointer, int32_t *status);
void initAccumulator(void* analog_port_pointer, int32_t *status);
void resetAccumulator(void* analog_port_pointer, int32_t *status);
void setAccumulatorCenter(void* analog_port_pointer, int32_t center, int32_t *status);
void setAccumulatorDeadband(void* analog_port_pointer, int32_t deadband, int32_t *status);
int64_t getAccumulatorValue(void* analog_port_pointer, int32_t *status);
uint32_t getAccumulatorCount(void* analog_port_pointer, int32_t *status);
void getAccumulatorOutput(void* analog_port_pointer, int64_t *value, uint32_t *count, int32_t *status);
typedef enum {kInWindow=0, kState=1, kRisingPulse=2, kFallingPulse=3} AnalogTriggerType;
void* initializeAnalogTrigger(void* port_pointer, uint32_t *index, int32_t *status);
void cleanAnalogTrigger(void* analog_trigger_pointer, int32_t *status);
void setAnalogTriggerLimitsRaw(void* analog_trigger_pointer, int32_t lower, int32_t upper, int32_t *status);
void setAnalogTriggerLimitsVoltage(void* analog_trigger_pointer, double lower, double upper, int32_t *status);
void setAnalogTriggerAveraged(void* analog_trigger_pointer, bool useAveragedValue, int32_t *status);
void setAnalogTriggerFiltered(void* analog_trigger_pointer, bool useFilteredValue, int32_t *status);
bool getAnalogTriggerInWindow(void* analog_trigger_pointer, int32_t *status);
bool getAnalogTriggerTriggerState(void* analog_trigger_pointer, int32_t *status);
bool getAnalogTriggerOutput(void* analog_trigger_pointer, AnalogTriggerType type, int32_t *status);
//// Float JNA Hack
// Float
int getAnalogSampleRateIntHack(int32_t *status);
int getAnalogSampleRateWithModuleIntHack(uint8_t module, int32_t *status);
int getAnalogVoltageIntHack(void* analog_port_pointer, int32_t *status);
int getAnalogAverageVoltageIntHack(void* analog_port_pointer, int32_t *status);
// Doubles
void setAnalogSampleRateIntHack(int samplesPerSecond, int32_t *status);
void setAnalogSampleRateWithModuleIntHack(uint8_t module, int samplesPerSecond, int32_t *status);
int32_t getAnalogVoltsToValueIntHack(void* analog_port_pointer, int voltage, int32_t *status);
void setAnalogTriggerLimitsVoltageIntHack(void* analog_trigger_pointer, int lower, int upper, int32_t *status);
}
#endif

15
hal/include/HAL/CAN.h Normal file
View File

@@ -0,0 +1,15 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_CAN_H
#define HAL_CAN_H
extern "C" {
void JaguarCANSendMessage(uint32_t messageID, const uint8_t *data, uint8_t dataSize, int32_t *status);
void JaguarCANReceiveMessage(uint32_t *messageID, uint8_t *data, uint8_t *dataSize, uint32_t timeoutMs, int32_t *status);
}
#endif

141
hal/include/HAL/Digital.h Normal file
View File

@@ -0,0 +1,141 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_DIGITAL_H
#define HAL_DIGITAL_H
extern "C" {
void* initializeDigitalPort(void* port_pointer, int32_t *status);
bool checkDigitalModule(uint8_t module);
bool checkPWMChannel(void* digital_port_pointer);
bool checkRelayChannel(void* digital_port_pointer);
uint8_t remapDigitalChannel(uint32_t pin, int32_t *status);
uint8_t unmapDigitalChannel(uint32_t pin, int32_t *status);
void setPWM(void* digital_port_pointer, unsigned short value, int32_t *status);
unsigned short getPWM(void* digital_port_pointer, int32_t *status);
void setPWMPeriodScale(void* digital_port_pointer, uint32_t squelchMask, int32_t *status);
void* allocatePWM(int32_t *status);
void* allocatePWMWithModule(uint8_t module, int32_t *status);
void freePWM(void* pwmGenerator, int32_t *status);
void freePWMWithModule(uint8_t module, void* pwmGenerator, int32_t *status);
void setPWMRate(double rate, int32_t *status);
void setPWMRateWithModule(uint8_t module, double rate, int32_t *status);
void setPWMDutyCycle(void* pwmGenerator, double dutyCycle, int32_t *status);
void setPWMDutyCycleWithModule(uint8_t module, void* pwmGenerator, double dutyCycle, int32_t *status);
void setPWMOutputChannel(void* pwmGenerator, uint32_t pin, int32_t *status);
void setPWMOutputChannelWithModule(uint8_t module, void* pwmGenerator, uint32_t pin, int32_t *status);
void setRelayForward(void* digital_port_pointer, bool on, int32_t *status);
void setRelayReverse(void* digital_port_pointer, bool on, int32_t *status);
bool getRelayForward(void* digital_port_pointer, int32_t *status);
bool getRelayReverse(void* digital_port_pointer, int32_t *status);
bool allocateDIO(void* digital_port_pointer, bool input, int32_t *status);
void freeDIO(void* digital_port_pointer, int32_t *status);
void setDIO(void* digital_port_pointer, short value, int32_t *status);
bool getDIO(void* digital_port_pointer, int32_t *status);
bool getDIODirection(void* digital_port_pointer, int32_t *status);
void pulse(void* digital_port_pointer, double pulseLength, int32_t *status);
bool isPulsing(void* digital_port_pointer, int32_t *status);
bool isAnyPulsing(int32_t *status);
bool isAnyPulsingWithModule(uint8_t module, int32_t *status);
typedef enum {kTwoPulse=0, kSemiperiod=1, kPulseLength=2, kExternalDirection=3} Mode;
void* initializeCounter(Mode mode, uint32_t *index, int32_t *status);
void freeCounter(void* counter_pointer, int32_t *status);
void setCounterAverageSize(void* counter_pointer, int32_t size, int32_t *status);
void setCounterUpSourceWithModule(void* counter_pointer, uint8_t module, uint32_t pin,
bool analogTrigger, int32_t *status); // TODO: Without Module
void setCounterUpSourceEdge(void* counter_pointer, bool risingEdge, bool fallingEdge, int32_t *status);
void clearCounterUpSource(void* counter_pointer, int32_t *status);
void setCounterDownSourceWithModule(void* counter_pointer, uint8_t module, uint32_t pin,
bool analogTrigger, int32_t *status); // TODO: Without Module
void setCounterDownSourceEdge(void* counter_pointer, bool risingEdge, bool fallingEdge, int32_t *status);
void clearCounterDownSource(void* counter_pointer, int32_t *status);
void setCounterUpDownMode(void* counter_pointer, int32_t *status);
void setCounterExternalDirectionMode(void* counter_pointer, int32_t *status);
void setCounterSemiPeriodMode(void* counter_pointer, bool highSemiPeriod, int32_t *status);
void setCounterPulseLengthMode(void* counter_pointer, double threshold, int32_t *status);
int32_t getCounterSamplesToAverage(void* counter_pointer, int32_t *status);
void setCounterSamplesToAverage(void* counter_pointer, int samplesToAverage, int32_t *status);
void startCounter(void* counter_pointer, int32_t *status);
void stopCounter(void* counter_pointer, int32_t *status);
void resetCounter(void* counter_pointer, int32_t *status);
int32_t getCounter(void* counter_pointer, int32_t *status);
double getCounterPeriod(void* counter_pointer, int32_t *status);
void setCounterMaxPeriod(void* counter_pointer, double maxPeriod, int32_t *status);
void setCounterUpdateWhenEmpty(void* counter_pointer, bool enabled, int32_t *status);
bool getCounterStopped(void* counter_pointer, int32_t *status);
bool getCounterDirection(void* counter_pointer, int32_t *status);
void setCounterReverseDirection(void* counter_pointer, bool reverseDirection, int32_t *status);
void* initializeEncoder(uint8_t port_a_module, uint32_t port_a_pin, bool port_a_analog_trigger,
uint8_t port_b_module, uint32_t port_b_pin, bool port_b_analog_trigger,
bool reverseDirection, int32_t *index, int32_t *status); // TODO: fix routing
void freeEncoder(void* encoder_pointer, int32_t *status);
void startEncoder(void* encoder_pointer, int32_t *status);
void stopEncoder(void* encoder_pointer, int32_t *status);
void resetEncoder(void* encoder_pointer, int32_t *status);
int32_t getEncoder(void* encoder_pointer, int32_t *status); // Raw value
double getEncoderPeriod(void* encoder_pointer, int32_t *status);
void setEncoderMaxPeriod(void* encoder_pointer, double maxPeriod, int32_t *status);
bool getEncoderStopped(void* encoder_pointer, int32_t *status);
bool getEncoderDirection(void* encoder_pointer, int32_t *status);
void setEncoderReverseDirection(void* encoder_pointer, bool reverseDirection, int32_t *status);
void setEncoderSamplesToAverage(void* encoder_pointer, uint32_t samplesToAverage, int32_t *status);
uint32_t getEncoderSamplesToAverage(void* encoder_pointer, int32_t *status);
uint16_t getLoopTiming(int32_t *status);
uint16_t getLoopTimingWithModule(uint8_t module, int32_t *status);
enum tSPIConstants {kReceiveFIFODepth=512, kTransmitFIFODepth=512};
enum tFrameMode {kChipSelect, kPreLatchPulse, kPostLatchPulse, kPreAndPostLatchPulse};
void* initializeSPI(uint8_t sclk_routing_module, uint32_t sclk_routing_pin,
uint8_t mosi_routing_module, uint32_t mosi_routing_pin,
uint8_t miso_routing_module, uint32_t miso_routing_pin, int32_t *status);
void cleanSPI(void* spi_pointer, int32_t *status);
void setSPIBitsPerWord(void* spi_pointer, uint32_t bits, int32_t *status);
uint32_t getSPIBitsPerWord(void* spi_pointer, int32_t *status);
void setSPIClockRate(void* spi_pointer, double hz, int32_t *status);
void setSPIMSBFirst(void* spi_pointer, int32_t *status);
void setSPILSBFirst(void* spi_pointer, int32_t *status);
void setSPISampleDataOnFalling(void* spi_pointer, int32_t *status);
void setSPISampleDataOnRising(void* spi_pointer, int32_t *status);
void setSPISlaveSelect(void* spi_pointer, uint8_t ss_routing_module, uint32_t ss_routing_pin,
int32_t *status);
void setSPILatchMode(void* spi_pointer, tFrameMode mode, int32_t *status);
tFrameMode getSPILatchMode(void* spi_pointer, int32_t *status);
void setSPIFramePolarity(void* spi_pointer, bool activeLow, int32_t *status);
bool getSPIFramePolarity(void* spi_pointer, int32_t *status);
void setSPIClockActiveLow(void* spi_pointer, int32_t *status);
void setSPIClockActiveHigh(void* spi_pointer, int32_t *status);
void applySPIConfig(void* spi_pointer, int32_t *status);
uint16_t getSPIOutputFIFOAvailable(void* spi_pointer, int32_t *status);
uint16_t getSPINumReceived(void* spi_pointer, int32_t *status);
bool isSPIDone(void* spi_pointer, int32_t *status);
bool hadSPIReceiveOverflow(void* spi_pointer, int32_t *status);
void writeSPI(void* spi_pointer, uint32_t data, int32_t *status);
uint32_t readSPI(void* spi_pointer, bool initiate, int32_t *status);
void resetSPI(void* spi_pointer, int32_t *status);
void clearSPIReceivedData(void* spi_pointer, int32_t *status);
bool doI2CTransaction(uint8_t address, bool compatibilityMode, uint8_t *dataToSend,
uint8_t sendSize, uint8_t *dataReceived, uint8_t receiveSize,
int32_t *status);
bool doI2CTransactionWithModule(uint8_t module, uint8_t address, bool compatibilityMode,
uint8_t *dataToSend, uint8_t sendSize, uint8_t *dataReceived,
uint8_t receiveSize, int32_t *status);
//// Float JNA Hack
// double
void setPWMRateIntHack(int rate, int32_t *status);
void setPWMRateWithModuleIntHack(uint8_t module, int32_t rate, int32_t *status);
void setPWMDutyCycleIntHack(void* pwmGenerator, int32_t dutyCycle, int32_t *status);
void setPWMDutyCycleWithModuleIntHack(uint8_t module, void* pwmGenerator, int32_t dutyCycle, int32_t *status);
}
#endif

30
hal/include/HAL/Errors.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef HAL_ERRORS_H
#define HAL_ERRORS_H
#define SAMPLE_RATE_TOO_HIGH 1
#define SAMPLE_RATE_TOO_HIGH_MESSAGE "Analog module sample rate is too high"
#define VOLTAGE_OUT_OF_RANGE 2
#define VOLTAGE_OUT_OF_RANGE_MESSAGE "Voltage to convert to raw value is out of range [-10; 10]"
#define LOOP_TIMING_ERROR 4
#define LOOP_TIMING_ERROR_MESSAGE "Digital module loop timing is not the expected value"
#define SPI_WRITE_NO_MOSI 12
#define SPI_WRITE_NO_MOSI_MESSAGE "Cannot write to SPI port with no MOSI output"
#define SPI_READ_NO_MISO 13
#define SPI_READ_NO_MISO_MESSAGE "Cannot read from SPI port with no MISO input"
#define SPI_READ_NO_DATA 14
#define SPI_READ_NO_DATA_MESSAGE "No data available to read from SPI"
#define INCOMPATIBLE_STATE 15
#define INCOMPATIBLE_STATE_MESSAGE "Incompatible State: The operation cannot be completed"
#define NO_AVAILABLE_RESOURCES -4
#define NO_AVAILABLE_RESOURCES_MESSAGE "No available resources to allocate"
#define NULL_PARAMETER -5
#define NULL_PARAMETER_MESSAGE "A pointer parameter to a method is NULL"
#define ANALOG_TRIGGER_LIMIT_ORDER_ERROR -10
#define ANALOG_TRIGGER_LIMIT_ORDER_ERROR_MESSAGE "AnalogTrigger limits error. Lower limit > Upper Limit"
#define ANALOG_TRIGGER_PULSE_OUTPUT_ERROR -11
#define ANALOG_TRIGGER_PULSE_OUTPUT_ERROR_MESSAGE "Attempted to read AnalogTrigger pulse output."
#define PARAMETER_OUT_OF_RANGE -28
#define PARAMETER_OUT_OF_RANGE_MESSAGE "A parameter is out of range."
#endif

300
hal/include/HAL/HAL.h Normal file
View File

@@ -0,0 +1,300 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2013. 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 $(WIND_BASE)/WPILib. */
/*----------------------------------------------------------------------------*/
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#include <cmath>
#include "Analog.h"
#include "Digital.h"
#include "Solenoid.h"
#include "Notifier.h"
#include "Interrupts.h"
#include "Errors.h"
#include "Utilities.h"
#include "Semaphore.h"
#include "Task.h"
#ifndef HAL_H
#define HAL_H
#define HAL_IO_CONFIG_DATA_SIZE 32
#define HAL_SYS_STATUS_DATA_SIZE 44
#define HAL_USER_STATUS_DATA_SIZE (984 - HAL_IO_CONFIG_DATA_SIZE - HAL_SYS_STATUS_DATA_SIZE)
#define HAL_USER_DS_LCD_DATA_SIZE 128
#define HALFRC_NetworkCommunication_DynamicType_DSEnhancedIO_Input 17
#define HALFRC_NetworkCommunication_DynamicType_DSEnhancedIO_Output 18
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Header 19
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Extra1 20
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Vertices1 21
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Extra2 22
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Vertices2 23
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Joystick 24
#define HALFRC_NetworkCommunication_DynamicType_Kinect_Custom 25
namespace HALUsageReporting
{
typedef enum
{
kResourceType_Controller,
kResourceType_Module,
kResourceType_Language,
kResourceType_CANPlugin,
kResourceType_Accelerometer,
kResourceType_ADXL345,
kResourceType_AnalogChannel,
kResourceType_AnalogTrigger,
kResourceType_AnalogTriggerOutput,
kResourceType_CANJaguar,
kResourceType_Compressor,
kResourceType_Counter,
kResourceType_Dashboard,
kResourceType_DigitalInput,
kResourceType_DigitalOutput,
kResourceType_DriverStationCIO,
kResourceType_DriverStationEIO,
kResourceType_DriverStationLCD,
kResourceType_Encoder,
kResourceType_GearTooth,
kResourceType_Gyro,
kResourceType_I2C,
kResourceType_Framework,
kResourceType_Jaguar,
kResourceType_Joystick,
kResourceType_Kinect,
kResourceType_KinectStick,
kResourceType_PIDController,
kResourceType_Preferences,
kResourceType_PWM,
kResourceType_Relay,
kResourceType_RobotDrive,
kResourceType_SerialPort,
kResourceType_Servo,
kResourceType_Solenoid,
kResourceType_SPI,
kResourceType_Task,
kResourceType_Ultrasonic,
kResourceType_Victor,
kResourceType_Button,
kResourceType_Command,
kResourceType_AxisCamera,
kResourceType_PCVideoServer,
kResourceType_SmartDashboard,
kResourceType_Talon,
kResourceType_HiTechnicColorSensor,
kResourceType_HiTechnicAccel,
kResourceType_HiTechnicCompass,
kResourceType_SRF08,
} tResourceType;
typedef enum
{
kLanguage_LabVIEW = 1,
kLanguage_CPlusPlus = 2,
kLanguage_Java = 3,
kLanguage_Python = 4,
kCANPlugin_BlackJagBridge = 1,
kCANPlugin_2CAN = 2,
kFramework_Iterative = 1,
kFramework_Simple = 2,
kRobotDrive_ArcadeStandard = 1,
kRobotDrive_ArcadeButtonSpin = 2,
kRobotDrive_ArcadeRatioCurve = 3,
kRobotDrive_Tank = 4,
kRobotDrive_MecanumPolar = 5,
kRobotDrive_MecanumCartesian = 6,
kDriverStationCIO_Analog = 1,
kDriverStationCIO_DigitalIn = 2,
kDriverStationCIO_DigitalOut = 3,
kDriverStationEIO_Acceleration = 1,
kDriverStationEIO_AnalogIn = 2,
kDriverStationEIO_AnalogOut = 3,
kDriverStationEIO_Button = 4,
kDriverStationEIO_LED = 5,
kDriverStationEIO_DigitalIn = 6,
kDriverStationEIO_DigitalOut = 7,
kDriverStationEIO_FixedDigitalOut = 8,
kDriverStationEIO_PWM = 9,
kDriverStationEIO_Encoder = 10,
kDriverStationEIO_TouchSlider = 11,
kADXL345_SPI = 1,
kADXL345_I2C = 2,
kCommand_Scheduler = 1,
kSmartDashboard_Instance = 1,
} tInstances;
}
struct HALCommonControlData{
uint16_t packetIndex;
union {
uint8_t control;
#ifndef __vxworks
struct {
uint8_t checkVersions :1;
uint8_t test :1;
uint8_t resync : 1;
uint8_t fmsAttached:1;
uint8_t autonomous : 1;
uint8_t enabled : 1;
uint8_t notEStop : 1;
uint8_t reset : 1;
};
#else
struct {
uint8_t reset : 1;
uint8_t notEStop : 1;
uint8_t enabled : 1;
uint8_t autonomous : 1;
uint8_t fmsAttached:1;
uint8_t resync : 1;
uint8_t test :1;
uint8_t checkVersions :1;
};
#endif
};
uint8_t dsDigitalIn;
uint16_t teamID;
char dsID_Alliance;
char dsID_Position;
union {
int8_t stick0Axes[6];
struct {
int8_t stick0Axis1;
int8_t stick0Axis2;
int8_t stick0Axis3;
int8_t stick0Axis4;
int8_t stick0Axis5;
int8_t stick0Axis6;
};
};
uint16_t stick0Buttons; // Left-most 4 bits are unused
union {
int8_t stick1Axes[6];
struct {
int8_t stick1Axis1;
int8_t stick1Axis2;
int8_t stick1Axis3;
int8_t stick1Axis4;
int8_t stick1Axis5;
int8_t stick1Axis6;
};
};
uint16_t stick1Buttons; // Left-most 4 bits are unused
union {
int8_t stick2Axes[6];
struct {
int8_t stick2Axis1;
int8_t stick2Axis2;
int8_t stick2Axis3;
int8_t stick2Axis4;
int8_t stick2Axis5;
int8_t stick2Axis6;
};
};
uint16_t stick2Buttons; // Left-most 4 bits are unused
union {
int8_t stick3Axes[6];
struct {
int8_t stick3Axis1;
int8_t stick3Axis2;
int8_t stick3Axis3;
int8_t stick3Axis4;
int8_t stick3Axis5;
int8_t stick3Axis6;
};
};
uint16_t stick3Buttons; // Left-most 4 bits are unused
//Analog inputs are 10 bit right-justified
uint16_t analog1;
uint16_t analog2;
uint16_t analog3;
uint16_t analog4;
uint64_t cRIOChecksum;
uint32_t FPGAChecksum0;
uint32_t FPGAChecksum1;
uint32_t FPGAChecksum2;
uint32_t FPGAChecksum3;
char versionData[8];
};
inline float intToFloat(int value) {
return (float)value;
}
inline int floatToInt(float value) {
return round(value);
}
extern "C" {
extern const uint32_t dio_kNumSystems;
extern const uint32_t solenoid_kNumDO7_0Elements;
extern const uint32_t interrupt_kNumSystems;
extern const uint32_t kSystemClockTicksPerMicrosecond;
void* getPort(uint8_t pin);
void* getPortWithModule(uint8_t module, uint8_t pin);
const char* getHALErrorMessage(int32_t code);
uint16_t getFPGAVersion(int32_t *status);
uint32_t getFPGARevision(int32_t *status);
uint32_t getFPGATime(int32_t *status);
void setFPGALED(uint32_t state, int32_t *status);
int32_t getFPGALED(int32_t *status);
int HALSetErrorData(const char *errors, int errorsLength, int wait_ms);
int HALSetUserDsLcdData(const char *userDsLcdData, int userDsLcdDataLength, int wait_ms);
int HALOverrideIOConfig(const char *ioConfig, int wait_ms);
int HALGetDynamicControlData(uint8_t type, char *dynamicData, int32_t maxLength, int wait_ms);
int HALGetCommonControlData(HALCommonControlData *data, int wait_ms);
void HALSetNewDataSem(pthread_mutex_t *);
int HALSetStatusData(float battery, uint8_t dsDigitalOut, uint8_t updateNumber,
const char *userDataHigh, int userDataHighLength,
const char *userDataLow, int userDataLowLength, int wait_ms);
void HALNetworkCommunicationReserve();
void HALNetworkCommunicationObserveUserProgramStarting(void);
void HALNetworkCommunicationObserveUserProgramDisabled(void);
void HALNetworkCommunicationObserveUserProgramAutonomous(void);
void HALNetworkCommunicationObserveUserProgramTeleop(void);
void HALNetworkCommunicationObserveUserProgramTest(void);
uint32_t HALReport(uint8_t resource, uint8_t instanceNumber, uint8_t context = 0, const char *feature = NULL);
}
// TODO: HACKS for now...
extern "C" {
//void FRC_NetworkCommunication_Reserve();
void NumericArrayResize();
void RTSetCleanupProc();
void EDVR_CreateReference();
void Occur();
}
#endif

27
hal/include/HAL/Interrupts.h Normal file
View File

@@ -0,0 +1,27 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_INTERRUPTS_H
#define HAL_INTERRUPTS_H
extern "C" {
typedef void (*InterruptHandlerFunction)(uint32_t interruptAssertedMask, void *param);
void* initializeInterrupts(uint32_t interruptIndex, bool watcher, int32_t *status);
void cleanInterrupts(void* interrupt_pointer, int32_t *status);
void waitForInterrupt(void* interrupt_pointer, double timeout, int32_t *status);
void enableInterrupts(void* interrupt_pointer, int32_t *status);
void disableInterrupts(void* interrupt_pointer, int32_t *status);
double readInterruptTimestamp(void* interrupt_pointer, int32_t *status);
void requestInterrupts(void* interrupt_pointer, uint8_t routing_module, uint32_t routing_pin,
bool routing_analog_trigger, int32_t *status);
void attachInterruptHandler(void* interrupt_pointer, InterruptHandlerFunction handler,
void* param, int32_t *status);
void setInterruptUpSourceEdge(void* interrupt_pointer, bool risingEdge, bool fallingEdge, int32_t *status);
}
#endif

17
hal/include/HAL/Notifier.h Normal file
View File

@@ -0,0 +1,17 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_NOTIFIER_H
#define HAL_NOTIFIER_H
extern "C" {
void* initializeNotifier(void (*ProcessQueue)(uint32_t, void*), int32_t *status);
void cleanNotifier(void* notifier_pointer, int32_t *status);
void updateNotifierAlarm(void* notifier_pointer, uint32_t triggerTime, int32_t *status);
}
#endif

54
hal/include/HAL/Semaphore.h Normal file
View File

@@ -0,0 +1,54 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#include <pthread.h>
#include <semaphore.h>
#endif
#ifndef HAL_SEMAPHORE_H
#define HAL_SEMAPHORE_H
extern "C" {
#ifdef __vxworks
typedef SEM_ID MUTEX_ID;
typedef SEM_ID SEMAPHORE_ID;
typedef SEM_ID MULTIWAIT_ID;
#else
typedef pthread_mutex_t* MUTEX_ID;
typedef sem_t* SEMAPHORE_ID;
typedef pthread_cond_t* MULTIWAIT_ID;
#endif
extern const uint32_t SEMAPHORE_Q_FIFO;
extern const uint32_t SEMAPHORE_Q_PRIORITY;
extern const uint32_t SEMAPHORE_DELETE_SAFE;
extern const uint32_t SEMAPHORE_INVERSION_SAFE;
extern const int32_t SEMAPHORE_NO_WAIT;
extern const int32_t SEMAPHORE_WAIT_FOREVER;
extern const uint32_t SEMAPHORE_EMPTY;
extern const uint32_t SEMAPHORE_FULL;
MUTEX_ID initializeMutexRecursive();
MUTEX_ID initializeMutexNormal();
void deleteMutex(MUTEX_ID sem);
int8_t takeMutex(MUTEX_ID sem);
int8_t tryTakeMutex(MUTEX_ID sem);
int8_t giveMutex(MUTEX_ID sem);
SEMAPHORE_ID initializeSemaphore(uint32_t initial_value);
void deleteSemaphore(SEMAPHORE_ID sem);
int8_t takeSemaphore(SEMAPHORE_ID sem);
int8_t tryTakeSemaphore(SEMAPHORE_ID sem);
int8_t giveSemaphore(SEMAPHORE_ID sem);
MULTIWAIT_ID initializeMultiWait();
void deleteMultiWait(MULTIWAIT_ID sem);
int8_t takeMultiWait(MULTIWAIT_ID sem, int32_t timeout);
int8_t giveMultiWait(MULTIWAIT_ID sem);
}
#endif

17
hal/include/HAL/Solenoid.h Normal file
View File

@@ -0,0 +1,17 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_SOLENOID_H
#define HAL_SOLENOID_H
extern "C" {
void* initializeSolenoidPort(void* port_pointer, int32_t *status);
bool checkSolenoidModule(uint8_t module);
bool getSolenoid(void* solenoid_port_pointer, int32_t *status);
void setSolenoid(void* solenoid_port_pointer, bool value, int32_t *status);
}
#endif

68
hal/include/HAL/Task.h Normal file
View File

@@ -0,0 +1,68 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#include <pthread.h>
#endif
#ifndef _FUNCPTR_DEFINED
#define _FUNCPTR_DEFINED
#ifdef __cplusplus
typedef int (*FUNCPTR) (...); /* ptr to function returning int */
#else
typedef int (*FUNCPTR) (); /* ptr to function returning int */
#endif /* __cplusplus */
#endif /* _FUNCPTR_DEFINED */
#ifndef _STATUS_DEFINED
#define _STATUS_DEFINED
typedef int STATUS;
#endif /* _STATUS_DEFINED */
#ifndef OK
#define OK 0
#endif /* OK */
#ifndef ERROR
#define ERROR (-1)
#endif /* ERROR */
#ifndef HAL_TASK_H
#define HAL_TASK_H
#ifdef __vxworks
#define NULL_TASK -1
#else
#define NULL_TASK NULL
#endif
extern "C" {
extern const uint32_t VXWORKS_FP_TASK;
extern const int32_t HAL_objLib_OBJ_ID_ERROR;
extern const int32_t HAL_objLib_OBJ_DELETED;
extern const int32_t HAL_taskLib_ILLEGAL_OPTIONS;
extern const int32_t HAL_memLib_NOT_ENOUGH_MEMORY;
extern const int32_t HAL_taskLib_ILLEGAL_PRIORITY;
#ifdef __vxworks
typedef int32_t TASK;
#else
typedef pthread_t* TASK;
#endif
TASK spawnTask(char * name, int priority, int options, int stackSize,
FUNCPTR entryPt, uint32_t arg0, uint32_t arg1, uint32_t arg2,
uint32_t arg3, uint32_t arg4, uint32_t arg5, uint32_t arg6,
uint32_t arg7, uint32_t arg8, uint32_t arg9);
STATUS restartTask(TASK task);
STATUS deleteTask(TASK task);
STATUS isTaskReady(TASK task);
STATUS isTaskSuspended(TASK task);
STATUS suspendTask(TASK task);
STATUS resumeTask(TASK task);
STATUS verifyTaskID(TASK task);
STATUS setTaskPriority(TASK task, int priority);
STATUS getTaskPriority(TASK task, int* priority);
}
#endif

18
hal/include/HAL/Utilities.h Normal file
View File

@@ -0,0 +1,18 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_UTILITIES_H
#define HAL_UTILITIES_H
extern "C" {
extern const int32_t HAL_NO_WAIT;
extern const int32_t HAL_WAIT_FOREVER;
void delayTicks(int32_t ticks);
void delayMillis(double ms);
void delaySeconds(double s);}
#endif

48
hal/include/HAL/cpp/Resource.h Normal file
View File

@@ -0,0 +1,48 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. 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 $(WIND_BASE)/WPILib. */
/*----------------------------------------------------------------------------*/
#ifndef RESOURCE_H_
#define RESOURCE_H_
#include "../Errors.h"
#include "Synchronized.h"
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
/**
* The Resource class is a convenient way to track allocated resources.
* It tracks them as indicies in the range [0 .. elements - 1].
* E.g. the library uses this to track hardware channel allocation.
*
* The Resource class does not allocate the hardware channels or other
* resources; it just tracks which indices were marked in use by
* Allocate and not yet freed by Free.
*/
class Resource
{
public:
virtual ~Resource();
static void CreateResourceObject(Resource **r, uint32_t elements);
uint32_t Allocate(const char *resourceDesc);
uint32_t Allocate(uint32_t index, const char *resourceDesc);
void Free(uint32_t index);
private:
explicit Resource(uint32_t size);
bool *m_isAllocated;
ReentrantSemaphore m_allocateLock;
uint32_t m_size;
static ReentrantSemaphore m_createLock;
DISALLOW_COPY_AND_ASSIGN(Resource);
};
#endif

15
hal/include/HAL/cpp/StackTrace.h Normal file
View File

@@ -0,0 +1,15 @@
#ifdef __vxworks
#include <vxWorks.h>
#else
#include <stdint.h>
#endif
#ifndef HAL_STACKTRACE_H
#define HAL_STACKTRACE_H
extern "C" {
void printCurrentStackTrace();
bool getErrnoToName(int32_t errNo, char* name);
}
#endif

102
hal/include/HAL/cpp/Synchronized.h Normal file
View File

@@ -0,0 +1,102 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. 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 $(WIND_BASE)/WPILib. */
/*----------------------------------------------------------------------------*/
#ifndef SYNCHRONIZED_H
#define SYNCHRONIZED_H
#include "HAL/HAL.h"
// A macro to disallow the copy constructor and operator= functions
// This should be used in the private: declarations for a class
#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&); \
void operator=(const TypeName&)
#define CRITICAL_REGION(s) { Synchronized _sync(s);
#define END_REGION }
class Synchronized;
/**
* Wrap a vxWorks semaphore (SEM_ID) for easier use in C++. For a static
* instance, the constructor runs at program load time before main() can spawn
* any tasks. Use that to fix race conditions in setup code.
*
* This uses a semM semaphore which is "reentrant" in the sense that the owning
* task can "take" the semaphore more than once. It will need to "give" the
* semaphore the same number of times to unlock it.
*
* This class is safe to use in static variables because it does not depend on
* any other C++ static constructors or destructors.
*/
class ReentrantSemaphore
{
public:
explicit ReentrantSemaphore() {
m_semaphore = initializeMutexRecursive();
}
~ReentrantSemaphore() {
deleteMutex(m_semaphore);
}
/**
* Lock the semaphore, blocking until it's available.
* @return 0 for success, -1 for error. If -1, the error will be in errno.
*/
int take() {
return takeMutex(m_semaphore);
}
/**
* Unlock the semaphore.
* @return 0 for success, -1 for error. If -1, the error will be in errno.
*/
int give() {
return giveMutex(m_semaphore);
}
private:
MUTEX_ID m_semaphore;
friend class Synchronized;
DISALLOW_COPY_AND_ASSIGN(ReentrantSemaphore);
};
/**
* Provide easy support for critical regions.
*
* A critical region is an area of code that is always executed under mutual exclusion. Only
* one task can be executing this code at any time. The idea is that code that manipulates data
* that is shared between two or more tasks has to be prevented from executing at the same time
* otherwise a race condition is possible when both tasks try to update the data. Typically
* semaphores are used to ensure only single task access to the data.
*
* Synchronized objects are a simple wrapper around semaphores to help ensure
* that semaphores are always unlocked (semGive) after locking (semTake).
*
* You allocate a Synchronized as a local variable, *not* on the heap. That
* makes it a "stack object" whose destructor runs automatically when it goes
* out of scope. E.g.
*
* { Synchronized _sync(aReentrantSemaphore); ... critical region ... }
*/
class Synchronized
{
public:
explicit Synchronized(MUTEX_ID);
#ifndef __vxworks
explicit Synchronized(SEMAPHORE_ID);
#endif
explicit Synchronized(ReentrantSemaphore&);
virtual ~Synchronized();
private:
MUTEX_ID m_mutex;
SEMAPHORE_ID m_semaphore;
DISALLOW_COPY_AND_ASSIGN(Synchronized);
};
#endif