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

Split out pinproctest into module-related files.

Browse Source
This commit is contained in:
Adam Preble
2009-05-30 16:43:15 -04:00
parent 61b791af8a
commit 301f3aa26b
7 changed files with 445 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

313
examples/pinproctest/pinproctest.cpp
View File

@@ -1,5 +1,4 @@
/*
* The MIT License
* Copyright (c) 2009 Gerry Stellenberg, Adam Preble
*
* Permission is hereby granted, free of charge, to any person
@@ -27,28 +26,8 @@
* pinproctest.cpp
* libpinproc
*/
#include <string.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <cmath>
#include "../../include/pinproc.h" // Include libpinproc's header.
#include <fstream>
#include <yaml-cpp/yaml.h>
#include <sys/time.h>
#include "pinproctest.h"
#define kFlippersSection "PRFlippers"
#define kBumpersSection "PRBumpers"
#define kCoilsSection "PRCoils"
#define kSwitchesSection "PRSwitches"
#define kNumberField "number"
#define kFlipperPulseTime (34) // 34 ms
#define kBumperPulseTime (25) // 25 ms
#define kDMDColumns (128)
#define kDMDRows (32)
#define kDMDSubFrames (4) // For color depth of 16
/** Demonstration of the custom logging callback. */
void TestLogger(PRLogLevel level, const char *text)
@@ -91,296 +70,6 @@ PRResult LoadConfiguration(YAML::Node& yamlDoc, const char *yamlFilePath)
return kPRSuccess;
}
void ConfigureDrivers(PRHandle proc, PRMachineType machineType, YAML::Node& yamlDoc)
{
int i;
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;
}
}
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:
PRDriverUpdateGlobalConfig(proc, &globals);
// Now enable the outputs: (TODO: Why?)
globals.enableOutputs = true;
PRDriverUpdateGlobalConfig(proc, &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++)
{
PRDriverGetGroupConfig(proc, 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;
PRDriverUpdateGroupConfig(proc, &group);
}
// The following 8 groups are configured for the feature lamp matrix.
for (i = 10; i < 10 + numMatrixGroups; i++) {
PRDriverGetGroupConfig(proc, 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;
PRDriverUpdateGroupConfig(proc, &group);
}
}
void ConfigureSwitches(PRHandle proc, YAML::Node& yamlDoc)
{
// Configure switch controller registers (if the defaults aren't acceptable)
PRSwitchConfig switchConfig;
switchConfig.clear = false;
switchConfig.directMatrixScanLoopTime = 2; // milliseconds
switchConfig.pulsesBeforeCheckingRX = 10;
switchConfig.inactivePulsesAfterBurst = 12;
switchConfig.pulsesPerBurst = 6;
switchConfig.pulseHalfPeriodTime = 13; // milliseconds
PRSwitchUpdateConfig(proc, &switchConfig);
}
void ConfigureWPCFlipperSwitchRule (PRHandle proc, int swNum, int mainCoilNum, int holdCoilNum, int pulseTime)
{
const int numDriverRules = 2;
PRDriverState drivers[numDriverRules];
PRSwitchRule sw;
// Flipper on rules
PRDriverGetState(proc, mainCoilNum, &drivers[0]);
PRDriverStatePulse(&drivers[0],pulseTime); // Pulse coil for 34ms.
PRDriverGetState(proc, holdCoilNum, &drivers[1]);
PRDriverStatePulse(&drivers[1],0); // Turn on indefintely (set pulse for 0ms)
sw.notifyHost = false;
PRSwitchUpdateRule(proc, swNum, kPREventTypeSwitchClosedNondebounced, &sw, drivers, numDriverRules);
sw.notifyHost = true;
PRSwitchUpdateRule(proc, swNum, kPREventTypeSwitchClosedDebounced, &sw, NULL, 0);
// Flipper off rules
PRDriverGetState(proc, mainCoilNum, &drivers[0]);
PRDriverStateDisable(&drivers[0]); // Disable main coil
PRDriverGetState(proc, holdCoilNum, &drivers[1]);
PRDriverStateDisable(&drivers[1]); // Disable hold coil
sw.notifyHost = false;
PRSwitchUpdateRule(proc, swNum, kPREventTypeSwitchOpenNondebounced, &sw, drivers, numDriverRules);
sw.notifyHost = true;
PRSwitchUpdateRule(proc, swNum, kPREventTypeSwitchOpenDebounced, &sw, NULL, 0);
}
void ConfigureBumperRule (PRHandle proc, int swNum, int coilNum, int pulseTime)
{
const int numDriverRules = 1;
PRDriverState drivers[numDriverRules];
PRSwitchRule sw;
// Lower Right Flipper On
PRDriverGetState(proc, coilNum, &drivers[0]);
PRDriverStatePulse(&drivers[0],pulseTime); // Pulse coil for 34ms.
sw.notifyHost = false;
PRSwitchUpdateRule(proc, swNum, kPREventTypeSwitchClosedNondebounced, &sw, drivers, numDriverRules);
sw.notifyHost = true;
PRSwitchUpdateRule(proc, swNum, kPREventTypeSwitchClosedDebounced, &sw, NULL, 0);
}
void ConfigureSwitchRules(PRHandle proc, YAML::Node& yamlDoc)
{
// WPC Flippers
const YAML::Node& flippers = yamlDoc[kFlippersSection];
for (YAML::Iterator flippersIt = flippers.begin(); flippersIt != flippers.end(); ++flippersIt)
{
int swNum, coilMain, coilHold;
std::string flipperName;
*flippersIt >> flipperName;
yamlDoc[kSwitchesSection][flipperName][kNumberField] >> swNum;
yamlDoc[kCoilsSection][flipperName + "Main"][kNumberField] >> coilMain;
yamlDoc[kCoilsSection][flipperName + "Hold"][kNumberField] >> coilHold;
ConfigureWPCFlipperSwitchRule (proc, swNum, coilMain, coilHold, kFlipperPulseTime);
}
const YAML::Node& bumpers = yamlDoc[kBumpersSection];
for (YAML::Iterator bumpersIt = bumpers.begin(); bumpersIt != bumpers.end(); ++bumpersIt)
{
int swNum, coilNum;
// WPC Slingshots
std::string bumperName;
*bumpersIt >> bumperName;
yamlDoc[kSwitchesSection][bumperName][kNumberField] >> swNum;
yamlDoc[kCoilsSection][bumperName][kNumberField] >> coilNum;
ConfigureBumperRule (proc, swNum, coilNum, kBumperPulseTime);
}
}
void ConfigureDMD(PRHandle proc)
{
int i;
// Create the structure that holds the DMD settings
PRDMDConfig dmdConfig;
memset(&dmdConfig, 0x0, sizeof(dmdConfig));
dmdConfig.numRows = kDMDRows;
dmdConfig.numColumns = kDMDColumns;
dmdConfig.numSubFrames = kDMDSubFrames;
for (i = 0; i < kDMDSubFrames; i++)
{
dmdConfig.rclkLowCycles[i] = 15;
dmdConfig.latchHighCycles[i] = 15;
dmdConfig.dotclkHalfPeriod[i] = 1;
}
dmdConfig.deHighCycles[0] = 250;
dmdConfig.deHighCycles[1] = 400;
dmdConfig.deHighCycles[2] = 180;
dmdConfig.deHighCycles[3] = 800;
PRDMDUpdateConfig(proc, &dmdConfig);
}
// Display a simple pattern to verify DMD functionality.
// 16 diagonal lines will rotate to the right. Every two rows will get brighter,
// starting with dim dots at the top.
void UpdateDots( unsigned char * dots, unsigned int dotOffset )
{
int row,col,subFrame,color,mappedColor,loopCtr,byte_shifter;
const int rate_reduction_divisor = 1;
loopCtr = dotOffset/rate_reduction_divisor;
color = pow(2,kDMDSubFrames) - 1;
byte_shifter = 0x80;
// Slow it down just a tad
if (dotOffset%rate_reduction_divisor == 0)
{
// Set up byte_shifter to rotate pattern to the right.
byte_shifter = pow(2,(loopCtr%8));
// Clear the DMD dots every time the rotation occurs
memset(dots,0,((kDMDColumns*kDMDRows)/8)*kDMDSubFrames);
// Loop through all of the rows
for (row = kDMDRows - 1; row >= 0; row--)
{
// Map the color index to the DMD's physical color map
int mappedColors[] = {0, 2, 8, 10, 1, 3, 9, 11, 4, 6, 12, 14, 5, 7, 13, 15};
mappedColor = mappedColors[color];
// Loop through each of 16 bytes in a row
for (col = 0; col < kDMDColumns / 8; col++)
{
// Loop through each subframe
for (subFrame = 0; subFrame < kDMDSubFrames; subFrame++)
{
// Turn on the byte in each sub-frame that's enabled
// active for the color code.
if ((mappedColor >> subFrame) & 1 == 1)
dots[subFrame*(kDMDColumns*kDMDRows/8)+((row%kDMDRows)*(kDMDColumns / 8))+col] = byte_shifter;
}
}
// Determine where to change the color in order to progress from row 0 = color 0
// to the last row being the last color.
if (row % (int)((kDMDRows/pow(2,kDMDSubFrames))) == 0) color--;
if (byte_shifter == 1) byte_shifter = 0x80;
else byte_shifter = byte_shifter >> 1;
}
}
}
time_t startTime;
bool runLoopRun = true;