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

Update to 2018_v4 image and new build system. (#598)

Browse Source 
* Revert "Force OpenCV to 3.1.0 (#602)"

This reverts commit 50ed55e8e2.

* Removes Simulation

* Removes old build system

* Removes old gtest

* Adds new gmock and gtest

* Updates to new ni-libraries

* removes MyRobot (to be replaced)

* moves files to new location

* Adds new sim backend and new test executables

* updates .styleguide and .gitignore

* Changes cpp WPILibVersion to a function

MSVC throws an AV with the old version.

* Disables USBCamera on all systems except for linux

* 2018 NI Libraries

* New build system
This commit is contained in:
Thad House
2017-08-18 21:35:53 -07:00
committed by Peter Johnson
parent 50ed55e8e2
commit e1195e8b9d
1024 changed files with 64481 additions and 61340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
hal/src/main/native/sim/MockData/AnalogGyroData.cpp Normal file
View File

@@ -0,0 +1,195 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2017. 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. */
/*----------------------------------------------------------------------------*/
#include "../PortsInternal.h"
#include "AnalogGyroDataInternal.h"
#include "NotifyCallbackHelpers.h"
using namespace hal;
AnalogGyroData hal::SimAnalogGyroData[kNumAccumulators];
void AnalogGyroData::ResetData() {
m_angle = 0.0;
m_angleCallbacks = nullptr;
m_rate = 0.0;
m_rateCallbacks = nullptr;
m_initialized = false;
m_initializedCallbacks = nullptr;
}
int32_t AnalogGyroData::RegisterAngleCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
// Must return -1 on a null callback for error handling
if (callback == nullptr) return -1;
int32_t newUid = 0;
{
std::lock_guard<std::mutex> lock(m_registerMutex);
m_angleCallbacks =
RegisterCallback(m_angleCallbacks, "Angle", callback, param, &newUid);
}
if (initialNotify) {
// We know that the callback is not null because of earlier null check
HAL_Value value = MakeDouble(GetAngle());
callback("Angle", param, &value);
}
return newUid;
}
void AnalogGyroData::CancelAngleCallback(int32_t uid) {
m_angleCallbacks = CancelCallback(m_angleCallbacks, uid);
}
void AnalogGyroData::InvokeAngleCallback(HAL_Value value) {
InvokeCallback(m_angleCallbacks, "Angle", &value);
}
double AnalogGyroData::GetAngle() { return m_angle; }
void AnalogGyroData::SetAngle(double angle) {
double oldValue = m_angle.exchange(angle);
if (oldValue != angle) {
InvokeAngleCallback(MakeDouble(angle));
}
}
int32_t AnalogGyroData::RegisterRateCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
// Must return -1 on a null callback for error handling
if (callback == nullptr) return -1;
int32_t newUid = 0;
{
std::lock_guard<std::mutex> lock(m_registerMutex);
m_rateCallbacks =
RegisterCallback(m_rateCallbacks, "Rate", callback, param, &newUid);
}
if (initialNotify) {
// We know that the callback is not null because of earlier null check
HAL_Value value = MakeDouble(GetRate());
callback("Rate", param, &value);
}
return newUid;
}
void AnalogGyroData::CancelRateCallback(int32_t uid) {
m_rateCallbacks = CancelCallback(m_rateCallbacks, uid);
}
void AnalogGyroData::InvokeRateCallback(HAL_Value value) {
InvokeCallback(m_rateCallbacks, "Rate", &value);
}
double AnalogGyroData::GetRate() { return m_rate; }
void AnalogGyroData::SetRate(double rate) {
double oldValue = m_rate.exchange(rate);
if (oldValue != rate) {
InvokeRateCallback(MakeDouble(rate));
}
}
int32_t AnalogGyroData::RegisterInitializedCallback(HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
// Must return -1 on a null callback for error handling
if (callback == nullptr) return -1;
int32_t newUid = 0;
{
std::lock_guard<std::mutex> lock(m_registerMutex);
m_initializedCallbacks = RegisterCallback(
m_initializedCallbacks, "Initialized", callback, param, &newUid);
}
if (initialNotify) {
// We know that the callback is not null because of earlier null check
HAL_Value value = MakeBoolean(GetInitialized());
callback("Initialized", param, &value);
}
return newUid;
}
void AnalogGyroData::CancelInitializedCallback(int32_t uid) {
m_initializedCallbacks = CancelCallback(m_initializedCallbacks, uid);
}
void AnalogGyroData::InvokeInitializedCallback(HAL_Value value) {
InvokeCallback(m_initializedCallbacks, "Initialized", &value);
}
HAL_Bool AnalogGyroData::GetInitialized() { return m_initialized; }
void AnalogGyroData::SetInitialized(HAL_Bool initialized) {
HAL_Bool oldValue = m_initialized.exchange(initialized);
if (oldValue != initialized) {
InvokeInitializedCallback(MakeBoolean(initialized));
}
}
extern "C" {
void HALSIM_ResetAnalogGyroData(int32_t index) {
SimAnalogGyroData[index].ResetData();
}
int32_t HALSIM_RegisterAnalogGyroAngleCallback(int32_t index,
HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
return SimAnalogGyroData[index].RegisterAngleCallback(callback, param,
initialNotify);
}
void HALSIM_CancelAnalogGyroAngleCallback(int32_t index, int32_t uid) {
SimAnalogGyroData[index].CancelAngleCallback(uid);
}
double HALSIM_GetAnalogGyroAngle(int32_t index) {
return SimAnalogGyroData[index].GetAngle();
}
void HALSIM_SetAnalogGyroAngle(int32_t index, double angle) {
SimAnalogGyroData[index].SetAngle(angle);
}
int32_t HALSIM_RegisterAnalogGyroRateCallback(int32_t index,
HAL_NotifyCallback callback,
void* param,
HAL_Bool initialNotify) {
return SimAnalogGyroData[index].RegisterRateCallback(callback, param,
initialNotify);
}
void HALSIM_CancelAnalogGyroRateCallback(int32_t index, int32_t uid) {
SimAnalogGyroData[index].CancelRateCallback(uid);
}
double HALSIM_GetAnalogGyroRate(int32_t index) {
return SimAnalogGyroData[index].GetRate();
}
void HALSIM_SetAnalogGyroRate(int32_t index, double rate) {
SimAnalogGyroData[index].SetRate(rate);
}
int32_t HALSIM_RegisterAnalogGyroInitializedCallback(
int32_t index, HAL_NotifyCallback callback, void* param,
HAL_Bool initialNotify) {
return SimAnalogGyroData[index].RegisterInitializedCallback(callback, param,
initialNotify);
}
void HALSIM_CancelAnalogGyroInitializedCallback(int32_t index, int32_t uid) {
SimAnalogGyroData[index].CancelInitializedCallback(uid);
}
HAL_Bool HALSIM_GetAnalogGyroInitialized(int32_t index) {
return SimAnalogGyroData[index].GetInitialized();
}
void HALSIM_SetAnalogGyroInitialized(int32_t index, HAL_Bool initialized) {
SimAnalogGyroData[index].SetInitialized(initialized);
}
}