libpinproc/examples/pinproctest/pinproctest.cpp

/*
 * 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.
 */
/*
 *  pinproctest.cpp
 *  libpinproc
 */
#include <string.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include "pinproc.h" // Include libpinproc's header.

/** Demonstration of the custom logging callback. */
void TestLogger(const char *text)
{
    fprintf(stderr, "TEST: %s", text);
}

void ConfigureDrivers(PRHandle proc)
{
    int i;

    PRDriverGlobalConfig globals;
    globals.enableOutputs = false;
    globals.globalPolarity = false;
    globals.useClear = false;
    globals.strobeStartSelect = false;
    globals.startStrobeTime = 4; // milliseconds per output loop
    globals.matrixRowEnableIndex1 = 12;
    globals.matrixRowEnableIndex0 = 6;
    globals.activeLowMatrixRows = true;
    globals.tickleWatchdog = false;
    globals.encodeEnables = false;

    // 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:

    PRDriverGroupConfig group;
    for (i = 0; i < 6; i++)
    {
        PRDriverGetGroupConfig(proc, i + 4, &group);
        group.slowTime = 0;
        group.enableIndex = i;
        group.rowActivateIndex = i;
        group.rowEnableSelect = 0;
        group.matrixed = false;
        group.polarity = false;
        group.active = 1;
        group.disableStrobeAfter = false;

        PRDriverUpdateGroupConfig(proc, &group);
    }

    for (i = 6; i < 14; i++) {
        PRDriverGetGroupConfig(proc, i + 4, &group);
        group.slowTime = 400;
        group.enableIndex = 7;
        group.rowActivateIndex = i - 6;
        group.rowEnableSelect = 0;
        group.matrixed = 1;
        group.polarity = 0;
        group.active = 1;
        group.disableStrobeAfter = 1;
        PRDriverUpdateGroupConfig(proc, &group);
    }
}

void ConfigureSwitches(PRHandle proc)
{
    int i;

    // Create a basic driver for all of the switches to default to:
    PRDriverState defaultDriver;
    memset(&defaultDriver, 0x0, sizeof(defaultDriver)); // Set all fields to 0.

    for (i = 0; i <= kPRSwitchPhysicalLast; i++)
    {
        PRSwitchRule sw;
        sw.switchNum = i;
        sw.notifyHost = true;
        sw.changeOutput = false;
        sw.linkActive = false;
        sw.linkAddress = 0;
        sw.eventType = kPREventTypeSwitchClosedDebounced;
        sw.driver = defaultDriver;
        PRSwitchesUpdateRules(proc, &sw, 1);
        sw.eventType = kPREventTypeSwitchOpenDebounced;
        PRSwitchesUpdateRules(proc, &sw, 1);
    }
}

bool runLoopRun = true;

void RunLoop(PRHandle proc)
{
    const int maxEvents = 16;
    PREvent events[maxEvents];
    while (runLoopRun)
    {
        int numEvents = PRGetEvents(proc, events, maxEvents);
        for (int i = 0; i < numEvents; i++)
        {
            PREvent *event = &events[i];
            const char *stateText = "Unknown";
            switch (event->type)
            {
                case kPREventTypeSwitchOpenDebounced: stateText = "open"; break;
                case kPREventTypeSwitchClosedDebounced: stateText = "closed"; break;
                case kPREventTypeSwitchOpenNondebounced: stateText = "open(ndb)"; break;
                case kPREventTypeSwitchClosedNondebounced: stateText = "closed(ndb)"; break;
            }
            printf("switch % 3d: %s\n", event->value, stateText);
        }
        usleep(10*1000); // Sleep for 10ms so we aren't pegging the CPU.
    }
}

void sigint(int)
{
    runLoopRun = false;
    signal(SIGINT, SIG_DFL); // Re-install the default signal handler.
    printf("Exiting...\n");
}

int main(const char **argv, int argc)
{
    // Set a signal handler so that we can exit gracefully on Ctrl-C:
    signal(SIGINT, sigint);

    // Assign a custom logging callback to demonstrate capturing log information from P-ROC:
    PRLogSetCallback(TestLogger);

    // Finally instantiate the P-ROC device:
    PRHandle proc = PRCreate(kPRMachineWPC);
    if (proc == kPRHandleInvalid)
        return 1;

    printf("Configuring P-ROC...\n");

    ConfigureDrivers(proc);
    ConfigureSwitches(proc);

    printf("Running.  Hit Ctrl-C to exit.\n");

    // Pulse a coil to test:
//	PRDriverDisable(proc, 80);
//	PRDriverPulse(proc, 53, 100);

    RunLoop(proc);

    // Destroy the P-ROC device handle:
    PRDelete(proc);
    proc = kPRHandleInvalid;

    return 0;
}