mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-19 00:41:43 +00:00
3cd1253977
Years update, references to WIND_BASE were removed, and WPILib license was moved to the root directory of the project. If there was already a comment block, a year range through 2016 was created using the first year in the comment. If there was no comment block, a block with just the year 2016 was added. Comments were not added to files from external sources (NI, CTRE). Change-Id: Iff4f098ab908b90b8d929902dea903de2f596acc
135 lines
4.7 KiB
C++
135 lines
4.7 KiB
C++
/*----------------------------------------------------------------------------*/
|
|
/* Copyright (c) FIRST 2016. 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 "HAL/Interrupts.hpp"
|
|
#include "ChipObject.h"
|
|
|
|
extern void remapDigitalSource(bool analogTrigger, uint32_t &pin, uint8_t &module);
|
|
|
|
struct Interrupt // FIXME: why is this internal?
|
|
{
|
|
tInterrupt *anInterrupt;
|
|
tInterruptManager *manager;
|
|
};
|
|
|
|
extern "C" {
|
|
|
|
void* initializeInterrupts(uint32_t interruptIndex, bool watcher, int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = new Interrupt();
|
|
// Expects the calling leaf class to allocate an interrupt index.
|
|
anInterrupt->anInterrupt = tInterrupt::create(interruptIndex, status);
|
|
anInterrupt->anInterrupt->writeConfig_WaitForAck(false, status);
|
|
anInterrupt->manager = new tInterruptManager(
|
|
(1 << interruptIndex) | (1 << (interruptIndex + 8)), watcher, status);
|
|
return anInterrupt;
|
|
}
|
|
|
|
void cleanInterrupts(void* interrupt_pointer, int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
delete anInterrupt->anInterrupt;
|
|
delete anInterrupt->manager;
|
|
anInterrupt->anInterrupt = NULL;
|
|
anInterrupt->manager = NULL;
|
|
}
|
|
|
|
/**
|
|
* In synchronous mode, wait for the defined interrupt to occur.
|
|
* @param timeout Timeout in seconds
|
|
* @param ignorePrevious If true, ignore interrupts that happened before
|
|
* waitForInterrupt was called.
|
|
* @return The mask of interrupts that fired.
|
|
*/
|
|
uint32_t waitForInterrupt(void* interrupt_pointer, double timeout, bool ignorePrevious, int32_t *status)
|
|
{
|
|
uint32_t result;
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
|
|
result = anInterrupt->manager->watch((int32_t)(timeout * 1e3), ignorePrevious, status);
|
|
|
|
// Don't report a timeout as an error - the return code is enough to tell
|
|
// that a timeout happened.
|
|
if(*status == -NiFpga_Status_IrqTimeout) {
|
|
*status = NiFpga_Status_Success;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Enable interrupts to occur on this input.
|
|
* Interrupts are disabled when the RequestInterrupt call is made. This gives time to do the
|
|
* setup of the other options before starting to field interrupts.
|
|
*/
|
|
void enableInterrupts(void* interrupt_pointer, int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
anInterrupt->manager->enable(status);
|
|
}
|
|
|
|
/**
|
|
* Disable Interrupts without without deallocating structures.
|
|
*/
|
|
void disableInterrupts(void* interrupt_pointer, int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
anInterrupt->manager->disable(status);
|
|
}
|
|
|
|
/**
|
|
* Return the timestamp for the rising interrupt that occurred most recently.
|
|
* This is in the same time domain as GetClock().
|
|
* @return Timestamp in seconds since boot.
|
|
*/
|
|
double readRisingTimestamp(void* interrupt_pointer, int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
uint32_t timestamp = anInterrupt->anInterrupt->readRisingTimeStamp(status);
|
|
return timestamp * 1e-6;
|
|
}
|
|
|
|
/**
|
|
* Return the timestamp for the falling interrupt that occurred most recently.
|
|
* This is in the same time domain as GetClock().
|
|
* @return Timestamp in seconds since boot.
|
|
*/
|
|
double readFallingTimestamp(void* interrupt_pointer, int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
uint32_t timestamp = anInterrupt->anInterrupt->readFallingTimeStamp(status);
|
|
return timestamp * 1e-6;
|
|
}
|
|
|
|
void requestInterrupts(void* interrupt_pointer, uint8_t routing_module, uint32_t routing_pin,
|
|
bool routing_analog_trigger, int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
anInterrupt->anInterrupt->writeConfig_WaitForAck(false, status);
|
|
remapDigitalSource(routing_analog_trigger, routing_pin, routing_module);
|
|
anInterrupt->anInterrupt->writeConfig_Source_AnalogTrigger(routing_analog_trigger, status);
|
|
anInterrupt->anInterrupt->writeConfig_Source_Channel(routing_pin, status);
|
|
anInterrupt->anInterrupt->writeConfig_Source_Module(routing_module, status);
|
|
}
|
|
|
|
void attachInterruptHandler(void* interrupt_pointer, InterruptHandlerFunction handler, void* param,
|
|
int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
anInterrupt->manager->registerHandler(handler, param, status);
|
|
}
|
|
|
|
void setInterruptUpSourceEdge(void* interrupt_pointer, bool risingEdge, bool fallingEdge,
|
|
int32_t *status)
|
|
{
|
|
Interrupt* anInterrupt = (Interrupt*)interrupt_pointer;
|
|
anInterrupt->anInterrupt->writeConfig_RisingEdge(risingEdge, status);
|
|
anInterrupt->anInterrupt->writeConfig_FallingEdge(fallingEdge, status);
|
|
}
|
|
|
|
} // extern "C"
|