// // Programmer: Craig Stuart Sapp // Creation Date: 11 Nov 1998 // Last Modified: 12 Nov 1998 // Filename: allchan.c // Syntax: C; National Instruments LabWindows/CVI 4.0 // // Description: This program can display any combination of // sensors hooked up to the National Instrument Digital AQuisition // card (NIDAQ). You can individually select the sampling range // of each sensor; however, all sensor will be sampled at the // SAME sampling rate. Multi-rate sampling cannot be done // with the "Easy I/O" set of routines which are used in this program. // // Control enumerations for items on the program's two windows: // // MAIN // MAIN_SCALE_{0..15} = slider: displays the input voltages from channel // MAIN_MAXVOLTS_{0..15} = ring: selects the maximum of the voltage sampling // MAIN_MINVOLTS_{0..15} = ring: selects the minimum of the voltage sampling // MAIN_ACTIVATE_{0..15} = toggle: turns on/off sampling of specified channel // // MAIN_CONFIG = button: to open the configuration panel // MAIN_START = button: start acquiring data from NIDAQ card // MAIN_STOP = button: stop acquiring data form NIDAQ card // // CONFIG = window: configuration window // CONFIG_DAQRATE = box: for setting the sampling rate // CONFIG_DEVICE = box: for setting the hardware device // #include #include #include #include #include #include #include // #include #include "allchan.h" /* automatically LabWindows/CVI-generated include file */ typedef unsigned long ulong; typedef unsigned short ushort; // global variables: int device = 1; // NIDAQ hardware device double targetSampleRate = 200; // desired sampling rate double actualSampleRate = 0; // actual sampling rate on NIDAQ ulong taskID = -1; // for "Easy I/O" task descriptor short error = -1; // for getting error flag from function. int mainHandle = -1; // main window panel descriptor number int configHandle = -1; // configure window panel descriptor number int samplingState = 0; // 0 = not sampling, 1 = sampling int channelState[16] = {0}; // boolean for if channel is on or off. int minvolt[16] = {0}; // minimum value of voltage samples int maxvolt[16] = // minimum value of voltage samples {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10}; double inputData[16] = {0}; // data from sensors hookedup to NIDAQ card double channelIndex[16] = {-1}; // relation of inputData values to channels ulong sampleCountWaiting = 0; // number of samples waiting in NIDAQ card. char channelString[1024] = {0}; // for setting up channl sampling int i; // function declarations: void setScaleRange(int aChannel, int maxVolts, int minVolts); void setScaleValue(int aChannel, double* inputData); void createChannelString(char* string, int* chanStates, int* min, int* max); void selectChannel(int aChannel); void unselectChannel(int aChannel); int runLoop(int panel, int control, int event, void *callbackData, int eventData1, int eventData2); // // callback functions are declared in "allchan.h" // // activateCallback -- displays or dims the scale for each channel // configureDAQ -- sets variables from the Configuration panel // runLoop -- the main program loop // setMaxValue -- sets the minimum of the voltage measuring range // setMinValue -- sets the minimum of the voltage measuring range // shutdown -- initializes the sampling of NIDAQ channels // startDAQ -- initializes the sampling of NIDAQ channels // stopDAQ -- stops NIDAQ continuous sampling // /////////////////////////////////////////////////////////////////////////// int main(int argc, char* argv[]) { InstallMainCallback(runLoop, 0, 1); SetIdleEventRate(20); // runLoop executed every X millisec mainHandle = LoadPanel(0, "allchan.uir", MAIN); configHandle = LoadPanel(0, "allchan.uir", CONFIG); // set the default values of the voltage ranges for each channel: for (i=0; i<16; i++) { setScaleRange(i, minvolt[i], maxvolt[i]); } // set the activity of each channel (on/off) from buttons on user interface: GetCtrlVal(mainHandle, MAIN_ACTIVATE_0, &channelState[0]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_1, &channelState[1]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_2, &channelState[2]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_3, &channelState[3]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_4, &channelState[4]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_5, &channelState[5]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_6, &channelState[6]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_7, &channelState[7]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_8, &channelState[8]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_9, &channelState[9]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_10, &channelState[10]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_11, &channelState[11]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_12, &channelState[12]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_13, &channelState[13]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_14, &channelState[14]); GetCtrlVal(mainHandle, MAIN_ACTIVATE_15, &channelState[15]); // set the configure panel default values: SetCtrlVal(configHandle, CONFIG_DAQRATE, targetSampleRate); SetCtrlVal(configHandle, CONFIG_DEVICE, device); DisplayPanel(mainHandle); RunUserInterface(); // main event loop return 0; } /////////////////////////////////////////////////////////////////////////// ////////////////////////////// // // activateCallback -- function that is called when an activate // toggle button is pressed to select or deselect a channel for // sampling. // int activateCallback(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { int state; switch (event) { case EVENT_COMMIT: GetCtrlVal(mainHandle, control, &state); switch (control) { case MAIN_ACTIVATE_0: if (state) selectChannel(0); else unselectChannel(0); break; case MAIN_ACTIVATE_1: if (state) selectChannel(1); else unselectChannel(1); break; case MAIN_ACTIVATE_2: if (state) selectChannel(2); else unselectChannel(2); break; case MAIN_ACTIVATE_3: if (state) selectChannel(3); else unselectChannel(3); break; case MAIN_ACTIVATE_4: if (state) selectChannel(4); else unselectChannel(4); break; case MAIN_ACTIVATE_5: if (state) selectChannel(5); else unselectChannel(5); break; case MAIN_ACTIVATE_6: if (state) selectChannel(6); else unselectChannel(6); break; case MAIN_ACTIVATE_7: if (state) selectChannel(7); else unselectChannel(7); break; case MAIN_ACTIVATE_8: if (state) selectChannel(8); else unselectChannel(8); break; case MAIN_ACTIVATE_9: if (state) selectChannel(9); else unselectChannel(9); break; case MAIN_ACTIVATE_10: if (state) selectChannel(10); else unselectChannel(10); break; case MAIN_ACTIVATE_11: if (state) selectChannel(11); else unselectChannel(11); break; case MAIN_ACTIVATE_12: if (state) selectChannel(12); else unselectChannel(12); break; case MAIN_ACTIVATE_13: if (state) selectChannel(13); else unselectChannel(13); break; case MAIN_ACTIVATE_14: if (state) selectChannel(14); else unselectChannel(14); break; case MAIN_ACTIVATE_15: if (state) selectChannel(15); else unselectChannel(15); break; } } return 0; } ////////////////////////////// // // configDAQ -- callback function which is called when closing the // Configure window // int configureDAQ(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: if (samplingState != 0) { return 1; } // set the program variables affected by the cofigure panel GetCtrlVal(configHandle, CONFIG_DAQRATE, &targetSampleRate); GetCtrlVal(configHandle, CONFIG_DEVICE, &device); // close the configuration panel: HidePanel(configHandle); break; } return 0; } ////////////////////////////// // // createChannelString -- creates the channel initialization for // AIStartAcquisition function. // void createChannelString(char* string, int* chanStates, int* min, int* max) { int count = 0; int j; char temp[128] = {0}; string[0] = '\0'; for (i=0; i<16; i++) { if (chanStates[i] == 1) { channelIndex[count++] = i; strcat(string, " cmd hi "); sprintf(temp, "%d", max[i]); strcat(string, temp); strcat(string, " low "); sprintf(temp, "%d", min[i]); strcat(string, temp); strcat(string, ";"); sprintf(temp, "%d", i); strcat(string, temp); strcat(string, ";"); } } for (i=count; i<16; i++) { channelIndex[i] = -1; } } ////////////////////////////// // // displayConfigPanel -- callback function which is called when pressing the // configure button // int displayConfigPanel(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: DisplayPanel(configHandle); break; } return 0; } /////////////////////////////// // // runLoop -- the function which runs continuously (every 20 millisec) // for this program, while the program is running. // int runLoop(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_IDLE: if (samplingState == 0) { return 0; } AICheckAcquisition(taskID, &sampleCountWaiting); if (sampleCountWaiting == 0) { return 0; } else { AIReadAcquisition(taskID, 1 /* sample */, LATEST_MODE, &sampleCountWaiting, GROUP_BY_CHANNEL, inputData); } i = 0; while (i < 16 && channelIndex[i] != -1) { setScaleValue(channelIndex[i], inputData); i++; } break; } return 0; } /////////////////////////////// // // selectChannel -- activates a display of a particular channel. // void selectChannel(int aChannel) { switch (aChannel) { case 0: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_0, ATTR_DIMMED, 0); break; case 1: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_1, ATTR_DIMMED, 0); break; case 2: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_2, ATTR_DIMMED, 0); break; case 3: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_3, ATTR_DIMMED, 0); break; case 4: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_4, ATTR_DIMMED, 0); break; case 5: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_5, ATTR_DIMMED, 0); break; case 6: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_6, ATTR_DIMMED, 0); break; case 7: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_7, ATTR_DIMMED, 0); break; case 8: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_8, ATTR_DIMMED, 0); break; case 9: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_9, ATTR_DIMMED, 0); break; case 10: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_10, ATTR_DIMMED, 0); break; case 11: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_11, ATTR_DIMMED, 0); break; case 12: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_12, ATTR_DIMMED, 0); break; case 13: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_13, ATTR_DIMMED, 0); break; case 14: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_14, ATTR_DIMMED, 0); break; case 15: channelState[aChannel] = 1; SetCtrlAttribute(mainHandle, MAIN_SCALE_15, ATTR_DIMMED, 0); break; } } /////////////////////////////// // // setScaleRange -- sets the channel scale on the user interface to the // specified values. // void setScaleRange(int aChannel, int min, int max) { double minVolts = (double)min; double maxVolts = (double)max; switch (aChannel) { case 0: SetCtrlAttribute(mainHandle, MAIN_SCALE_0, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_0, ATTR_MIN_VALUE, minVolts); break; case 1: SetCtrlAttribute(mainHandle, MAIN_SCALE_1, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_1, ATTR_MIN_VALUE, minVolts); break; case 2: SetCtrlAttribute(mainHandle, MAIN_SCALE_2, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_2, ATTR_MIN_VALUE, minVolts); break; case 3: SetCtrlAttribute(mainHandle, MAIN_SCALE_3, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_3, ATTR_MIN_VALUE, minVolts); break; case 4: SetCtrlAttribute(mainHandle, MAIN_SCALE_4, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_4, ATTR_MIN_VALUE, minVolts); break; case 5: SetCtrlAttribute(mainHandle, MAIN_SCALE_5, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_5, ATTR_MIN_VALUE, minVolts); break; case 6: SetCtrlAttribute(mainHandle, MAIN_SCALE_6, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_6, ATTR_MIN_VALUE, minVolts); break; case 7: SetCtrlAttribute(mainHandle, MAIN_SCALE_7, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_7, ATTR_MIN_VALUE, minVolts); break; case 8: SetCtrlAttribute(mainHandle, MAIN_SCALE_8, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_8, ATTR_MIN_VALUE, minVolts); break; case 9: SetCtrlAttribute(mainHandle, MAIN_SCALE_9, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_9, ATTR_MIN_VALUE, minVolts); break; case 10: SetCtrlAttribute(mainHandle, MAIN_SCALE_10, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_10, ATTR_MIN_VALUE, minVolts); break; case 11: SetCtrlAttribute(mainHandle, MAIN_SCALE_11, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_11, ATTR_MIN_VALUE, minVolts); break; case 12: SetCtrlAttribute(mainHandle, MAIN_SCALE_12, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_12, ATTR_MIN_VALUE, minVolts); break; case 13: SetCtrlAttribute(mainHandle, MAIN_SCALE_13, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_13, ATTR_MIN_VALUE, minVolts); break; case 14: SetCtrlAttribute(mainHandle, MAIN_SCALE_14, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_14, ATTR_MIN_VALUE, minVolts); break; case 15: SetCtrlAttribute(mainHandle, MAIN_SCALE_15, ATTR_MAX_VALUE, maxVolts); SetCtrlAttribute(mainHandle, MAIN_SCALE_15, ATTR_MIN_VALUE, minVolts); break; } } /////////////////////////////// // // setScaleValue -- sets the channel's current value on the main panel // display. // void setScaleValue(int aChannel, double* values) { switch (aChannel) { case 0: SetCtrlVal(mainHandle, MAIN_SCALE_0, values[aChannel]); break; case 1: SetCtrlVal(mainHandle, MAIN_SCALE_1, values[aChannel]); break; case 2: SetCtrlVal(mainHandle, MAIN_SCALE_2, values[aChannel]); break; case 3: SetCtrlVal(mainHandle, MAIN_SCALE_3, values[aChannel]); break; case 4: SetCtrlVal(mainHandle, MAIN_SCALE_4, values[aChannel]); break; case 5: SetCtrlVal(mainHandle, MAIN_SCALE_5, values[aChannel]); break; case 6: SetCtrlVal(mainHandle, MAIN_SCALE_6, values[aChannel]); break; case 7: SetCtrlVal(mainHandle, MAIN_SCALE_7, values[aChannel]); break; case 8: SetCtrlVal(mainHandle, MAIN_SCALE_8, values[aChannel]); break; case 9: SetCtrlVal(mainHandle, MAIN_SCALE_9, values[aChannel]); break; case 10: SetCtrlVal(mainHandle, MAIN_SCALE_10, values[aChannel]); break; case 11: SetCtrlVal(mainHandle, MAIN_SCALE_11, values[aChannel]); break; case 12: SetCtrlVal(mainHandle, MAIN_SCALE_12, values[aChannel]); break; case 13: SetCtrlVal(mainHandle, MAIN_SCALE_13, values[aChannel]); break; case 14: SetCtrlVal(mainHandle, MAIN_SCALE_14, values[aChannel]); break; case 15: SetCtrlVal(mainHandle, MAIN_SCALE_15, values[aChannel]); break; } } ////////////////////////////// // // setMaxValue -- sets the minimum of the voltage measuring range // int setMaxValue(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: switch (control) { case MAIN_MAXVOLTS_0: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_0, &maxvolt[0]); setScaleRange(0, minvolt[0], maxvolt[0]); break; case MAIN_MAXVOLTS_1: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_1, &maxvolt[1]); setScaleRange(1, minvolt[1], maxvolt[1]); break; case MAIN_MAXVOLTS_2: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_2, &maxvolt[2]); setScaleRange(2, minvolt[2], maxvolt[2]); break; case MAIN_MAXVOLTS_3: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_3, &maxvolt[3]); setScaleRange(3, minvolt[3], maxvolt[3]); break; case MAIN_MAXVOLTS_4: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_4, &maxvolt[4]); setScaleRange(4, minvolt[4], maxvolt[4]); break; case MAIN_MAXVOLTS_5: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_5, &maxvolt[5]); setScaleRange(5, minvolt[5], maxvolt[5]); break; case MAIN_MAXVOLTS_6: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_6, &maxvolt[6]); setScaleRange(6, minvolt[6], maxvolt[6]); break; case MAIN_MAXVOLTS_7: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_7, &maxvolt[7]); setScaleRange(7, minvolt[7], maxvolt[7]); break; case MAIN_MAXVOLTS_8: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_8, &maxvolt[8]); setScaleRange(8, minvolt[8], maxvolt[8]); break; case MAIN_MAXVOLTS_9: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_9, &maxvolt[9]); setScaleRange(9, minvolt[9], maxvolt[9]); break; case MAIN_MAXVOLTS_10: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_10, &maxvolt[10]); setScaleRange(10, minvolt[10], maxvolt[10]); break; case MAIN_MAXVOLTS_11: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_11, &maxvolt[11]); setScaleRange(11, minvolt[11], maxvolt[11]); break; case MAIN_MAXVOLTS_12: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_12, &maxvolt[12]); setScaleRange(12, minvolt[12], maxvolt[12]); break; case MAIN_MAXVOLTS_13: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_13, &maxvolt[13]); setScaleRange(13, minvolt[13], maxvolt[13]); break; case MAIN_MAXVOLTS_14: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_14, &maxvolt[14]); setScaleRange(14, minvolt[14], maxvolt[14]); break; case MAIN_MAXVOLTS_15: GetCtrlVal(mainHandle, MAIN_MAXVOLTS_15, &maxvolt[15]); setScaleRange(15, minvolt[15], maxvolt[15]); break; } break; } return 0; } ////////////////////////////// // // setMinValue -- sets the minimum of the voltage measuring range // int setMinValue(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: switch (control) { case MAIN_MINVOLTS_0: GetCtrlVal(mainHandle, MAIN_MINVOLTS_0, &minvolt[0]); setScaleRange(0, minvolt[0], maxvolt[0]); break; case MAIN_MINVOLTS_1: GetCtrlVal(mainHandle, MAIN_MINVOLTS_1, &minvolt[1]); setScaleRange(1, minvolt[1], maxvolt[1]); break; case MAIN_MINVOLTS_2: GetCtrlVal(mainHandle, MAIN_MINVOLTS_2, &minvolt[2]); setScaleRange(2, minvolt[2], maxvolt[2]); break; case MAIN_MINVOLTS_3: GetCtrlVal(mainHandle, MAIN_MINVOLTS_3, &minvolt[3]); setScaleRange(3, minvolt[3], maxvolt[3]); break; case MAIN_MINVOLTS_4: GetCtrlVal(mainHandle, MAIN_MINVOLTS_4, &minvolt[4]); setScaleRange(4, minvolt[4], maxvolt[4]); break; case MAIN_MINVOLTS_5: GetCtrlVal(mainHandle, MAIN_MINVOLTS_5, &minvolt[5]); setScaleRange(5, minvolt[5], maxvolt[5]); break; case MAIN_MINVOLTS_6: GetCtrlVal(mainHandle, MAIN_MINVOLTS_6, &minvolt[6]); setScaleRange(6, minvolt[6], maxvolt[6]); break; case MAIN_MINVOLTS_7: GetCtrlVal(mainHandle, MAIN_MINVOLTS_7, &minvolt[7]); setScaleRange(7, minvolt[7], maxvolt[7]); break; case MAIN_MINVOLTS_8: GetCtrlVal(mainHandle, MAIN_MINVOLTS_8, &minvolt[8]); setScaleRange(8, minvolt[8], maxvolt[8]); break; case MAIN_MINVOLTS_9: GetCtrlVal(mainHandle, MAIN_MINVOLTS_9, &minvolt[9]); setScaleRange(9, minvolt[9], maxvolt[9]); break; case MAIN_MINVOLTS_10: GetCtrlVal(mainHandle, MAIN_MINVOLTS_10, &minvolt[10]); setScaleRange(10, minvolt[10], maxvolt[10]); break; case MAIN_MINVOLTS_11: GetCtrlVal(mainHandle, MAIN_MINVOLTS_11, &minvolt[11]); setScaleRange(11, minvolt[11], maxvolt[11]); break; case MAIN_MINVOLTS_12: GetCtrlVal(mainHandle, MAIN_MINVOLTS_12, &minvolt[12]); setScaleRange(12, minvolt[12], maxvolt[12]); break; case MAIN_MINVOLTS_13: GetCtrlVal(mainHandle, MAIN_MINVOLTS_13, &minvolt[13]); setScaleRange(13, minvolt[13], maxvolt[13]); break; case MAIN_MINVOLTS_14: GetCtrlVal(mainHandle, MAIN_MINVOLTS_14, &minvolt[14]); setScaleRange(14, minvolt[14], maxvolt[14]); break; case MAIN_MINVOLTS_15: GetCtrlVal(mainHandle, MAIN_MINVOLTS_15, &minvolt[15]); setScaleRange(15, minvolt[15], maxvolt[15]); break; } break; } return 0; } ////////////////////////////// // // shutdown -- what to do when closing the program // int shutdown(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: if (samplingState != 0) { AIClearAcquisition(taskID); taskID = -1; samplingState = 0; } QuitUserInterface(0); break; } return 0; } ////////////////////////////// // // startDAQ -- callback function when start button is pressed // int startDAQ(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: // Activate certain objects on the main panel: SetCtrlAttribute(mainHandle, MAIN_STOP, ATTR_DIMMED, 0); // De-activate certain objects on the main panel: SetCtrlAttribute(mainHandle, MAIN_CONFIG, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_START, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_0, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_1, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_2, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_3, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_4, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_5, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_6, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_7, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_8, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_9, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_10, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_11, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_12, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_13, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_14, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_15, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_0, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_1, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_2, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_3, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_4, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_5, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_6, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_7, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_8, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_9, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_10, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_11, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_12, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_13, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_14, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_15, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_0, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_1, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_2, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_3, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_4, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_5, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_6, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_7, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_8, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_9, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_10, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_11, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_12, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_13, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_14, ATTR_DIMMED, 1); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_15, ATTR_DIMMED, 1); // create list of channels to sample createChannelString(channelString, channelState, minvolt, maxvolt); // start asynchronous continuous sampling of specified channels if (samplingState == 0) { AIStartAcquisition(device, channelString, 1024, targetSampleRate, 0.0 /* default min voltage */, 5.0 /* default max voltage */, &actualSampleRate, &taskID); // show the user via the configure panel what the actual srate is: SetCtrlVal(configHandle, CONFIG_DAQRATE, actualSampleRate); } samplingState = 1; break; } return 0; } ////////////////////////////// // // stopDAQ -- // int stopDAQ(int panel, int control, int event, void *callbackData, int eventData1, int eventData2) { switch (event) { case EVENT_COMMIT: // De-activate certain objects on the main panel: SetCtrlAttribute(mainHandle, MAIN_STOP, ATTR_DIMMED, 1); // Activate certain objects on the main panel: SetCtrlAttribute(mainHandle, MAIN_CONFIG, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_START, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_0, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_1, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_2, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_3, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_4, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_5, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_6, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_7, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_8, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_9, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_10, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_11, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_12, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_13, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_14, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MAXVOLTS_15, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_0, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_1, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_2, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_3, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_4, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_5, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_6, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_7, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_8, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_9, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_10, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_11, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_12, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_13, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_14, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_MINVOLTS_15, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_0, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_1, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_2, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_3, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_4, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_5, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_6, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_7, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_8, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_9, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_10, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_11, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_12, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_13, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_14, ATTR_DIMMED, 0); SetCtrlAttribute(mainHandle, MAIN_ACTIVATE_15, ATTR_DIMMED, 0); if (samplingState != 0) { AIClearAcquisition(taskID); } samplingState = 0; break; } return 0; } /////////////////////////////// // // unselectChannel -- deactivates a display of a particular channel. // void unselectChannel(int aChannel) { switch (aChannel) { case 0: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_0, ATTR_DIMMED, 1); break; case 1: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_1, ATTR_DIMMED, 1); break; case 2: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_2, ATTR_DIMMED, 1); break; case 3: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_3, ATTR_DIMMED, 1); break; case 4: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_4, ATTR_DIMMED, 1); break; case 5: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_5, ATTR_DIMMED, 1); break; case 6: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_6, ATTR_DIMMED, 1); break; case 7: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_7, ATTR_DIMMED, 1); break; case 8: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_8, ATTR_DIMMED, 1); break; case 9: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_9, ATTR_DIMMED, 1); break; case 10: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_10, ATTR_DIMMED, 1); break; case 11: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_11, ATTR_DIMMED, 1); break; case 12: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_12, ATTR_DIMMED, 1); break; case 13: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_13, ATTR_DIMMED, 1); break; case 14: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_14, ATTR_DIMMED, 1); break; case 15: channelState[aChannel] = 0; SetCtrlAttribute(mainHandle, MAIN_SCALE_15, ATTR_DIMMED, 1); break; } }