mirror of
https://github.com/preble/libpinproc
synced 2026-02-24 18:25:23 +01:00
935 lines
33 KiB
C++
935 lines
33 KiB
C++
/*
|
|
* The MIT License
|
|
* Copyright (c) 2009 Gerry Stellenberg, Adam Preble
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
/*
|
|
* PRDevice.cpp
|
|
* libpinproc
|
|
*/
|
|
|
|
#include "PRDevice.h"
|
|
|
|
PRDevice::PRDevice(PRMachineType machineType) : machineType(machineType)
|
|
{
|
|
// Reset internally maintainted driver and switch structures, but do not update the device.
|
|
Reset(kPRResetFlagDefault);
|
|
}
|
|
|
|
PRDevice::~PRDevice()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
PRDevice* PRDevice::Create(PRMachineType machineType)
|
|
{
|
|
PRDevice *dev = new PRDevice(machineType);
|
|
|
|
if (dev == NULL)
|
|
{
|
|
DEBUG(PRLog(kPRLogError, "Error allocating memory for P-ROC device\n"));
|
|
return NULL;
|
|
}
|
|
|
|
if (!dev->Open())
|
|
{
|
|
DEBUG(PRLog(kPRLogError, "Error opening P-ROC device.\n"));
|
|
delete dev;
|
|
return NULL;
|
|
}
|
|
|
|
return dev;
|
|
}
|
|
|
|
PRResult PRDevice::Reset(uint32_t resetFlags)
|
|
{
|
|
int i;
|
|
|
|
// Make sure the data queues are empty.
|
|
while (!unrequestedDataQueue.empty()) unrequestedDataQueue.pop();
|
|
while (!requestedDataQueue.empty()) requestedDataQueue.pop();
|
|
num_collected_bytes = 0;
|
|
numPreparedWriteWords = 0;
|
|
|
|
DriverLoadMachineTypeDefaults(machineType, resetFlags);
|
|
|
|
// Make sure the free list is empty.
|
|
while (!freeSwitchRuleIndexes.empty()) freeSwitchRuleIndexes.pop();
|
|
|
|
for (i = 0; i < kPRSwitchRulesCount; i++)
|
|
{
|
|
PRSwitchRuleInternal *switchRule = &switchRules[i];
|
|
memset(switchRule, 0x00, sizeof(PRSwitchRule));
|
|
|
|
uint16_t ruleIndex = i;
|
|
ParseSwitchRuleIndex(ruleIndex, &switchRule->switchNum, &switchRule->eventType);
|
|
switchRule->driver.polarity = driverGlobalConfig.globalPolarity;
|
|
if (switchRule->switchNum >= kPRSwitchVirtualFirst) // Disabled for compiler warning (always true due to data type): && switchRule->switchNum <= kPRSwitchVirtualLast)
|
|
freeSwitchRuleIndexes.push(ruleIndex);
|
|
}
|
|
|
|
// Create empty switch rule for clearing the rules in the device.
|
|
PRSwitchRule emptySwitchRule;
|
|
memset(&emptySwitchRule, 0x00, sizeof(PRSwitchRule));
|
|
|
|
for (i = 0; i < kPRSwitchCount; i++)
|
|
{
|
|
// Send blank rule for each event type to Device if necessary
|
|
if ((resetFlags & kPRResetFlagUpdateDevice) && i <= kPRSwitchPhysicalLast)
|
|
{
|
|
SwitchUpdateRule(i, kPREventTypeSwitchOpenDebounced, &emptySwitchRule, NULL, 0);
|
|
SwitchUpdateRule(i, kPREventTypeSwitchClosedDebounced, &emptySwitchRule, NULL, 0);
|
|
SwitchUpdateRule(i, kPREventTypeSwitchOpenNondebounced, &emptySwitchRule, NULL, 0);
|
|
SwitchUpdateRule(i, kPREventTypeSwitchClosedNondebounced, &emptySwitchRule, NULL, 0);
|
|
}
|
|
}
|
|
|
|
return kPRSuccess;
|
|
}
|
|
|
|
int PRDevice::GetEvents(PREvent *events, int maxEvents)
|
|
{
|
|
SortReturningData();
|
|
|
|
// The unrequestedDataQueue only has unrequested switch event data. Pop
|
|
// events out 1 at a time, interpret them, and populate the outgoing list with them.
|
|
int i;
|
|
for (i = 0; (i < maxEvents) && !unrequestedDataQueue.empty(); i++)
|
|
{
|
|
uint32_t event_data = unrequestedDataQueue.front();
|
|
unrequestedDataQueue.pop();
|
|
|
|
events[i].value = event_data & P_ROC_EVENT_SWITCH_NUM_MASK;
|
|
bool open = (event_data & P_ROC_EVENT_SWITCH_STATE_MASK) >> P_ROC_EVENT_SWITCH_STATE_SHIFT;
|
|
bool debounced = (event_data & P_ROC_EVENT_SWITCH_DEBOUNCED_MASK) >> P_ROC_EVENT_SWITCH_DEBOUNCED_SHIFT;
|
|
if (open)
|
|
events[i].type = debounced ? kPREventTypeSwitchOpenDebounced : kPREventTypeSwitchOpenNondebounced;
|
|
else
|
|
events[i].type = debounced ? kPREventTypeSwitchClosedDebounced : kPREventTypeSwitchOpenNondebounced;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
PRResult PRDevice::DriverUpdateGlobalConfig(PRDriverGlobalConfig *driverGlobalConfig)
|
|
{
|
|
const int burstWords = 4;
|
|
uint32_t burst[burstWords];
|
|
int32_t rc;
|
|
|
|
DEBUG(PRLog(kPRLogInfo, "Installing driver globals\n"));
|
|
|
|
this->driverGlobalConfig = *driverGlobalConfig;
|
|
rc = CreateDriverUpdateGlobalConfigBurst(burst, driverGlobalConfig);
|
|
rc = CreateWatchdogConfigBurst(burst+2, driverGlobalConfig->watchdogExpired,
|
|
driverGlobalConfig->watchdogEnable,
|
|
driverGlobalConfig->watchdogResetTime);
|
|
|
|
DEBUG(PRLog(kPRLogVerbose, "Driver Global words: %x %x\n", burst[0], burst[1]));
|
|
DEBUG(PRLog(kPRLogVerbose, "Watchdog words: %x %x\n", burst[2], burst[3]));
|
|
return PrepareWriteData(burst, burstWords);
|
|
}
|
|
|
|
PRResult PRDevice::DriverGetGroupConfig(uint8_t groupNum, PRDriverGroupConfig *driverGroupConfig)
|
|
{
|
|
*driverGroupConfig = driverGroups[groupNum];
|
|
return kPRSuccess;
|
|
}
|
|
|
|
PRResult PRDevice::DriverUpdateGroupConfig(PRDriverGroupConfig *driverGroupConfig)
|
|
{
|
|
const int burstWords = 2;
|
|
uint32_t burst[burstWords];
|
|
int32_t rc;
|
|
|
|
driverGroups[driverGroupConfig->groupNum] = *driverGroupConfig;
|
|
DEBUG(PRLog(kPRLogInfo, "Installing driver group\n"));
|
|
rc = CreateDriverUpdateGroupConfigBurst(burst, driverGroupConfig);
|
|
|
|
DEBUG(PRLog(kPRLogVerbose, "Words: %x %x\n", burst[0], burst[1]));
|
|
return PrepareWriteData(burst, burstWords);
|
|
}
|
|
|
|
PRResult PRDevice::DriverGetState(uint8_t driverNum, PRDriverState *driverState)
|
|
{
|
|
*driverState = drivers[driverNum];
|
|
return kPRSuccess;
|
|
}
|
|
|
|
PRResult PRDevice::DriverUpdateState(PRDriverState *driverState)
|
|
{
|
|
const int burstWords = 3;
|
|
uint32_t burst[burstWords];
|
|
int32_t rc;
|
|
|
|
DEBUG(PRLog(kPRLogInfo, "Updating driver #%d\n", driverState->driverNum));
|
|
|
|
if (driverState->polarity != drivers[driverState->driverNum].polarity && machineType != kPRMachineCustom)
|
|
{
|
|
PRSetLastErrorText("Refusing to update driver #%d; polarity differs on non-custom machine.", driverState->driverNum);
|
|
return kPRFailure;
|
|
}
|
|
|
|
drivers[driverState->driverNum] = *driverState;
|
|
|
|
rc = CreateDriverUpdateBurst(burst, &drivers[driverState->driverNum]);
|
|
DEBUG(PRLog(kPRLogVerbose, "Words: %x %x %x\n", burst[0], burst[1], burst[2]));
|
|
|
|
return PrepareWriteData(burst, burstWords);
|
|
}
|
|
|
|
PRResult PRDevice::DriverLoadMachineTypeDefaults(PRMachineType machineType, uint32_t resetFlags)
|
|
{
|
|
int i;
|
|
PRResult res = kPRSuccess;
|
|
|
|
//const int WPCDriverLoopTime = 4; // milliseconds
|
|
//const int SternDriverLoopTime = 2; // milliseconds
|
|
|
|
const int mappedWPCDriverGroupEnableIndex[] = {0, 0, 0, 0, 0, 2, 4, 3, 1, 5, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
const int mappedSternDriverGroupEnableIndex[] = {0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9};
|
|
const int mappedWPCDriverGroupSlowTime[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 400, 400, 400, 400, 400, 400, 400, 400, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
const int mappedSternDriverGroupSlowTime[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, 0, 200, 0, 200, 0, 200, 0, 200, 0, 200, 0, 200, 0, 200};
|
|
const int mappedWPCDriverGroupActivateIndex[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
const int mappedSternDriverGroupActivateIndex[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7};
|
|
|
|
const int watchdogResetTime = 1000; // milliseconds
|
|
|
|
int mappedDriverGroupEnableIndex[kPRDriverGroupsMax];
|
|
int mappedDriverGroupSlowTime[kPRDriverGroupsMax];
|
|
int mappedDriverGroupActivateIndex[kPRDriverGroupsMax];
|
|
int rowEnableIndex1;
|
|
int rowEnableIndex0;
|
|
bool tickleSternWatchdog;
|
|
bool globalPolarity;
|
|
bool activeLowMatrixRows;
|
|
int driverLoopTime;
|
|
//int slowGroupTime;
|
|
int numMatrixGroups;
|
|
bool encodeEnables;
|
|
int rowEnableSelect;
|
|
|
|
switch (machineType)
|
|
{
|
|
case kPRMachineWPC:
|
|
{
|
|
memcpy(mappedDriverGroupEnableIndex,mappedWPCDriverGroupEnableIndex,
|
|
sizeof(mappedDriverGroupEnableIndex));
|
|
rowEnableIndex1 = 6; // Unused in WPC
|
|
rowEnableIndex0 = 6;
|
|
tickleSternWatchdog = false;
|
|
globalPolarity = false;
|
|
activeLowMatrixRows = true;
|
|
driverLoopTime = 4; // milliseconds
|
|
memcpy(mappedDriverGroupSlowTime,mappedWPCDriverGroupSlowTime,
|
|
sizeof(mappedDriverGroupSlowTime));
|
|
memcpy(mappedDriverGroupActivateIndex,mappedWPCDriverGroupActivateIndex,
|
|
sizeof(mappedDriverGroupActivateIndex));
|
|
numMatrixGroups = 8;
|
|
encodeEnables = false;
|
|
rowEnableSelect = 0;
|
|
break;
|
|
}
|
|
|
|
case kPRMachineStern:
|
|
{
|
|
memcpy(mappedDriverGroupEnableIndex,mappedSternDriverGroupEnableIndex,
|
|
sizeof(mappedDriverGroupEnableIndex));
|
|
rowEnableIndex1 = 6; // Unused in Stern
|
|
rowEnableIndex0 = 10;
|
|
tickleSternWatchdog = true;
|
|
globalPolarity = true;
|
|
activeLowMatrixRows = false;
|
|
driverLoopTime = 2; // milliseconds
|
|
memcpy(mappedDriverGroupSlowTime,mappedSternDriverGroupSlowTime,
|
|
sizeof(mappedDriverGroupSlowTime));
|
|
memcpy(mappedDriverGroupActivateIndex,mappedSternDriverGroupActivateIndex,
|
|
sizeof(mappedDriverGroupActivateIndex));
|
|
numMatrixGroups = 16;
|
|
encodeEnables = true;
|
|
rowEnableSelect = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
memset(&driverGlobalConfig, 0x00, sizeof(PRDriverGlobalConfig));
|
|
for (i = 0; i < kPRDriverCount; i++)
|
|
{
|
|
PRDriverState *driver = &drivers[i];
|
|
memset(driver, 0x00, sizeof(PRDriverState));
|
|
driver->driverNum = i;
|
|
driver->polarity = globalPolarity;
|
|
if (resetFlags & kPRResetFlagUpdateDevice)
|
|
res = DriverUpdateState(driver);
|
|
}
|
|
for (i = 0; i < kPRDriverGroupsMax; i++)
|
|
{
|
|
PRDriverGroupConfig *group = &driverGroups[i];
|
|
memset(group, 0x00, sizeof(PRDriverGroupConfig));
|
|
group->groupNum = i;
|
|
group->polarity = globalPolarity;
|
|
}
|
|
|
|
PRDriverGlobalConfig globals;
|
|
globals.enableOutputs = false;
|
|
globals.globalPolarity = globalPolarity;
|
|
globals.useClear = false;
|
|
globals.strobeStartSelect = false;
|
|
globals.startStrobeTime = driverLoopTime; // milliseconds per output loop
|
|
globals.matrixRowEnableIndex1 = rowEnableIndex1;
|
|
globals.matrixRowEnableIndex0 = rowEnableIndex0;
|
|
globals.activeLowMatrixRows = activeLowMatrixRows;
|
|
globals.tickleSternWatchdog = tickleSternWatchdog;
|
|
globals.encodeEnables = encodeEnables;
|
|
globals.watchdogExpired = false;
|
|
globals.watchdogEnable = true;
|
|
globals.watchdogResetTime = watchdogResetTime;
|
|
|
|
// 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:
|
|
|
|
// Enable now without the outputs enabled:
|
|
if (resetFlags & kPRResetFlagUpdateDevice)
|
|
res = DriverUpdateGlobalConfig(&globals);
|
|
else
|
|
driverGlobalConfig = globals;
|
|
|
|
// Now enable the outputs to protect against the polarity being driven incorrectly:
|
|
globals.enableOutputs = true;
|
|
if (resetFlags & kPRResetFlagUpdateDevice)
|
|
res = DriverUpdateGlobalConfig(&globals);
|
|
else
|
|
driverGlobalConfig = globals;
|
|
|
|
// Configure the groups. Each group corresponds to 8 consecutive drivers, starting
|
|
// with driver #32. The following 6 groups are configured for coils/flashlamps.
|
|
|
|
PRDriverGroupConfig group;
|
|
for (i = 4; i < 10; i++)
|
|
{
|
|
DriverGetGroupConfig(i, &group);
|
|
group.slowTime = 0;
|
|
group.enableIndex = mappedDriverGroupEnableIndex[i];
|
|
group.rowActivateIndex = 0;
|
|
group.rowEnableSelect = 0;
|
|
group.matrixed = false;
|
|
group.polarity = globalPolarity;
|
|
group.active = 1;
|
|
group.disableStrobeAfter = false;
|
|
|
|
if (resetFlags & kPRResetFlagUpdateDevice)
|
|
res = DriverUpdateGroupConfig(&group);
|
|
else
|
|
driverGroups[i] = group;
|
|
}
|
|
|
|
// The following 8 groups are configured for the feature lamp matrix.
|
|
for (i = 10; i < 10 + numMatrixGroups; i++) {
|
|
DriverGetGroupConfig(i, &group);
|
|
group.slowTime = mappedDriverGroupSlowTime[i];
|
|
group.enableIndex = mappedDriverGroupEnableIndex[i];
|
|
group.rowActivateIndex = mappedDriverGroupActivateIndex[i];
|
|
group.rowEnableSelect = rowEnableSelect;
|
|
group.matrixed = 1;
|
|
group.polarity = globalPolarity;
|
|
group.active = 1;
|
|
group.disableStrobeAfter = mappedDriverGroupSlowTime[i] != 0;
|
|
|
|
if (resetFlags & kPRResetFlagUpdateDevice)
|
|
res = DriverUpdateGroupConfig(&group);
|
|
else
|
|
driverGroups[i] = group;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
PRResult PRDevice::DriverWatchdogTickle()
|
|
{
|
|
const int burstWords = 2;
|
|
uint32_t burst[burstWords];
|
|
int32_t rc;
|
|
|
|
rc = CreateWatchdogConfigBurst(burst, driverGlobalConfig.watchdogExpired,
|
|
driverGlobalConfig.watchdogEnable,
|
|
driverGlobalConfig.watchdogResetTime);
|
|
|
|
return PrepareWriteData(burst, burstWords);
|
|
}
|
|
|
|
|
|
|
|
PRSwitchRuleInternal *PRDevice::GetSwitchRuleByIndex(uint16_t index)
|
|
{
|
|
return &switchRules[index];
|
|
}
|
|
|
|
PRResult PRDevice::SwitchUpdateConfig(PRSwitchConfig *switchConfig)
|
|
{
|
|
uint32_t rc;
|
|
const int burstWords = 2;
|
|
uint32_t burst[burstWords];
|
|
|
|
this->switchConfig = *switchConfig;
|
|
CreateSwitchUpdateConfigBurst(burst, switchConfig);
|
|
|
|
DEBUG(PRLog(kPRLogInfo, "Configuring Switch Logic"));
|
|
DEBUG(PRLog(kPRLogVerbose, "Words: %x %x\n",burst[0],burst[1]));
|
|
|
|
rc = PrepareWriteData(burst, burstWords);
|
|
return rc;
|
|
}
|
|
|
|
PRResult PRDevice::SwitchUpdateRule(uint8_t switchNum, PREventType eventType, PRSwitchRule *rule, PRDriverState *linkedDrivers, int numDrivers)
|
|
{
|
|
// Updates a single rule with the associated linked driver state changes.
|
|
const int burstSize = 4;
|
|
uint32_t burst[burstSize];
|
|
|
|
if (switchNum > kPRSwitchPhysicalLast) // Always true due to data type.
|
|
{
|
|
PRSetLastErrorText("Switch rule out of range 0-%d", kPRSwitchPhysicalLast);
|
|
return kPRFailure;
|
|
}
|
|
|
|
// If more the base rule will link to others, ensure free indexes exists for
|
|
// the links.
|
|
if (numDrivers > 0 && freeSwitchRuleIndexes.size() < numDrivers-1) // -1 because the first switch rule holds the first driver.
|
|
{
|
|
PRSetLastErrorText("Not enough free switch rule indexes: %d available, need %d", freeSwitchRuleIndexes.size(), numDrivers);
|
|
return kPRFailure;
|
|
}
|
|
|
|
PRResult res = kPRSuccess;
|
|
uint32_t newRuleIndex = CreateSwitchRuleIndex(switchNum, eventType);
|
|
|
|
// Because we're redefining the rule chain, we need to remove all previously existing links and return the indexes to the free list.
|
|
PRSwitchRuleInternal *oldRule = GetSwitchRuleByIndex(newRuleIndex);
|
|
while (oldRule->linkActive)
|
|
{
|
|
oldRule = GetSwitchRuleByIndex(oldRule->linkIndex);
|
|
freeSwitchRuleIndexes.push(oldRule->linkIndex);
|
|
}
|
|
|
|
// Now let's setup the first actual rule:
|
|
uint16_t firstRuleIndex = newRuleIndex;
|
|
PRSwitchRuleInternal *newRule = GetSwitchRuleByIndex(newRuleIndex);
|
|
if (newRule->eventType != eventType)
|
|
DEBUG(PRLog(kPRLogWarning, "Unexpected state: switch rule at 0x%x has event type 0x%x (expected 0x%x).\n", newRuleIndex, newRule->eventType, eventType));
|
|
newRule->notifyHost = rule->notifyHost;
|
|
newRule->changeOutput = false;
|
|
newRule->linkActive = false;
|
|
|
|
// Process each driver who's state should change in response to the switch event.
|
|
if (numDrivers > 0)
|
|
{
|
|
while (numDrivers > 0)
|
|
{
|
|
newRule->changeOutput = true;
|
|
newRule->driver = linkedDrivers[0];
|
|
|
|
if (numDrivers > 1)
|
|
{
|
|
newRule->linkActive = true;
|
|
newRule->linkIndex = freeSwitchRuleIndexes.front();
|
|
freeSwitchRuleIndexes.pop();
|
|
|
|
CreateSwitchUpdateRulesBurst(burst, newRule);
|
|
|
|
// Prepare for the next rule:
|
|
newRule = GetSwitchRuleByIndex(newRule->linkIndex);
|
|
}
|
|
else
|
|
{
|
|
newRule->linkActive = false;
|
|
CreateSwitchUpdateRulesBurst(burst, newRule);
|
|
}
|
|
|
|
DEBUG(PRLog(kPRLogVerbose, "Rule Words: %x %x %x %x\n", burst[0],burst[1],burst[2],burst[3]));
|
|
// Write the rule:
|
|
res = PrepareWriteData(burst, burstSize);
|
|
if (res != kPRSuccess)
|
|
{
|
|
DEBUG(PRLog(kPRLogError, "Error while writing switch update, attempting to revert switch rule to a safe state..."));
|
|
newRule = GetSwitchRuleByIndex(firstRuleIndex);
|
|
newRule->changeOutput = false;
|
|
newRule->linkActive = false;
|
|
CreateSwitchUpdateRulesBurst(burst, newRule);
|
|
if (PrepareWriteData(burst, burstSize) == kPRSuccess)
|
|
DEBUG(PRLog(kPRLogError, "Disabled successfully.\n"));
|
|
else
|
|
DEBUG(PRLog(kPRLogError, "Failed to disable.\n"));
|
|
return res;
|
|
}
|
|
|
|
linkedDrivers++;
|
|
numDrivers--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CreateSwitchUpdateRulesBurst(burst, newRule);
|
|
DEBUG(PRLog(kPRLogVerbose, "Rule Words: %x %x %x %x\n", burst[0],burst[1],burst[2],burst[3]));
|
|
|
|
// Write the rule:
|
|
res = PrepareWriteData(burst, burstSize);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
PRResult PRDevice::SwitchGetStates( PREventType * switchStates, uint16_t numSwitches )
|
|
{
|
|
uint32_t rc;
|
|
uint32_t stateWord, debounceWord;
|
|
uint8_t i, j;
|
|
PREventType eventType;
|
|
|
|
// Request one state word and one debounce word at a time. Could make more efficient
|
|
// use of the USB bus by requesting a burst of state words and then a burst of debounce
|
|
// words, but doing one word at a time makes it easier to process each switch when the
|
|
// data returns. Also, this function shouldn't be called during timing sensitive
|
|
// situations; so the inefficiencies are acceptable.
|
|
for (i = 0; i < numSwitches / 32; i++)
|
|
{
|
|
rc = RequestData(P_ROC_BUS_SWITCH_CTRL_SELECT,
|
|
P_ROC_SWITCH_CTRL_STATE_BASE_ADDR + i, 1);
|
|
rc = RequestData(P_ROC_BUS_SWITCH_CTRL_SELECT,
|
|
P_ROC_SWITCH_CTRL_DEBOUNCE_BASE_ADDR + i, 1);
|
|
}
|
|
|
|
// Expect 4 words for each 32 switches. The state and debounce words,
|
|
// and the address words for both.
|
|
uint16_t numWords = 4 * (numSwitches / 32);
|
|
|
|
i = 0; // Reset i so it can be used to prevent an infinite loop below
|
|
|
|
// Wait for data to return. Give it 10 loops before giving up.
|
|
while (requestedDataQueue.size() < numWords && i++ < 10)
|
|
{
|
|
PRSleep (10); // 10 milliseconds should be plenty of time.
|
|
SortReturningData();
|
|
}
|
|
|
|
// Make sure all of the requested words are available before processing them.
|
|
// Too many words is just as bad as not enough words.
|
|
// If too many come back, can they be trusted?
|
|
if (requestedDataQueue.size() == numWords)
|
|
{
|
|
// Process the returning words.
|
|
for (i = 0; i < numSwitches / 32; i++)
|
|
{
|
|
requestedDataQueue.pop(); // Ignore address word. TODO: Verify this address word.
|
|
stateWord = requestedDataQueue.front(); // This is the switch state word.
|
|
requestedDataQueue.pop();
|
|
requestedDataQueue.pop(); // Ignore address word. TODO: Verify this address word.
|
|
debounceWord = requestedDataQueue.front(); // This is the debounce word.
|
|
requestedDataQueue.pop();
|
|
|
|
// Loop through each bit of the words, combining them into an eventType
|
|
for (j = 0; j < 32; j++)
|
|
{
|
|
// Only process the number of switches requested via numSwitches
|
|
if ((i * 32) + j < numSwitches)
|
|
{
|
|
if (stateWord >> j & 1)
|
|
if (debounceWord >> j & 1) eventType = kPREventTypeSwitchOpenDebounced;
|
|
else eventType = kPREventTypeSwitchOpenNondebounced;
|
|
else if (debounceWord >> j & 1) eventType = kPREventTypeSwitchClosedDebounced;
|
|
else eventType = kPREventTypeSwitchClosedNondebounced;
|
|
switchStates[(i * 32) + j] = eventType;
|
|
}
|
|
}
|
|
}
|
|
return kPRSuccess;
|
|
}
|
|
else return kPRFailure;
|
|
}
|
|
|
|
int32_t PRDevice::DMDUpdateConfig(PRDMDConfig *dmdConfig)
|
|
{
|
|
uint32_t rc;
|
|
const int burstWords = 7;
|
|
uint32_t burst[burstWords];
|
|
|
|
this->dmdConfig = *dmdConfig;
|
|
CreateDMDUpdateConfigBurst(burst, dmdConfig);
|
|
|
|
DEBUG(PRLog(kPRLogInfo, "Configuring DMD"));
|
|
DEBUG(PRLog(kPRLogVerbose, "Words: %x %x %x %x %x %x %x\n",burst[0],burst[1],burst[2],burst[3],
|
|
burst[4],burst[5],burst[6]));
|
|
|
|
rc = PrepareWriteData(burst, burstWords);
|
|
return rc;
|
|
}
|
|
|
|
|
|
PRResult PRDevice::DMDDraw(uint8_t * dots)
|
|
{
|
|
int32_t k; //i,x,y,j,k,m;
|
|
//uint8_t color;
|
|
uint16_t words_per_sub_frame = (dmdConfig.numColumns*dmdConfig.numRows) / 32;
|
|
uint16_t words_per_frame = words_per_sub_frame * dmdConfig.numSubFrames;
|
|
uint32_t dmd_command_buffer[1024];
|
|
uint32_t * p_dmd_frame_buffer_words;
|
|
|
|
p_dmd_frame_buffer_words = (uint32_t *)dots;
|
|
|
|
dmd_command_buffer[0] = CreateBurstCommand(P_ROC_BUS_DMD_SELECT, P_ROC_DMD_DOT_TABLE_BASE_ADDR, words_per_frame);
|
|
for (k=0; k<words_per_frame; k++) {
|
|
dmd_command_buffer[k+1] = p_dmd_frame_buffer_words[k];
|
|
}
|
|
|
|
return PrepareWriteData(dmd_command_buffer, words_per_frame+1);
|
|
|
|
// The following code prints out the init lines for the 4 Xilinx BlockRAMs
|
|
// in the FPGA. It's used to make an image for the P-ROC to display on power-up.
|
|
//if (print_dots) {
|
|
//print_dots = false;
|
|
|
|
//for (i=0; i<4; i++) {
|
|
// std::cout << "For memory: "<< i << "\n";
|
|
// // Need 4 lines to get 1 frame (4*256*4 = 4096)
|
|
// // The rest will be all 0.
|
|
// for (y=0; y<4; y++) {
|
|
// std::cout << "defparam blockram.INIT_00 = 256'b";
|
|
// for (j=31; j>=0; j--) {
|
|
// for (x=7; x>=0; x--) {
|
|
// std::cout << ((dmd_frame_buffer[(y*32)+j] >> ((i*8)+x)) & 1);
|
|
// }
|
|
// }
|
|
// std::cout << ";\n";
|
|
// }
|
|
// std::cout << "\n\n\n";
|
|
//}
|
|
//}
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Device I/O
|
|
|
|
PRResult PRDevice::Open()
|
|
{
|
|
PRResult res = PRHardwareOpen();
|
|
if (res == kPRSuccess)
|
|
{
|
|
// Try to verify the P-ROC IS in the FPGA before initializing the FPGA's FTDI interface
|
|
// just in case it was already initialized from a previous application execution.
|
|
DEBUG(PRLog(kPRLogInfo, "Verifying P-ROC ID: \n"));
|
|
if (VerifyChipID() == kPRFailure) {
|
|
// Since the FPGA didn't appear to be responding properly, send the FPGA's FTDI
|
|
// initialization sequence. This is a set of bytes the FPGA is waiting to receive
|
|
// before it allows access deeper into the chip. This keeps garbage from getting
|
|
// in and wreaking havoc before software is up and running.
|
|
DEBUG(PRLog(kPRLogInfo, "Initializing P-ROC...\n"));
|
|
res = FlushReadBuffer();
|
|
uint32_t temp_word = P_ROC_INIT_PATTERN_A;
|
|
res = WriteData(&temp_word, 1);
|
|
temp_word = P_ROC_INIT_PATTERN_B;
|
|
res = WriteData(&temp_word, 1);
|
|
res = VerifyChipID();
|
|
if (res == kPRFailure)
|
|
DEBUG(PRLog(kPRLogWarning, "Unable to read Chip ID - P-ROC could not be initialized.\n"));
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
PRResult PRDevice::Close()
|
|
{
|
|
// TODO: Add protection against closing a not-open ftdic.
|
|
PRHardwareClose();
|
|
return kPRSuccess;
|
|
}
|
|
|
|
PRResult PRDevice::VerifyChipID()
|
|
{
|
|
PRResult rc;
|
|
const int bufferWords = 5;
|
|
uint32_t buffer[bufferWords];
|
|
//uint32_t temp_word;
|
|
uint32_t max_count;
|
|
|
|
//std::cout << "Requesting FPGA Chip ID: ";
|
|
rc = RequestData(P_ROC_MANAGER_SELECT, P_ROC_REG_CHIP_ID_ADDR, 4);
|
|
|
|
max_count = 0;
|
|
//std::cout << "Waiting for read data ";
|
|
while (num_collected_bytes < (bufferWords*4) && max_count < 10) {
|
|
PRSleep(10);
|
|
//std::cout << ". ";
|
|
rc = CollectReadData();
|
|
max_count++;
|
|
}
|
|
//std::cout << "\n";
|
|
|
|
if (max_count != 10) {
|
|
int wordsRead = ReadData(buffer, bufferWords);
|
|
|
|
if (wordsRead == 5) {
|
|
//std::cout << rc << " words read. \n"
|
|
DEBUG(PRLog(kPRLogInfo, "FPGA Chip ID: 0x%x\n", buffer[1]));
|
|
DEBUG(PRLog(kPRLogInfo, "FPGA Chip Version/Rev: %d.%d\n", buffer[2] >> 16, buffer[2] & 0xffff));
|
|
DEBUG(PRLog(kPRLogInfo, "Watchdog Settings: 0x%x\n", buffer[3]));
|
|
DEBUG(PRLog(kPRLogInfo, "Switches: 0x%x\n", buffer[4]));
|
|
rc = kPRSuccess;
|
|
}
|
|
else {
|
|
DEBUG(PRLog(kPRLogError, "Error reading Chip IP and Version. Incorrect number of bytes received from read_data().\n"));
|
|
rc = kPRFailure;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Return failure without logging; calling function must log.
|
|
rc = kPRFailure;
|
|
}
|
|
return (rc);
|
|
}
|
|
|
|
PRResult PRDevice::RequestData(uint32_t module_select, uint32_t start_addr, int32_t num_words)
|
|
{
|
|
uint32_t requestWord = CreateRegRequestWord(module_select, start_addr, num_words);
|
|
return WriteData(&requestWord, 1);
|
|
}
|
|
|
|
PRResult PRDevice::PrepareWriteData(uint32_t * words, int32_t numWords)
|
|
{
|
|
if (numWords > maxWriteWords)
|
|
{
|
|
PRSetLastErrorText("%d words Exceeds write capabilities. Restrict write requests to %d words.", numWords, maxWriteWords);
|
|
return kPRFailure;
|
|
}
|
|
|
|
// If there are already some words prepared to be written and the addition of the new
|
|
// words will be too many, flush the currently prepared words to the P-ROC now.
|
|
if (numPreparedWriteWords + numWords > maxWriteWords)
|
|
{
|
|
if (FlushWriteData() == kPRFailure);
|
|
return kPRFailure;
|
|
}
|
|
|
|
memcpy(preparedWriteWords + numPreparedWriteWords, words, numWords * 4);
|
|
numPreparedWriteWords += numWords;
|
|
|
|
return kPRSuccess;
|
|
}
|
|
|
|
PRResult PRDevice::FlushWriteData()
|
|
{
|
|
PRResult res;
|
|
res = WriteData(preparedWriteWords, numPreparedWriteWords);
|
|
numPreparedWriteWords = 0; // Reset word counter
|
|
return res;
|
|
}
|
|
|
|
PRResult PRDevice::WriteData(uint32_t * words, int32_t numWords)
|
|
{
|
|
int32_t j,k;
|
|
// int32_t item;
|
|
|
|
if (numWords == 0)
|
|
return kPRSuccess;
|
|
|
|
// The 32-bit words coming in are in the same byte order they need to be in the P-ROC.
|
|
// However, due to Intel endian-ness, simply casting the words to 4 bytes changes the
|
|
// byte order. So, the conversion to bytes is done here manually to preserve the byte
|
|
// order. Might want to add a parameter for endian-ness at some point to make it
|
|
// work on big endian architectures.
|
|
for (j = 0; j < numWords; j++) {
|
|
uint32_t temp_word = words[j];
|
|
for (k = 3; k >= 0; k--)
|
|
{
|
|
wr_buffer[(j*4)+k] = (uint8_t)(temp_word & 0x000000ff);
|
|
temp_word = temp_word >> 8;
|
|
}
|
|
// for (k=0; k<4; k++)
|
|
// {
|
|
// item = wr_buffer[(j*4)+k];
|
|
// }
|
|
}
|
|
|
|
int bytesToWrite = numWords * 4;
|
|
int bytesWritten = PRHardwareWrite(wr_buffer, bytesToWrite);
|
|
|
|
if (bytesWritten != bytesToWrite)
|
|
{
|
|
PRSetLastErrorText("Error in WriteData: wrote %d of %d bytes", bytesWritten, bytesToWrite);
|
|
return kPRFailure;
|
|
}
|
|
else
|
|
{
|
|
return kPRSuccess;
|
|
}
|
|
}
|
|
|
|
PRResult PRDevice::WriteDataRaw(uint32_t moduleSelect, uint32_t startingAddr, int32_t numWriteWords, uint32_t * writeBuffer)
|
|
{
|
|
uint32_t * buffer;
|
|
|
|
buffer = (uint32_t *)malloc((numWriteWords * 4) + 1);
|
|
buffer[0] = CreateBurstCommand(moduleSelect, startingAddr, numWriteWords);
|
|
memcpy(buffer+1, writeBuffer, numWriteWords * 4);
|
|
WriteData(buffer, numWriteWords + 1);
|
|
free (buffer);
|
|
}
|
|
|
|
PRResult PRDevice::ReadDataRaw(uint32_t moduleSelect, uint32_t startingAddr, int32_t numReadWords, uint32_t * readBuffer)
|
|
{
|
|
uint32_t rc;
|
|
uint8_t i;
|
|
|
|
// Send out the request.
|
|
rc = RequestData(moduleSelect, startingAddr, numReadWords);
|
|
|
|
i = 0; // Reset i so it can be used to prevent an infinite loop below
|
|
|
|
// Wait for data to return. Give it 10 loops before giving up.
|
|
// Expect numReadWords + 1 word with the address.
|
|
while (requestedDataQueue.size() < (numReadWords + 1) && i++ < 10)
|
|
{
|
|
PRSleep (10); // 10 milliseconds should be plenty of time.
|
|
SortReturningData();
|
|
}
|
|
|
|
// Make sure all of the requested words are available before processing them.
|
|
// Too many words is just as bad as not enough words.
|
|
// If too many come back, can they be trusted?
|
|
if (requestedDataQueue.size() == numReadWords + 1)
|
|
{
|
|
requestedDataQueue.pop(); // Ignore address word. TODO: Verify the address.
|
|
for (i = 0; i < numReadWords; i++)
|
|
{
|
|
readBuffer[i] = requestedDataQueue.front();
|
|
requestedDataQueue.pop();
|
|
}
|
|
return kPRSuccess;
|
|
}
|
|
else return kPRFailure;
|
|
}
|
|
|
|
|
|
int32_t PRDevice::ReadData(uint32_t *buffer, int32_t num_words)
|
|
{
|
|
int32_t rc,i,j;
|
|
|
|
// Just like in the write_data method, the bytes are ordered here manually to put
|
|
// them in the right order. They are pulled from the collected_bytes_fifo 1 at a time
|
|
// and stuffed into 32-bit words, high byte to low byte.
|
|
if ((num_words * 4) <= num_collected_bytes) {
|
|
for (j=0; j<num_words; j++) {
|
|
// Initialize buffer position
|
|
buffer[j] = 0;
|
|
for (i=0; i<4; i++) {
|
|
buffer[j] = (collected_bytes_fifo[collected_bytes_rd_addr] << (24-(i*8))) |
|
|
buffer[j];
|
|
if (collected_bytes_rd_addr == (FTDI_BUFFER_SIZE-1))
|
|
collected_bytes_rd_addr = 0;
|
|
else
|
|
collected_bytes_rd_addr++;
|
|
}
|
|
}
|
|
num_collected_bytes -= (num_words * 4);
|
|
|
|
rc = num_words;
|
|
}
|
|
else {
|
|
rc = 0;
|
|
}
|
|
DEBUG(PRLog(kPRLogVerbose, "Read num bytes: %d\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
PRResult PRDevice::FlushReadBuffer()
|
|
{
|
|
int32_t numBytes,rc,k;
|
|
uint32_t rd_buffer[3];
|
|
numBytes = CollectReadData();
|
|
k = 0;
|
|
//std::cout << "Flushing rd buffer of " << num_words << "words\n";
|
|
while (k < numBytes) {
|
|
rc = ReadData(rd_buffer, 1);
|
|
k++;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int32_t PRDevice::CollectReadData()
|
|
{
|
|
int32_t rc,i;
|
|
rc = PRHardwareRead(collect_buffer, FTDI_BUFFER_SIZE-num_collected_bytes);
|
|
for (i=0; i<rc; i++) {
|
|
collected_bytes_fifo[collected_bytes_wr_addr] = collect_buffer[i];
|
|
if (collected_bytes_wr_addr == (FTDI_BUFFER_SIZE-1))
|
|
collected_bytes_wr_addr = 0;
|
|
else
|
|
collected_bytes_wr_addr++;
|
|
}
|
|
num_collected_bytes += rc;
|
|
if (rc > 0)
|
|
{
|
|
DEBUG(PRLog(kPRLogVerbose, "Collected bytes: %d\n", rc));
|
|
}
|
|
return (rc);
|
|
}
|
|
|
|
PRResult PRDevice::SortReturningData()
|
|
{
|
|
uint32_t num_bytes, num_words, rc;
|
|
uint32_t rd_buffer[512];
|
|
|
|
num_bytes = CollectReadData();
|
|
num_words = num_collected_bytes/4;
|
|
|
|
while (num_words >= 2) {
|
|
rc = ReadData(rd_buffer, 1);
|
|
DEBUG(PRLog(kPRLogVerbose, "New returning word: 0x%x\n", rd_buffer[0]));
|
|
|
|
switch ( (rd_buffer[0] & P_ROC_COMMAND_MASK) >> P_ROC_COMMAND_SHIFT)
|
|
{
|
|
case P_ROC_REQUESTED_DATA: {
|
|
// Push the address word so it can be used to identify the subsequent data.
|
|
requestedDataQueue.push(rd_buffer[0]);
|
|
int wordsRead = ReadData(rd_buffer,
|
|
(rd_buffer[0] & P_ROC_HEADER_LENGTH_MASK) >>
|
|
P_ROC_HEADER_LENGTH_SHIFT);
|
|
for (int i = 0; i < wordsRead; i++)
|
|
{
|
|
DEBUG(PRLog(kPRLogVerbose, "Pushing onto unreq Q 0x%x\n", rd_buffer[i]));
|
|
requestedDataQueue.push(rd_buffer[i]);
|
|
}
|
|
break;
|
|
}
|
|
case P_ROC_UNREQUESTED_DATA: {
|
|
ReadData(rd_buffer,1);
|
|
DEBUG(PRLog(kPRLogVerbose, "Pushing onto unreq Q 0x%x\n", rd_buffer[0]));
|
|
unrequestedDataQueue.push(rd_buffer[0]);
|
|
break;
|
|
}
|
|
}
|
|
num_words = num_collected_bytes/4;
|
|
}
|
|
return kPRSuccess;
|
|
}
|