rebellion/libpinproc
1
0
Fork 0
mirror of https://github.com/preble/libpinproc synced 2026-02-24 18:25:23 +01:00
Code Releases Activity

Tabs to spaces.

Browse Source
This commit is contained in:
Adam Preble
2009-05-19 21:21:20 -04:00
parent 0a0756c2b5
commit 62d3176463
7 changed files with 941 additions and 941 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
examples/pinproctest/pinproctest.cpp
View File

@@ -36,153 +36,153 @@
/** Demonstration of the custom logging callback. */ /** Demonstration of the custom logging callback. */
void TestLogger(const char *text) void TestLogger(const char *text)
{ {
fprintf(stderr, "TEST: %s", text); fprintf(stderr, "TEST: %s", text);
} }
void ConfigureDrivers(PRHandle proc) void ConfigureDrivers(PRHandle proc)
{ {
int i; int i;
PRDriverGlobalConfig globals; PRDriverGlobalConfig globals;
globals.enableOutputs = false; globals.enableOutputs = false;
globals.globalPolarity = false; globals.globalPolarity = false;
globals.useClear = false; globals.useClear = false;
globals.strobeStartSelect = false; globals.strobeStartSelect = false;
globals.startStrobeTime = 4; // milliseconds per output loop globals.startStrobeTime = 4; // milliseconds per output loop
globals.matrixRowEnableIndex1 = 12; globals.matrixRowEnableIndex1 = 12;
globals.matrixRowEnableIndex0 = 6; globals.matrixRowEnableIndex0 = 6;
globals.activeLowMatrixRows = true; globals.activeLowMatrixRows = true;
globals.tickleWatchdog = false; globals.tickleWatchdog = false;
globals.encodeEnables = false; globals.encodeEnables = false;
// We want to start up safely, so we'll update the global driver config twice. // We want to start up safely, so we'll update the global driver config twice.
// When we toggle enableOutputs like this P-ROC will reset the polarity: // When we toggle enableOutputs like this P-ROC will reset the polarity:
// Enable now without the outputs enabled: // Enable now without the outputs enabled:
PRDriverUpdateGlobalConfig(proc, &globals); PRDriverUpdateGlobalConfig(proc, &globals);
// Now enable the outputs: (TODO: Why?) // Now enable the outputs: (TODO: Why?)
globals.enableOutputs = true; globals.enableOutputs = true;
PRDriverUpdateGlobalConfig(proc, &globals); PRDriverUpdateGlobalConfig(proc, &globals);
// Configure the groups: // Configure the groups:
PRDriverGroupConfig group; PRDriverGroupConfig group;
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
{ {
PRDriverGetGroupConfig(proc, i + 4, &group); PRDriverGetGroupConfig(proc, i + 4, &group);
group.slowTime = 0; group.slowTime = 0;
group.enableIndex = i; group.enableIndex = i;
group.rowActivateIndex = i; group.rowActivateIndex = i;
group.rowEnableSelect = 0; group.rowEnableSelect = 0;
group.matrixed = false; group.matrixed = false;
group.polarity = false; group.polarity = false;
group.active = 1; group.active = 1;
group.disableStrobeAfter = false; group.disableStrobeAfter = false;
PRDriverUpdateGroupConfig(proc, &group); PRDriverUpdateGroupConfig(proc, &group);
} }
for (i = 6; i < 14; i++) { for (i = 6; i < 14; i++) {
PRDriverGetGroupConfig(proc, i + 4, &group); PRDriverGetGroupConfig(proc, i + 4, &group);
group.slowTime = 400; group.slowTime = 400;
group.enableIndex = 7; group.enableIndex = 7;
group.rowActivateIndex = i - 6; group.rowActivateIndex = i - 6;
group.rowEnableSelect = 0; group.rowEnableSelect = 0;
group.matrixed = 1; group.matrixed = 1;
group.polarity = 0; group.polarity = 0;
group.active = 1; group.active = 1;
group.disableStrobeAfter = 1; group.disableStrobeAfter = 1;
PRDriverUpdateGroupConfig(proc, &group); PRDriverUpdateGroupConfig(proc, &group);
} }
} }
void ConfigureSwitches(PRHandle proc) void ConfigureSwitches(PRHandle proc)
{ {
int i; int i;
// Create a basic driver for all of the switches to default to: // Create a basic driver for all of the switches to default to:
PRDriverState defaultDriver; PRDriverState defaultDriver;
memset(&defaultDriver, 0x0, sizeof(defaultDriver)); // Set all fields to 0. memset(&defaultDriver, 0x0, sizeof(defaultDriver)); // Set all fields to 0.
for (i = 0; i <= kPRSwitchPhysicalLast; i++) for (i = 0; i <= kPRSwitchPhysicalLast; i++)
{ {
PRSwitchRule sw; PRSwitchRule sw;
sw.switchNum = i; sw.switchNum = i;
sw.notifyHost = true; sw.notifyHost = true;
sw.changeOutput = false; sw.changeOutput = false;
sw.linkActive = false; sw.linkActive = false;
sw.linkAddress = 0; sw.linkAddress = 0;
sw.eventType = kPREventTypeSwitchClosedDebounced; sw.eventType = kPREventTypeSwitchClosedDebounced;
sw.driver = defaultDriver; sw.driver = defaultDriver;
PRSwitchesUpdateRules(proc, &sw, 1); PRSwitchesUpdateRules(proc, &sw, 1);
sw.eventType = kPREventTypeSwitchOpenDebounced; sw.eventType = kPREventTypeSwitchOpenDebounced;
PRSwitchesUpdateRules(proc, &sw, 1); PRSwitchesUpdateRules(proc, &sw, 1);
} }
} }
bool runLoopRun = true; bool runLoopRun = true;
void RunLoop(PRHandle proc) void RunLoop(PRHandle proc)
{ {
const int maxEvents = 16; const int maxEvents = 16;
PREvent events[maxEvents]; PREvent events[maxEvents];
while (runLoopRun) while (runLoopRun)
{ {
int numEvents = PRGetEvents(proc, events, maxEvents); int numEvents = PRGetEvents(proc, events, maxEvents);
for (int i = 0; i < numEvents; i++) for (int i = 0; i < numEvents; i++)
{ {
PREvent *event = &events[i]; PREvent *event = &events[i];
const char *stateText = "Unknown"; const char *stateText = "Unknown";
switch (event->type) switch (event->type)
{ {
case kPREventTypeSwitchOpenDebounced: stateText = "open"; break; case kPREventTypeSwitchOpenDebounced: stateText = "open"; break;
case kPREventTypeSwitchClosedDebounced: stateText = "closed"; break; case kPREventTypeSwitchClosedDebounced: stateText = "closed"; break;
case kPREventTypeSwitchOpenNondebounced: stateText = "open(ndb)"; break; case kPREventTypeSwitchOpenNondebounced: stateText = "open(ndb)"; break;
case kPREventTypeSwitchClosedNondebounced: stateText = "closed(ndb)"; break; case kPREventTypeSwitchClosedNondebounced: stateText = "closed(ndb)"; break;
} }
printf("switch % 3d: %s\n", event->value, stateText); printf("switch % 3d: %s\n", event->value, stateText);
} }
usleep(10*1000); // Sleep for 10ms so we aren't pegging the CPU. usleep(10*1000); // Sleep for 10ms so we aren't pegging the CPU.
} }
} }
void sigint(int) void sigint(int)
{ {
runLoopRun = false; runLoopRun = false;
signal(SIGINT, SIG_DFL); // Re-install the default signal handler. signal(SIGINT, SIG_DFL); // Re-install the default signal handler.
printf("Exiting...\n"); printf("Exiting...\n");
} }
int main(const char **argv, int argc) int main(const char **argv, int argc)
{ {
// Set a signal handler so that we can exit gracefully on Ctrl-C: // Set a signal handler so that we can exit gracefully on Ctrl-C:
signal(SIGINT, sigint); signal(SIGINT, sigint);
// Assign a custom logging callback to demonstrate capturing log information from P-ROC: // Assign a custom logging callback to demonstrate capturing log information from P-ROC:
PRLogSetCallback(TestLogger); PRLogSetCallback(TestLogger);
// Finally instantiate the P-ROC device: // Finally instantiate the P-ROC device:
PRHandle proc = PRCreate(kPRMachineWPC); PRHandle proc = PRCreate(kPRMachineWPC);
if (proc == kPRHandleInvalid) if (proc == kPRHandleInvalid)
return 1; return 1;
printf("Configuring P-ROC...\n"); printf("Configuring P-ROC...\n");
ConfigureDrivers(proc); ConfigureDrivers(proc);
ConfigureSwitches(proc); ConfigureSwitches(proc);
printf("Running. Hit Ctrl-C to exit.\n"); printf("Running. Hit Ctrl-C to exit.\n");
// Pulse a coil to test: // Pulse a coil to test:
// PRDriverDisable(proc, 80); // PRDriverDisable(proc, 80);
// PRDriverPulse(proc, 53, 100); // PRDriverPulse(proc, 53, 100);
RunLoop(proc); RunLoop(proc);
// Destroy the P-ROC device handle: // Destroy the P-ROC device handle:
PRDelete(proc); PRDelete(proc);
proc = kPRHandleInvalid; proc = kPRHandleInvalid;
return 0; return 0;
} }

154
include/pinproc.h
View File

@@ -35,26 +35,26 @@
/** @cond */ /** @cond */
#if defined(__WIN32__) #if defined(__WIN32__)
#undef PR_EXPORT #undef PR_EXPORT
#if defined(PR_BUILDING_PR) #if defined(PR_BUILDING_PR)
#define PR_EXPORT __declspec(dllexport) extern #define PR_EXPORT __declspec(dllexport) extern
#else #else
#define PR_EXPORT __declspec(dllimport) extern #define PR_EXPORT __declspec(dllimport) extern
#endif #endif
#endif #endif
#if !defined(PR_EXPORT) #if !defined(PR_EXPORT)
#define PR_EXPORT extern #define PR_EXPORT extern
#endif #endif
#if !defined(PR_EXTERN_C_BEGIN) #if !defined(PR_EXTERN_C_BEGIN)
#if defined(__cplusplus) #if defined(__cplusplus)
#define PR_EXTERN_C_BEGIN extern "C" { #define PR_EXTERN_C_BEGIN extern "C" {
#define PR_EXTERN_C_END } #define PR_EXTERN_C_END }
#else #else
#define PR_EXTERN_C_BEGIN #define PR_EXTERN_C_BEGIN
#define PR_EXTERN_C_END #define PR_EXTERN_C_END
#endif #endif
#endif #endif
/** @endcond */ /** @endcond */
@@ -67,20 +67,20 @@ PR_EXTERN_C_BEGIN
typedef int32_t bool_t; // FIXME: This needs better platform independence. typedef int32_t bool_t; // FIXME: This needs better platform independence.
typedef int32_t PRResult; /**< See: #kPRSuccess and #kPRFailure. */ typedef int32_t PRResult; /**< See: #kPRSuccess and #kPRFailure. */
#define kPRSuccess (1) /**< Success value for #PRResult. */ #define kPRSuccess (1) /**< Success value for #PRResult. */
#define kPRFailure (0) /**< Failure value for #PRResult. */ #define kPRFailure (0) /**< Failure value for #PRResult. */
typedef void * PRHandle; /**< Opaque type used to reference an individual P-ROC device. Created with PRCreate() and destroyed with PRDelete(). This value is used as the first parameter to all P-ROC API function calls. */ typedef void * PRHandle; /**< Opaque type used to reference an individual P-ROC device. Created with PRCreate() and destroyed with PRDelete(). This value is used as the first parameter to all P-ROC API function calls. */
#define kPRHandleInvalid (0) /**< Value returned by PRCreate() on failure. Indicates an invalid #PRHandle. */ #define kPRHandleInvalid (0) /**< Value returned by PRCreate() on failure. Indicates an invalid #PRHandle. */
typedef void (*PRLogCallback)(const char *text); /**< Function pointer type for a custom logging callback. See: PRLogSetCallback(). */ typedef void (*PRLogCallback)(const char *text); /**< Function pointer type for a custom logging callback. See: PRLogSetCallback(). */
PR_EXPORT void PRLogSetCallback(PRLogCallback callback); /**< Replaces the default logging handler with the given callback function. */ PR_EXPORT void PRLogSetCallback(PRLogCallback callback); /**< Replaces the default logging handler with the given callback function. */
typedef enum PRMachineType { typedef enum PRMachineType {
kPRMachineInvalid = 0, kPRMachineInvalid = 0,
kPRMachineCustom = 1, kPRMachineCustom = 1,
kPRMachineWPC = 2, kPRMachineWPC = 2,
kPRMachineStern = 3, // May be split into kPRMachineWhitestar and kPRMachineSAM. kPRMachineStern = 3, // May be split into kPRMachineWhitestar and kPRMachineSAM.
} PRMachineType; } PRMachineType;
// PRHandle Creation and Deletion // PRHandle Creation and Deletion
@@ -92,18 +92,18 @@ PR_EXPORT void PRDelete(PRHandle handle); /**< Destroys an existin
// Events // Events
// Closed == 0, Open == 1 // Closed == 0, Open == 1
typedef enum PREventType { typedef enum PREventType {
kPREventTypeInvalid = 0, kPREventTypeInvalid = 0,
kPREventTypeSwitchClosedDebounced = 1, /**< The switch has gone from open to closed and the signal has been debounced. */ kPREventTypeSwitchClosedDebounced = 1, /**< The switch has gone from open to closed and the signal has been debounced. */
kPREventTypeSwitchOpenDebounced = 2, /**< The switch has gone from closed to open and the signal has been debounced. */ kPREventTypeSwitchOpenDebounced = 2, /**< The switch has gone from closed to open and the signal has been debounced. */
kPREventTypeSwitchClosedNondebounced = 3, /**< The switch has gone from open to closed and the signal has not been debounced. */ kPREventTypeSwitchClosedNondebounced = 3, /**< The switch has gone from open to closed and the signal has not been debounced. */
kPREventTypeSwitchOpenNondebounced = 4, /**< The switch has gone from closed to open and the signal has not been debounced. */ kPREventTypeSwitchOpenNondebounced = 4, /**< The switch has gone from closed to open and the signal has not been debounced. */
kPREventTypetLast = kPREventTypeSwitchOpenNondebounced kPREventTypetLast = kPREventTypeSwitchOpenNondebounced
} PREventType; } PREventType;
typedef struct PREvent { typedef struct PREvent {
PREventType type; /**< The type of event that has occurred. Usually a switch event at this point. */ PREventType type; /**< The type of event that has occurred. Usually a switch event at this point. */
uint32_t value; /**< For switch events, the switch number that has changed. */ uint32_t value; /**< For switch events, the switch number that has changed. */
uint32_t time; /**< Time (in milliseconds) that this event occurred. */ uint32_t time; /**< Time (in milliseconds) that this event occurred. */
} PREvent; } PREvent;
/** Get all of the available events that have been received. */ /** Get all of the available events that have been received. */
@@ -113,40 +113,40 @@ PR_EXPORT int PRGetEvents(PRHandle handle, PREvent *eventsOut, int maxEvents);
// Drivers // Drivers
typedef struct PRDriverGlobalConfig { typedef struct PRDriverGlobalConfig {
bool_t enableOutputs; // Formerly enable_direct_outputs bool_t enableOutputs; // Formerly enable_direct_outputs
bool_t globalPolarity; bool_t globalPolarity;
bool_t useClear; bool_t useClear;
bool_t strobeStartSelect; bool_t strobeStartSelect;
uint8_t startStrobeTime; uint8_t startStrobeTime;
uint8_t matrixRowEnableIndex1; uint8_t matrixRowEnableIndex1;
uint8_t matrixRowEnableIndex0; uint8_t matrixRowEnableIndex0;
bool_t activeLowMatrixRows; bool_t activeLowMatrixRows;
bool_t encodeEnables; bool_t encodeEnables;
bool_t tickleWatchdog; bool_t tickleWatchdog;
} PRDriverGlobalConfig; } PRDriverGlobalConfig;
typedef struct PRDriverGroupConfig { typedef struct PRDriverGroupConfig {
uint8_t groupNum; uint8_t groupNum;
uint16_t slowTime; uint16_t slowTime;
uint8_t enableIndex; uint8_t enableIndex;
uint8_t rowActivateIndex; uint8_t rowActivateIndex;
uint8_t rowEnableSelect; uint8_t rowEnableSelect;
bool_t matrixed; bool_t matrixed;
bool_t polarity; bool_t polarity;
bool_t active; bool_t active;
bool_t disableStrobeAfter; bool_t disableStrobeAfter;
} PRDriverGroupConfig; } PRDriverGroupConfig;
typedef struct PRDriverState { typedef struct PRDriverState {
uint16_t driverNum; uint16_t driverNum;
uint32_t outputDriveTime; uint32_t outputDriveTime;
bool_t polarity; bool_t polarity;
bool_t state; bool_t state;
bool_t waitForFirstTimeSlot; bool_t waitForFirstTimeSlot;
uint32_t timeslots; uint32_t timeslots;
uint8_t patterOnTime; uint8_t patterOnTime;
uint8_t patterOffTime; uint8_t patterOffTime;
bool_t patterEnable; bool_t patterEnable;
} PRDriverState; } PRDriverState;
/** Update registers for the global driver configuration. */ /** Update registers for the global driver configuration. */
@@ -178,20 +178,20 @@ PR_EXPORT PRResult PRDriverPatter(PRHandle handle, uint16_t driverNum, uint16_t
/** @defgroup switchconsts Switch Constants /** @defgroup switchconsts Switch Constants
* @{ * @{
*/ */
#define kPRSwitchPhysicalFirst (0) /**< Switch number of the first physical switch. */ #define kPRSwitchPhysicalFirst (0) /**< Switch number of the first physical switch. */
#define kPRSwitchPhysicalLast (223) /**< Switch number of the last physical switch. */ #define kPRSwitchPhysicalLast (223) /**< Switch number of the last physical switch. */
#define kPRSwitchVirtualFirst (224) /**< Switch number of the first virtual switch. */ #define kPRSwitchVirtualFirst (224) /**< Switch number of the first virtual switch. */
#define kPRSwitchVirtualLast (255) /**< Switch number of the last virtual switch. */ #define kPRSwitchVirtualLast (255) /**< Switch number of the last virtual switch. */
/** @} */ /** @} */
typedef struct PRSwitchRule { typedef struct PRSwitchRule {
uint16_t switchNum; /**< Number of the physical switch, or for linked driver changes the virtual switch number (224 and up). */ uint16_t switchNum; /**< Number of the physical switch, or for linked driver changes the virtual switch number (224 and up). */
PREventType eventType; /**< The event type that this rule generates. Determines closed/open, debounced/non-debounced. */ PREventType eventType; /**< The event type that this rule generates. Determines closed/open, debounced/non-debounced. */
bool_t notifyHost; bool_t notifyHost;
bool_t changeOutput; /**< True if this switch rule should affect a driver output change. */ bool_t changeOutput; /**< True if this switch rule should affect a driver output change. */
bool_t linkActive; /**< True if this switch rule has additional linked driver updates. */ bool_t linkActive; /**< True if this switch rule has additional linked driver updates. */
uint32_t linkAddress; /**< Switch number of the linked driver update. */ uint32_t linkAddress; /**< Switch number of the linked driver update. */
PRDriverState driver; /**< Driver state change to affect once this rule is triggered. */ PRDriverState driver; /**< Driver state change to affect once this rule is triggered. */
} PRSwitchRule; } PRSwitchRule;
/** Updates the rules for the given switch and PREventType combinations. */ /** Updates the rules for the given switch and PREventType combinations. */
@@ -202,15 +202,15 @@ PR_EXPORT PRResult PRSwitchesUpdateRules(PRHandle handle, PRSwitchRule *rules, i
// DMD // DMD
typedef struct PRDMDGlobalConfig { typedef struct PRDMDGlobalConfig {
uint8_t numRows; uint8_t numRows;
uint16_t numColumns; uint16_t numColumns;
uint8_t numSubFrames; uint8_t numSubFrames;
uint16_t cyclesPerRow; uint16_t cyclesPerRow;
bool_t enable; bool_t enable;
uint8_t rclkLowCycles[8]; uint8_t rclkLowCycles[8];
uint8_t latchHighCycles[8]; uint8_t latchHighCycles[8];
uint16_t deHighCycles[8]; uint16_t deHighCycles[8];
uint8_t dotclkHalfPeriod[8]; uint8_t dotclkHalfPeriod[8];
} PRDMDConfig; } PRDMDConfig;
/** Sets the configuration registers for the DMD driver. */ /** Sets the configuration registers for the DMD driver. */

848
src/PRDevice.cpp
View File

File diff suppressed because it is too large Load Diff

104
src/PRDevice.h
View File

@@ -49,81 +49,81 @@ extern void PRLog(const char *format, ...);
class PRDevice class PRDevice
{ {
public: public:
static PRDevice *Create(PRMachineType machineType); static PRDevice *Create(PRMachineType machineType);
~PRDevice(); ~PRDevice();
protected: protected:
PRDevice(PRMachineType machineType); PRDevice(PRMachineType machineType);
public: public:
// public libpinproc API: // public libpinproc API:
int GetEvents(PREvent *events, int maxEvents); int GetEvents(PREvent *events, int maxEvents);
PRResult DriverUpdateGlobalConfig(PRDriverGlobalConfig *driverGlobalConfig); PRResult DriverUpdateGlobalConfig(PRDriverGlobalConfig *driverGlobalConfig);
PRResult DriverGetGroupConfig(uint8_t groupNum, PRDriverGroupConfig *driverGroupConfig); PRResult DriverGetGroupConfig(uint8_t groupNum, PRDriverGroupConfig *driverGroupConfig);
PRResult DriverUpdateGroupConfig(PRDriverGroupConfig *driverGroupConfig); PRResult DriverUpdateGroupConfig(PRDriverGroupConfig *driverGroupConfig);
PRResult DriverGetState(uint8_t driverNum, PRDriverState *driverState); PRResult DriverGetState(uint8_t driverNum, PRDriverState *driverState);
PRResult DriverUpdateState(PRDriverState *driverState); PRResult DriverUpdateState(PRDriverState *driverState);
PRResult DriverDisable(uint16_t driverNum); PRResult DriverDisable(uint16_t driverNum);
PRResult DriverPulse(uint16_t driverNum, int milliseconds); PRResult DriverPulse(uint16_t driverNum, int milliseconds);
PRResult DriverSchedule(uint16_t driverNum, uint32_t schedule, uint8_t cycleSeconds, bool now); PRResult DriverSchedule(uint16_t driverNum, uint32_t schedule, uint8_t cycleSeconds, bool now);
PRResult DriverPatter(uint16_t driverNum, uint16_t millisecondsOn, uint16_t millisecondsOff, uint16_t originalOnTime); PRResult DriverPatter(uint16_t driverNum, uint16_t millisecondsOn, uint16_t millisecondsOff, uint16_t originalOnTime);
PRResult SwitchesUpdateRules(PRSwitchRule *rules, int numRules); PRResult SwitchesUpdateRules(PRSwitchRule *rules, int numRules);
PRResult DMDUpdateGlobalConfig(PRDMDGlobalConfig *dmdGlobalConfig); PRResult DMDUpdateGlobalConfig(PRDMDGlobalConfig *dmdGlobalConfig);
PRResult DMDDraw(uint8_t * dots, uint16_t columns, uint8_t rows, uint8_t numSubFrames); PRResult DMDDraw(uint8_t * dots, uint16_t columns, uint8_t rows, uint8_t numSubFrames);
protected: protected:
// Device I/O // Device I/O
PRResult Open(); PRResult Open();
PRResult Close(); PRResult Close();
PRResult VerifyChipID(); PRResult VerifyChipID();
// Raw write and read methods // Raw write and read methods
/** Writes data to P-ROC. /** Writes data to P-ROC.
* Returns #kPFailure if the number of words read does not match the number requested. * Returns #kPFailure if the number of words read does not match the number requested.
*/ */
PRResult WriteData(uint32_t * buffer, int32_t numWords); PRResult WriteData(uint32_t * buffer, int32_t numWords);
/** /**
* Reads data from the buffer that was previously collected by CollectReadData(). * Reads data from the buffer that was previously collected by CollectReadData().
* Returns the number of bytes read. * Returns the number of bytes read.
*/ */
int32_t ReadData(uint32_t *buffer, int32_t maxWords); int32_t ReadData(uint32_t *buffer, int32_t maxWords);
// Collection of methods to get data returning from the P-ROC // Collection of methods to get data returning from the P-ROC
/** /**
* Request a block of data from the P-ROC. * Request a block of data from the P-ROC.
*/ */
PRResult RequestData(uint32_t module_select, uint32_t start_addr, int32_t num_words); PRResult RequestData(uint32_t module_select, uint32_t start_addr, int32_t num_words);
/** /**
* Actually reads the data off of the FTDI chip. * Actually reads the data off of the FTDI chip.
* This is called by SortReturningData() in order to get some data to process. * This is called by SortReturningData() in order to get some data to process.
*/ */
int32_t CollectReadData(); int32_t CollectReadData();
/** /**
* Processes data into unrequestedDataQueue and requestedDataQueue. * Processes data into unrequestedDataQueue and requestedDataQueue.
* Calls CollectReadData() to obtain the data and then uses ReadData() to read it out. * Calls CollectReadData() to obtain the data and then uses ReadData() to read it out.
*/ */
PRResult SortReturningData(); PRResult SortReturningData();
/** /**
* Empties out the read buffer. * Empties out the read buffer.
* Calls CollectReadData() and then ReadData() until it's empty. * Calls CollectReadData() and then ReadData() until it's empty.
*/ */
PRResult FlushReadBuffer(); PRResult FlushReadBuffer();
queue<uint32_t> unrequestedDataQueue; /**< Queue of words received from the device that were not requested via RequestData(). Usually switch events. */ queue<uint32_t> unrequestedDataQueue; /**< Queue of words received from the device that were not requested via RequestData(). Usually switch events. */
queue<uint32_t> requestedDataQueue; /**< Queue of words received from the device as the result of a call to RequestData(). */ queue<uint32_t> requestedDataQueue; /**< Queue of words received from the device as the result of a call to RequestData(). */
bool ftdiInitialized; bool ftdiInitialized;
ftdi_context ftdic; ftdi_context ftdic;
uint8_t collected_bytes_fifo[FTDI_BUFFER_SIZE]; uint8_t collected_bytes_fifo[FTDI_BUFFER_SIZE];
int32_t collected_bytes_rd_addr; int32_t collected_bytes_rd_addr;
int32_t collected_bytes_wr_addr; int32_t collected_bytes_wr_addr;
int32_t num_collected_bytes; int32_t num_collected_bytes;
@@ -132,12 +132,12 @@ protected:
uint8_t collect_buffer[FTDI_BUFFER_SIZE]; uint8_t collect_buffer[FTDI_BUFFER_SIZE];
// Local Device State // Local Device State
void Reset(); void Reset();
PRMachineType machineType; PRMachineType machineType;
PRDriverGlobalConfig driverGlobalConfig; PRDriverGlobalConfig driverGlobalConfig;
PRDriverGroupConfig driverGroups[maxDriverGroups]; PRDriverGroupConfig driverGroups[maxDriverGroups];
PRDriverState drivers[maxDrivers]; PRDriverState drivers[maxDrivers];
PRSwitchRule switchRules[maxSwitchRules]; PRSwitchRule switchRules[maxSwitchRules];
}; };

200
src/PRHardware.cpp
View File

@@ -33,139 +33,139 @@
uint32_t CreateRegRequestWord( uint32_t select, uint32_t addr, uint32_t num_words ) { uint32_t CreateRegRequestWord( uint32_t select, uint32_t addr, uint32_t num_words ) {
return ( (P_ROC_READ << P_ROC_COMMAND_SHIFT) | return ( (P_ROC_READ << P_ROC_COMMAND_SHIFT) |
(num_words << P_ROC_HEADER_LENGTH_SHIFT) | (num_words << P_ROC_HEADER_LENGTH_SHIFT) |
(select << P_ROC_MODULE_SELECT_SHIFT) | (select << P_ROC_MODULE_SELECT_SHIFT) |
(addr << P_ROC_ADDR_SHIFT) ); (addr << P_ROC_ADDR_SHIFT) );
}; };
uint32_t CreateBurstCommand ( uint32_t select, uint32_t addr, uint32_t num_words ) { uint32_t CreateBurstCommand ( uint32_t select, uint32_t addr, uint32_t num_words ) {
return ( (P_ROC_WRITE << P_ROC_COMMAND_SHIFT) | return ( (P_ROC_WRITE << P_ROC_COMMAND_SHIFT) |
(num_words << P_ROC_HEADER_LENGTH_SHIFT) | (num_words << P_ROC_HEADER_LENGTH_SHIFT) |
(select << P_ROC_MODULE_SELECT_SHIFT) | (select << P_ROC_MODULE_SELECT_SHIFT) |
(addr << P_ROC_ADDR_SHIFT) ); (addr << P_ROC_ADDR_SHIFT) );
} }
int32_t CreateDriverUpdateGlobalConfigBurst ( uint32_t * burst, PRDriverGlobalConfig *driver_globals) { int32_t CreateDriverUpdateGlobalConfigBurst ( uint32_t * burst, PRDriverGlobalConfig *driver_globals) {
uint32_t addr; uint32_t addr;
addr = 0; addr = 0;
addr = (P_ROC_DRIVER_CTRL_REG_DECODE << P_ROC_DRIVER_CTRL_DECODE_SHIFT); addr = (P_ROC_DRIVER_CTRL_REG_DECODE << P_ROC_DRIVER_CTRL_DECODE_SHIFT);
burst[0] = CreateBurstCommand (P_ROC_BUS_DRIVER_CTRL_SELECT, addr, 1 ); burst[0] = CreateBurstCommand (P_ROC_BUS_DRIVER_CTRL_SELECT, addr, 1 );
burst[1] = ( (driver_globals->enableOutputs << burst[1] = ( (driver_globals->enableOutputs <<
P_ROC_DRIVER_GLOBAL_ENABLE_DIRECT_OUTPUTS_SHIFT) | P_ROC_DRIVER_GLOBAL_ENABLE_DIRECT_OUTPUTS_SHIFT) |
(driver_globals->globalPolarity << (driver_globals->globalPolarity <<
P_ROC_DRIVER_GLOBAL_GLOBAL_POLARITY_SHIFT) | P_ROC_DRIVER_GLOBAL_GLOBAL_POLARITY_SHIFT) |
(driver_globals->useClear << (driver_globals->useClear <<
P_ROC_DRIVER_GLOBAL_USE_CLEAR_SHIFT) | P_ROC_DRIVER_GLOBAL_USE_CLEAR_SHIFT) |
(driver_globals->strobeStartSelect << (driver_globals->strobeStartSelect <<
P_ROC_DRIVER_GLOBAL_STROBE_START_SELECT_SHIFT) | P_ROC_DRIVER_GLOBAL_STROBE_START_SELECT_SHIFT) |
(driver_globals->startStrobeTime << (driver_globals->startStrobeTime <<
P_ROC_DRIVER_GLOBAL_START_STROBE_TIME_SHIFT) | P_ROC_DRIVER_GLOBAL_START_STROBE_TIME_SHIFT) |
(driver_globals->matrixRowEnableIndex1 << (driver_globals->matrixRowEnableIndex1 <<
P_ROC_DRIVER_GLOBAL_MATRIX_ROW_ENABLE_INDEX_1_SHIFT) | P_ROC_DRIVER_GLOBAL_MATRIX_ROW_ENABLE_INDEX_1_SHIFT) |
(driver_globals->matrixRowEnableIndex0 << (driver_globals->matrixRowEnableIndex0 <<
P_ROC_DRIVER_GLOBAL_MATRIX_ROW_ENABLE_INDEX_0_SHIFT) | P_ROC_DRIVER_GLOBAL_MATRIX_ROW_ENABLE_INDEX_0_SHIFT) |
(driver_globals->activeLowMatrixRows << (driver_globals->activeLowMatrixRows <<
P_ROC_DRIVER_GLOBAL_ACTIVE_LOW_MATRIX_ROWS_SHIFT) | P_ROC_DRIVER_GLOBAL_ACTIVE_LOW_MATRIX_ROWS_SHIFT) |
(driver_globals->encodeEnables << (driver_globals->encodeEnables <<
P_ROC_DRIVER_GLOBAL_ENCODE_ENABLES_SHIFT) | P_ROC_DRIVER_GLOBAL_ENCODE_ENABLES_SHIFT) |
(driver_globals->tickleWatchdog << (driver_globals->tickleWatchdog <<
P_ROC_DRIVER_GLOBAL_TICKLE_WATCHDOG_SHIFT) ); P_ROC_DRIVER_GLOBAL_TICKLE_WATCHDOG_SHIFT) );
return kPRSuccess; return kPRSuccess;
} }
int32_t CreateDriverUpdateGroupConfigBurst ( uint32_t * burst, PRDriverGroupConfig *driver_group) { int32_t CreateDriverUpdateGroupConfigBurst ( uint32_t * burst, PRDriverGroupConfig *driver_group) {
uint32_t addr; uint32_t addr;
addr = 0; addr = 0;
addr = (P_ROC_DRIVER_CTRL_REG_DECODE << P_ROC_DRIVER_CTRL_DECODE_SHIFT) | addr = (P_ROC_DRIVER_CTRL_REG_DECODE << P_ROC_DRIVER_CTRL_DECODE_SHIFT) |
driver_group->groupNum; driver_group->groupNum;
burst[0] = CreateBurstCommand (P_ROC_BUS_DRIVER_CTRL_SELECT, addr, 1 ); burst[0] = CreateBurstCommand (P_ROC_BUS_DRIVER_CTRL_SELECT, addr, 1 );
burst[1] = ( (driver_group->slowTime << burst[1] = ( (driver_group->slowTime <<
P_ROC_DRIVER_GROUP_SLOW_TIME_SHIFT) | P_ROC_DRIVER_GROUP_SLOW_TIME_SHIFT) |
(driver_group->disableStrobeAfter << (driver_group->disableStrobeAfter <<
P_ROC_DRIVER_GROUP_DISABLE_STROBE_AFTER_SHIFT) | P_ROC_DRIVER_GROUP_DISABLE_STROBE_AFTER_SHIFT) |
(driver_group->enableIndex << (driver_group->enableIndex <<
P_ROC_DRIVER_GROUP_ENABLE_INDEX_SHIFT) | P_ROC_DRIVER_GROUP_ENABLE_INDEX_SHIFT) |
(driver_group->rowActivateIndex << (driver_group->rowActivateIndex <<
P_ROC_DRIVER_GROUP_ROW_ACTIVATE_INDEX_SHIFT) | P_ROC_DRIVER_GROUP_ROW_ACTIVATE_INDEX_SHIFT) |
(driver_group->rowEnableSelect << (driver_group->rowEnableSelect <<
P_ROC_DRIVER_GROUP_ROW_ENABLE_SELECT_SHIFT) | P_ROC_DRIVER_GROUP_ROW_ENABLE_SELECT_SHIFT) |
(driver_group->matrixed << (driver_group->matrixed <<
P_ROC_DRIVER_GROUP_MATRIXED_SHIFT) | P_ROC_DRIVER_GROUP_MATRIXED_SHIFT) |
(driver_group->polarity << (driver_group->polarity <<
P_ROC_DRIVER_GROUP_POLARITY_SHIFT) | P_ROC_DRIVER_GROUP_POLARITY_SHIFT) |
(driver_group->active << (driver_group->active <<
P_ROC_DRIVER_GROUP_ACTIVE_SHIFT) ); P_ROC_DRIVER_GROUP_ACTIVE_SHIFT) );
return kPRSuccess; return kPRSuccess;
} }
int32_t CreateDriverUpdateBurst ( uint32_t * burst, PRDriverState *driver) { int32_t CreateDriverUpdateBurst ( uint32_t * burst, PRDriverState *driver) {
uint32_t addr; uint32_t addr;
addr = 0; addr = 0;
addr = (P_ROC_DRIVER_CONFIG_TABLE_DECODE << P_ROC_DRIVER_CTRL_DECODE_SHIFT) | addr = (P_ROC_DRIVER_CONFIG_TABLE_DECODE << P_ROC_DRIVER_CTRL_DECODE_SHIFT) |
(driver->driverNum << P_ROC_DRIVER_CONFIG_TABLE_DRIVER_NUM_SHIFT); (driver->driverNum << P_ROC_DRIVER_CONFIG_TABLE_DRIVER_NUM_SHIFT);
burst[0] = CreateBurstCommand (P_ROC_BUS_DRIVER_CTRL_SELECT, addr, 2 ); burst[0] = CreateBurstCommand (P_ROC_BUS_DRIVER_CTRL_SELECT, addr, 2 );
burst[1] = ( (driver->outputDriveTime << P_ROC_DRIVER_CONFIG_OUTPUT_DRIVE_TIME_SHIFT) | burst[1] = ( (driver->outputDriveTime << P_ROC_DRIVER_CONFIG_OUTPUT_DRIVE_TIME_SHIFT) |
(driver->polarity << P_ROC_DRIVER_CONFIG_POLARITY_SHIFT) | (driver->polarity << P_ROC_DRIVER_CONFIG_POLARITY_SHIFT) |
(driver->state << P_ROC_DRIVER_CONFIG_STATE_SHIFT) | (driver->state << P_ROC_DRIVER_CONFIG_STATE_SHIFT) |
(1 << P_ROC_DRIVER_CONFIG_UPDATE_SHIFT) | (1 << P_ROC_DRIVER_CONFIG_UPDATE_SHIFT) |
(driver->waitForFirstTimeSlot << P_ROC_DRIVER_CONFIG_WAIT_4_1ST_SLOT_SHIFT) | (driver->waitForFirstTimeSlot << P_ROC_DRIVER_CONFIG_WAIT_4_1ST_SLOT_SHIFT) |
(driver->timeslots << P_ROC_DRIVER_CONFIG_TIMESLOT_SHIFT) ); (driver->timeslots << P_ROC_DRIVER_CONFIG_TIMESLOT_SHIFT) );
burst[2] = (driver->timeslots >> P_ROC_DRIVER_CONFIG_TIMESLOT_SHIFT) | burst[2] = (driver->timeslots >> P_ROC_DRIVER_CONFIG_TIMESLOT_SHIFT) |
(driver->patterOnTime << P_ROC_DRIVER_CONFIG_PATTER_ON_TIME_SHIFT) | (driver->patterOnTime << P_ROC_DRIVER_CONFIG_PATTER_ON_TIME_SHIFT) |
(driver->patterOffTime << P_ROC_DRIVER_CONFIG_PATTER_OFF_TIME_SHIFT) | (driver->patterOffTime << P_ROC_DRIVER_CONFIG_PATTER_OFF_TIME_SHIFT) |
(driver->patterEnable << P_ROC_DRIVER_CONFIG_PATTER_ENABLE_SHIFT); (driver->patterEnable << P_ROC_DRIVER_CONFIG_PATTER_ENABLE_SHIFT);
return kPRSuccess; return kPRSuccess;
} }
int32_t CreateSwitchesUpdateRulesBurst ( uint32_t * burst, PRSwitchRule *rule_record) { int32_t CreateSwitchesUpdateRulesBurst ( uint32_t * burst, PRSwitchRule *rule_record) {
uint32_t addr; uint32_t addr;
uint32_t driver_command[3]; uint32_t driver_command[3];
CreateDriverUpdateBurst ( driver_command, &(rule_record->driver)); CreateDriverUpdateBurst ( driver_command, &(rule_record->driver));
uint32_t debounce = (rule_record->eventType == kPREventTypeSwitchOpenDebounced) || (rule_record->eventType == kPREventTypeSwitchClosedDebounced) ? 1 : 0; uint32_t debounce = (rule_record->eventType == kPREventTypeSwitchOpenDebounced) || (rule_record->eventType == kPREventTypeSwitchClosedDebounced) ? 1 : 0;
uint32_t state = (rule_record->eventType == kPREventTypeSwitchOpenDebounced) || (rule_record->eventType == kPREventTypeSwitchOpenNondebounced) ? 1 : 0; uint32_t state = (rule_record->eventType == kPREventTypeSwitchOpenDebounced) || (rule_record->eventType == kPREventTypeSwitchOpenNondebounced) ? 1 : 0;
addr = ( (debounce << P_ROC_SWITCH_RULE_ADDR_DEBOUNCE_SHIFT) | addr = ( (debounce << P_ROC_SWITCH_RULE_ADDR_DEBOUNCE_SHIFT) |
(state << P_ROC_SWITCH_RULE_ADDR_STATE_SHIFT) | (state << P_ROC_SWITCH_RULE_ADDR_STATE_SHIFT) |
(rule_record->switchNum << P_ROC_SWITCH_RULE_ADDR_SWITCH_NUM_SHIFT) ); (rule_record->switchNum << P_ROC_SWITCH_RULE_ADDR_SWITCH_NUM_SHIFT) );
burst[0] = CreateBurstCommand (P_ROC_BUS_STATE_CHANGE_PROC_SELECT, addr, 3 ); burst[0] = CreateBurstCommand (P_ROC_BUS_STATE_CHANGE_PROC_SELECT, addr, 3 );
burst[1] = driver_command[1]; burst[1] = driver_command[1];
burst[2] = driver_command[2]; burst[2] = driver_command[2];
burst[3] = (rule_record->changeOutput << P_ROC_SWITCH_RULE_CHANGE_OUTPUT_SHIFT) | burst[3] = (rule_record->changeOutput << P_ROC_SWITCH_RULE_CHANGE_OUTPUT_SHIFT) |
(rule_record->driver.driverNum << P_ROC_SWITCH_RULE_DRIVER_NUM_SHIFT) | (rule_record->driver.driverNum << P_ROC_SWITCH_RULE_DRIVER_NUM_SHIFT) |
(rule_record->linkActive << P_ROC_SWITCH_RULE_LINK_ACTIVE_SHIFT) | (rule_record->linkActive << P_ROC_SWITCH_RULE_LINK_ACTIVE_SHIFT) |
(rule_record->linkAddress << P_ROC_SWITCH_RULE_LINK_ADDRESS_SHIFT) | (rule_record->linkAddress << P_ROC_SWITCH_RULE_LINK_ADDRESS_SHIFT) |
(rule_record->notifyHost << P_ROC_SWITCH_RULE_NOTIFY_HOST_SHIFT); (rule_record->notifyHost << P_ROC_SWITCH_RULE_NOTIFY_HOST_SHIFT);
return kPRSuccess; return kPRSuccess;
} }
int32_t CreateDMDUpdateGlobalConfigBurst ( uint32_t * burst, PRDMDConfig *dmd_config) int32_t CreateDMDUpdateGlobalConfigBurst ( uint32_t * burst, PRDMDConfig *dmd_config)
{ {
uint32_t addr; uint32_t addr;
uint32_t i; uint32_t i;
addr = 8; addr = 8;
burst[0] = CreateBurstCommand (P_ROC_BUS_DMD_SELECT, addr, 8 ); burst[0] = CreateBurstCommand (P_ROC_BUS_DMD_SELECT, addr, 8 );
for (i=0; i<8; i++) { for (i=0; i<8; i++) {
burst[i+1] = 0; burst[i+1] = 0;
burst[i+1] = (dmd_config->rclkLowCycles[i] << P_ROC_DMD_RCLK_LOW_CYCLES_SHIFT) | burst[i+1] = (dmd_config->rclkLowCycles[i] << P_ROC_DMD_RCLK_LOW_CYCLES_SHIFT) |
(dmd_config->latchHighCycles[i] << P_ROC_DMD_LATCH_HIGH_CYCLES_SHIFT) | (dmd_config->latchHighCycles[i] << P_ROC_DMD_LATCH_HIGH_CYCLES_SHIFT) |
(dmd_config->deHighCycles[i] << P_ROC_DMD_DE_HIGH_CYCLES_SHIFT) | (dmd_config->deHighCycles[i] << P_ROC_DMD_DE_HIGH_CYCLES_SHIFT) |
(dmd_config->dotclkHalfPeriod[i] << P_ROC_DMD_DOTCLK_HALF_PERIOD_SHIFT); (dmd_config->dotclkHalfPeriod[i] << P_ROC_DMD_DOTCLK_HALF_PERIOD_SHIFT);
} }
return kPRSuccess; return kPRSuccess;
} }

60
src/pinproc.cpp
View File

@@ -37,20 +37,20 @@ PRLogCallback logCallback = NULL;
void PRLog(const char *format, ...) void PRLog(const char *format, ...)
{ {
const int maxLogLineLength = 1024; const int maxLogLineLength = 1024;
char line[maxLogLineLength]; char line[maxLogLineLength];
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
vsnprintf(line, maxLogLineLength, format, ap); vsnprintf(line, maxLogLineLength, format, ap);
if (logCallback) if (logCallback)
logCallback(line); logCallback(line);
else else
fprintf(stderr, line); fprintf(stderr, line);
} }
void PRLogSetCallback(PRLogCallback callback) void PRLogSetCallback(PRLogCallback callback)
{ {
logCallback = callback; logCallback = callback;
} }
@@ -59,17 +59,17 @@ void PRLogSetCallback(PRLogCallback callback)
/** Create a new P-ROC device handle. Only one handle per device may be created. This handle must be destroyed with PRDelete() when it is no longer needed. */ /** Create a new P-ROC device handle. Only one handle per device may be created. This handle must be destroyed with PRDelete() when it is no longer needed. */
PR_EXPORT PRHandle PRCreate(PRMachineType machineType) PR_EXPORT PRHandle PRCreate(PRMachineType machineType)
{ {
PRDevice *device = PRDevice::Create(machineType); PRDevice *device = PRDevice::Create(machineType);
if (device == NULL) if (device == NULL)
return kPRHandleInvalid; return kPRHandleInvalid;
else else
return device; return device;
} }
/** Destroys an existing P-ROC device handle. */ /** Destroys an existing P-ROC device handle. */
PR_EXPORT void PRDelete(PRHandle handle) PR_EXPORT void PRDelete(PRHandle handle)
{ {
if (handle != kPRHandleInvalid) if (handle != kPRHandleInvalid)
delete (PRDevice*)handle; delete (PRDevice*)handle;
} }
@@ -78,48 +78,48 @@ PR_EXPORT void PRDelete(PRHandle handle)
/** Get all of the available events that have been received. */ /** Get all of the available events that have been received. */
PR_EXPORT int PRGetEvents(PRHandle handle, PREvent *eventsOut, int maxEvents) PR_EXPORT int PRGetEvents(PRHandle handle, PREvent *eventsOut, int maxEvents)
{ {
return handleAsDevice->GetEvents(eventsOut, maxEvents); return handleAsDevice->GetEvents(eventsOut, maxEvents);
} }
// Drivers // Drivers
PR_EXPORT PRResult PRDriverUpdateGlobalConfig(PRHandle handle, PRDriverGlobalConfig *driverGlobalConfig) PR_EXPORT PRResult PRDriverUpdateGlobalConfig(PRHandle handle, PRDriverGlobalConfig *driverGlobalConfig)
{ {
return handleAsDevice->DriverUpdateGlobalConfig(driverGlobalConfig); return handleAsDevice->DriverUpdateGlobalConfig(driverGlobalConfig);
} }
PR_EXPORT PRResult PRDriverGetGroupConfig(PRHandle handle, uint8_t groupNum, PRDriverGroupConfig *driverGroupConfig) PR_EXPORT PRResult PRDriverGetGroupConfig(PRHandle handle, uint8_t groupNum, PRDriverGroupConfig *driverGroupConfig)
{ {
return handleAsDevice->DriverGetGroupConfig(groupNum, driverGroupConfig); return handleAsDevice->DriverGetGroupConfig(groupNum, driverGroupConfig);
} }
PR_EXPORT PRResult PRDriverUpdateGroupConfig(PRHandle handle, PRDriverGroupConfig *driverGroupConfig) PR_EXPORT PRResult PRDriverUpdateGroupConfig(PRHandle handle, PRDriverGroupConfig *driverGroupConfig)
{ {
return handleAsDevice->DriverUpdateGroupConfig(driverGroupConfig); return handleAsDevice->DriverUpdateGroupConfig(driverGroupConfig);
} }
PR_EXPORT PRResult PRDriverGetState(PRHandle handle, uint8_t driverNum, PRDriverState *driverState) PR_EXPORT PRResult PRDriverGetState(PRHandle handle, uint8_t driverNum, PRDriverState *driverState)
{ {
return handleAsDevice->DriverGetState(driverNum, driverState); return handleAsDevice->DriverGetState(driverNum, driverState);
} }
PR_EXPORT PRResult PRDriverUpdateState(PRHandle handle, PRDriverState *driverState) PR_EXPORT PRResult PRDriverUpdateState(PRHandle handle, PRDriverState *driverState)
{ {
return handleAsDevice->DriverUpdateState(driverState); return handleAsDevice->DriverUpdateState(driverState);
} }
// Driver Helper functions: // Driver Helper functions:
PR_EXPORT PRResult PRDriverDisable(PRHandle handle, uint16_t driverNum) PR_EXPORT PRResult PRDriverDisable(PRHandle handle, uint16_t driverNum)
{ {
return handleAsDevice->DriverDisable(driverNum); return handleAsDevice->DriverDisable(driverNum);
} }
PR_EXPORT PRResult PRDriverPulse(PRHandle handle, uint16_t driverNum, int milliseconds) PR_EXPORT PRResult PRDriverPulse(PRHandle handle, uint16_t driverNum, int milliseconds)
{ {
return handleAsDevice->DriverPulse(driverNum, milliseconds); return handleAsDevice->DriverPulse(driverNum, milliseconds);
} }
PR_EXPORT PRResult PRDriverSchedule(PRHandle handle, uint16_t driverNum, uint32_t schedule, uint8_t cycleSeconds, bool_t now) PR_EXPORT PRResult PRDriverSchedule(PRHandle handle, uint16_t driverNum, uint32_t schedule, uint8_t cycleSeconds, bool_t now)
{ {
return handleAsDevice->DriverSchedule(driverNum, schedule, cycleSeconds, now); return handleAsDevice->DriverSchedule(driverNum, schedule, cycleSeconds, now);
} }
PR_EXPORT PRResult PRDriverPatter(PRHandle handle, uint16_t driverNum, uint16_t millisecondsOn, uint16_t millisecondsOff, uint16_t originalOnTime) PR_EXPORT PRResult PRDriverPatter(PRHandle handle, uint16_t driverNum, uint16_t millisecondsOn, uint16_t millisecondsOff, uint16_t originalOnTime)
{ {
return handleAsDevice->DriverPatter(driverNum, millisecondsOn, millisecondsOff, originalOnTime); return handleAsDevice->DriverPatter(driverNum, millisecondsOn, millisecondsOff, originalOnTime);
} }
@@ -128,15 +128,15 @@ PR_EXPORT PRResult PRDriverPatter(PRHandle handle, uint16_t driverNum, uint16_t
PR_EXPORT PRResult PRSwitchesUpdateRules(PRHandle handle, PRSwitchRule *rules, int numRules) PR_EXPORT PRResult PRSwitchesUpdateRules(PRHandle handle, PRSwitchRule *rules, int numRules)
{ {
return handleAsDevice->SwitchesUpdateRules(rules, numRules); return handleAsDevice->SwitchesUpdateRules(rules, numRules);
} }
PR_EXPORT int32_t PRDMDUpdateGlobalConfig(PRHandle handle, PRDMDGlobalConfig *dmdGlobalConfig) PR_EXPORT int32_t PRDMDUpdateGlobalConfig(PRHandle handle, PRDMDGlobalConfig *dmdGlobalConfig)
{ {
return handleAsDevice->DMDUpdateGlobalConfig(dmdGlobalConfig); return handleAsDevice->DMDUpdateGlobalConfig(dmdGlobalConfig);
} }
PR_EXPORT PRResult PRDMDDraw(PRHandle handle, uint8_t * dots, uint16_t columns, uint8_t rows, uint8_t numSubFrames) PR_EXPORT PRResult PRDMDDraw(PRHandle handle, uint8_t * dots, uint16_t columns, uint8_t rows, uint8_t numSubFrames)
{ {
return handleAsDevice->DMDDraw(dots, columns, rows, numSubFrames); return handleAsDevice->DMDDraw(dots, columns, rows, numSubFrames);
} }