/// <summary>
/// Reports a general message to the log and or driver station
/// </summary>
/// <param name="message">message to send</param>
/// <param name="sendToDriverstation">wether to send it to the driverstation</param>
public static void General(string message, bool sendToDriverstation = false)
{
Console.WriteLine(message);
Log.Str(message);
if (sendToDriverstation)
{
DriverStation.ReportError(message, false);
}
}
public void ForeachLiveWindow(int dataHandle, ForeachLiveWindowCallback callback)
{
lock (mutex)
{
foreachComponents.Clear();
foreach (var v in components)
{
foreachComponents.Add(v.Value);
}
foreach (var comp in foreachComponents)
{
if (comp.Sendable == null) continue;
if (comp.Sendable == null || !comp.LiveWindow || !comp.Sendable.TryGetTarget(out var sendable))
{
continue;
}
ISendable? parent = null;
if (comp.Parent != null)
{
comp.Parent.TryGetTarget(out parent);
}
object? data = null;
if (comp.Data != null && dataHandle < comp.Data.Length)
{
data = comp.Data[dataHandle];
}
CallbackData cbData = new CallbackData(sendable, comp.Name, comp.Subsystem, parent, data, comp.Builder);
try
{
callback(ref cbData);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
#pragma warning restore CA1031 // Do not catch general exception types
{
DriverStation.ReportError("Unhandled exception calling LiveWindow for " + comp.Name + ": " + ex.Message, false);
}
if (cbData.Data != null)
{
if (comp.Data == null)
{
comp.Data = new object?[dataHandle + 1];
}
else if (dataHandle >= comp.Data.Length)
{
object?[] copy = new object?[dataHandle + 1];
comp.Data.CopyTo(copy.AsSpan());
comp.Data = copy;
}
comp.Data[dataHandle] = cbData.Data;
}
}
}
}
public void AddEventMarker(string name, string description, EventImportance importance)
{
if (string.IsNullOrWhiteSpace(name))
{
DriverStation.ReportError("Shuffleboard event name was not specified", true);
return;
}
m_eventsTable.GetSubTable(name).GetEntry("Info").SetStringArray(new string[] { description, importance.GetName() });
}
public void Update()
{
Row3.SetActive(pfms.estopView && (latestDSInfo.TeamNumber != 0 ? !latestDSInfo.EStop : false));
if (isRedAlliance)
{
if (pfms.jsonPayload.RedAlliance.Count >= stationId)
{
latestDSInfo = pfms.jsonPayload.RedAlliance[stationId - 1];
}
}
else
{
if (pfms.jsonPayload.BlueAlliance.Count >= stationId)
{
latestDSInfo = pfms.jsonPayload.BlueAlliance[stationId - 1];
}
}
}
/// <summary>
/// Creates a new instance of TurningPID with the supplied PIDF values.
/// </summary>
/// <param name="kp">Proportional gain.</param>
/// <param name="ki">Integral gain.</param>
/// <param name="kd">Derivative gain.</param>
/// <param name="kf">Filter gain.</param>
public TurningPID(double kp, double ki, double kd, double kf)
{
try
{
// Set the NavX to run off of displacement.
// Means it will return the distance from the start of the PID control.
RobotMap.NavX.PIDSourceType = PIDSourceType.Displacement;
// Create a new PID controller with the given PIDF values and NavX.
Controller = new PIDController(kp, ki, kd, kf, RobotMap.NavX, this);
// Sets the input range of the controller to be -180 degrees to 180 degrees.
Controller.SetInputRange(-180f, 180f);
// Sets the peak output to be 45% power on the drive train.
Controller.SetOutputRange(-.65, 65);
// Allow for a tolerance of 10 when turning.
Controller.SetAbsoluteTolerance(5);
}
catch (Exception ex) { DriverStation.ReportError(ex.Message, true); }
}
public void TestGetAlliance(DriverStation.Alliance returnAlliance, HALAllianceStationID station)
{
SetAllianceStation(station);
UpdateData();
Assert.AreEqual(returnAlliance, DriverStation.Instance.GetAlliance());
}
public GenericHID(int port)
{
m_ds = DriverStation.Instance;
Port = port;
}
/// <summary>
/// Clears all HAL Sim Data and resets it.
/// </summary>
/// <param name="resetDS">If true, resets the DS data sempahore.</param>
public static void ResetHALData(bool resetDS)
{
foreach (var halSimPCMData in PCM)
{
halSimPCMData.ResetData();
}
foreach (var halSimPDPData in PDP)
{
halSimPDPData.ResetData();
}
Accelerometer.ResetData();
foreach (var analogGyroData in AnalogGyro)
{
analogGyroData.ResetData();
}
foreach (var analogInData in AnalogIn)
{
analogInData.ResetData();
}
foreach (var analogOutData in AnalogOut)
{
analogOutData.ResetData();
}
foreach (var analogTriggerData in AnalogTrigger)
{
analogTriggerData.ResetData();
}
foreach (var dioData in DIO)
{
dioData.ResetData();
}
foreach (var pwmData in PWM)
{
pwmData.ResetData();
}
foreach (var relayData in Relay)
{
relayData.ResetData();
}
foreach (var digitalPWMData in DigitalPWM)
{
digitalPWMData.ResetData();
}
/*
* foreach (var digitalGlitchFilterData in DigitalGlitchFilter)
* {
* digitalGlitchFilterData.ResetData();
* }
*
* foreach (var counterData in Counter)
* {
* counterData.ResetData();
* }
*/
foreach (var encoderData in Encoder)
{
encoderData.ResetData();
}
RoboRioData.ResetData();
/*
* foreach (var pdpData in s_pdp.Values)
* {
* pdpData.ResetData();
* }
*
* foreach (var pcmData in s_pcm.Values)
* {
* pcmData.ResetData();
* }
*/
foreach (var spiAccelerometerData in SPIAccelerometer)
{
spiAccelerometerData.ResetData();
}
//ErrorList.Clear();
DriverStation.ResetData();
SimHooks.RestartTiming();
if (resetDS)
{
s_halNewDataSem = IntPtr.Zero;
}
}
/// <summary>
/// Reports a warning message to the log and driver station
/// </summary>
/// <param name="message">message to send</param>
public static void Warning(string message)
{
//Console.WriteLine($"WARNING:{message}");
Log.Str($"WARNING:{message}");
DriverStation.ReportError($"WARNING:{message}", false);
}
/// <summary>
/// Reports a error message to the log and driver station
/// </summary>
/// <param name="message">message to send</param>
public static void Error(string message)
{
//Console.WriteLine($"ERROR:{message}");
Log.Str($"ERROR:{message}");
DriverStation.ReportError($"ERROR:{message}", false);
}