Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-23 01:21:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move CameraServer and WPILib headers into their own folder

Browse Source 
The old headers were moved into folders because doing so avoids polluting
the system include directories.

Folder names were also normalized to lowercase.
This commit is contained in:
Tyler Veness
2018-07-20 00:03:45 -07:00
committed by Peter Johnson
parent 31ced30c1e
commit d89b7dd412
728 changed files with 1876 additions and 1851 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
hal/src/main/native/sim/mockdata/DriverStationDataInternal.h Normal file
View File

@@ -0,0 +1,138 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2018 FIRST. 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 the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#pragma once
#include <array>
#include <atomic>
#include <memory>
#include <wpi/mutex.h>
#include "mockdata/DriverStationData.h"
#include "mockdata/NotifyListenerVector.h"
namespace hal {
struct JoystickOutputStore;
class DriverStationData {
public:
DriverStationData();
void ResetData();
int32_t RegisterEnabledCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelEnabledCallback(int32_t uid);
void InvokeEnabledCallback(HAL_Value value);
HAL_Bool GetEnabled();
void SetEnabled(HAL_Bool enabled);
int32_t RegisterAutonomousCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelAutonomousCallback(int32_t uid);
void InvokeAutonomousCallback(HAL_Value value);
HAL_Bool GetAutonomous();
void SetAutonomous(HAL_Bool autonomous);
int32_t RegisterTestCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelTestCallback(int32_t uid);
void InvokeTestCallback(HAL_Value value);
HAL_Bool GetTest();
void SetTest(HAL_Bool test);
int32_t RegisterEStopCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelEStopCallback(int32_t uid);
void InvokeEStopCallback(HAL_Value value);
HAL_Bool GetEStop();
void SetEStop(HAL_Bool eStop);
int32_t RegisterFmsAttachedCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelFmsAttachedCallback(int32_t uid);
void InvokeFmsAttachedCallback(HAL_Value value);
HAL_Bool GetFmsAttached();
void SetFmsAttached(HAL_Bool fmsAttached);
int32_t RegisterDsAttachedCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelDsAttachedCallback(int32_t uid);
void InvokeDsAttachedCallback(HAL_Value value);
HAL_Bool GetDsAttached();
void SetDsAttached(HAL_Bool dsAttached);
int32_t RegisterAllianceStationIdCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify);
void CancelAllianceStationIdCallback(int32_t uid);
void InvokeAllianceStationIdCallback(HAL_Value value);
HAL_AllianceStationID GetAllianceStationId();
void SetAllianceStationId(HAL_AllianceStationID allianceStationId);
int32_t RegisterMatchTimeCallback(HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify);
void CancelMatchTimeCallback(int32_t uid);
void InvokeMatchTimeCallback(HAL_Value value);
double GetMatchTime();
void SetMatchTime(double matchTime);
void GetJoystickAxes(int32_t joystickNum, HAL_JoystickAxes* axes);
void GetJoystickPOVs(int32_t joystickNum, HAL_JoystickPOVs* povs);
void GetJoystickButtons(int32_t joystickNum, HAL_JoystickButtons* buttons);
void GetJoystickDescriptor(int32_t joystickNum,
HAL_JoystickDescriptor* descriptor);
void GetJoystickOutputs(int32_t joystickNum, int64_t* outputs,
int32_t* leftRumble, int32_t* rightRumble);
void GetMatchInfo(HAL_MatchInfo* info);
void FreeMatchInfo(const HAL_MatchInfo* info);
void SetJoystickAxes(int32_t joystickNum, const HAL_JoystickAxes* axes);
void SetJoystickPOVs(int32_t joystickNum, const HAL_JoystickPOVs* povs);
void SetJoystickButtons(int32_t joystickNum,
const HAL_JoystickButtons* buttons);
void SetJoystickDescriptor(int32_t joystickNum,
const HAL_JoystickDescriptor* descriptor);
void SetJoystickOutputs(int32_t joystickNum, int64_t outputs,
int32_t leftRumble, int32_t rightRumble);
void SetMatchInfo(const HAL_MatchInfo* info);
void NotifyNewData();
private:
wpi::mutex m_registerMutex;
std::atomic<HAL_Bool> m_enabled{false};
std::shared_ptr<NotifyListenerVector> m_enabledCallbacks = nullptr;
std::atomic<HAL_Bool> m_autonomous{false};
std::shared_ptr<NotifyListenerVector> m_autonomousCallbacks = nullptr;
std::atomic<HAL_Bool> m_test{false};
std::shared_ptr<NotifyListenerVector> m_testCallbacks = nullptr;
std::atomic<HAL_Bool> m_eStop{false};
std::shared_ptr<NotifyListenerVector> m_eStopCallbacks = nullptr;
std::atomic<HAL_Bool> m_fmsAttached{false};
std::shared_ptr<NotifyListenerVector> m_fmsAttachedCallbacks = nullptr;
std::atomic<HAL_Bool> m_dsAttached{false};
std::shared_ptr<NotifyListenerVector> m_dsAttachedCallbacks = nullptr;
std::atomic<HAL_AllianceStationID> m_allianceStationId{
static_cast<HAL_AllianceStationID>(0)};
std::shared_ptr<NotifyListenerVector> m_allianceStationIdCallbacks = nullptr;
std::atomic<double> m_matchTime{0.0};
std::shared_ptr<NotifyListenerVector> m_matchTimeCallbacks = nullptr;
wpi::mutex m_joystickDataMutex;
wpi::mutex m_matchInfoMutex;
std::unique_ptr<HAL_JoystickAxes[]> m_joystickAxes;
std::unique_ptr<HAL_JoystickPOVs[]> m_joystickPOVs;
std::unique_ptr<HAL_JoystickButtons[]> m_joystickButtons;
std::unique_ptr<JoystickOutputStore[]> m_joystickOutputs;
std::unique_ptr<HAL_JoystickDescriptor[]> m_joystickDescriptor;
std::unique_ptr<HAL_MatchInfo> m_matchInfo;
};
extern DriverStationData* SimDriverStationData;
} // namespace hal