////////////////////////////////////////////////////////////////////////////////////
// Open()
// This routine is called when MatLab executes the 'digitalio' instruction.
// Several things should be validated at this point.
////////////////////////////////////////////////////////////////////////////////////
HRESULT CadvantechDio::Open(IUnknown *Interface,long ID)
{
if (ID<0)
{
return E_INVALID_DEVICE_ID;
}
RETURN_HRESULT(CmwDevice::Open(Interface));
m_deviceID = static_cast<WORD>(ID); // Set the Device Number to the requested device number set in Matlab.
short numDevices;
DEVLIST deviceList[MaxDev]; // Structure containing list of installed boards (MaxDev is defined in driver.h)
RETURN_ADVANTECH(DRV_DeviceGetList((DEVLIST far *)&deviceList[0], MaxDev, &numDevices));
DWORD index = -1;
for (int i=0; i < numDevices; i++) // Find the deviceID which corresponds to the desired board.
{
if (deviceList[i].dwDeviceNum == m_deviceID)
{
index = i;
}
}
if (index == -1)
{
return E_INVALID_DEVICE_ID;
}
strcpy(m_deviceName, deviceList[index].szDeviceName);
// Open device and check that device number is valid
RETURN_ADVANTECH(DRV_DeviceOpen(m_deviceID,(LONG far *)&m_driverHandle));
PT_DeviceGetFeatures ptDevFeatures;
ptDevFeatures.buffer = (LPDEVFEATURES)&m_devFeatures;
ptDevFeatures.size = sizeof(DEVFEATURES);
RETURN_ADVANTECH(DRV_DeviceGetFeatures(m_driverHandle, (LPT_DeviceGetFeatures)&ptDevFeatures));
RETURN_HRESULT(LoadINIInfo());
RETURN_HRESULT(SetDaqHwInfo());
return S_OK;
} // end of Open()
/////////////////////////////////////////////////////////////////////////////
// AdaptorInfo()
//
// The function is used to elicit relevant info about the current HW..
//..configuration from the HW API.
// The info to extract is:
//..1)number of boards installed
//..2)board names
//..3)supported subsystems (AnalogInput, AnalogOutput, DigitalIO)
// The function is called by the engine in response to the ML user..
//..command DAQHWINFO
/////////////////////////////////////////////////////////////////////////////
HRESULT Cadvantechadapt::AdaptorInfo(IPropContainer * Container)
{
LONG lDriverHandle = (LONG)NULL; // driver handle
PT_DeviceGetFeatures ptDevFeatures; // Devfeatures table
DEVFEATURES DevFeatures; // structure for device features
int i = 0; // Index variable
// Get the name of the adaptor module
TCHAR name[256];
GetModuleFileName(_Module.GetModuleInstance(),name,256); // null returns MATLAB version (non existant)
RETURN_HRESULT(Container->put_MemberValue(L"adaptordllname",CComVariant(name)));
// Place the adaptor name in the appropriate struct in the engine.
RETURN_HRESULT(Container->put_MemberValue(L"adaptorname",variant_t(ConstructorName)));
// Find board IDs
// Start by obtaining the DeviceList. Not stored.
short numDevices; // Number of devices
DEVLIST deviceList[MaxDev]; // Space to store device information.
CComVariant var; // General CComVariant to return info to adaptor engine.
RETURN_ADVANTECH(DRV_DeviceGetList((DEVLIST far *)&deviceList[0], MaxDev, &numDevices));
// Create storage for board IDs, bord names and constructors.
TSafeArrayVector<CComBSTR> IDs; // Create A SafeArrayVector to store the IDs in
IDs.Allocate(numDevices); // Allocate the memory for the number of devices
TSafeArrayVector<CComBSTR> Names; // Create A SafeArrayVector to store the Names in
Names.Allocate(numDevices); // Allocate the memory for the number of devices
SAFEARRAY *ps; // SafeArray for the subsystem support [nDx3 CComBStrs]
CComBSTR *subsystems;
SAFEARRAYBOUND arrayBounds[2];
arrayBounds[0].lLbound = 0;
arrayBounds[0].cElements = numDevices;
arrayBounds[1].lLbound = 0;
arrayBounds[1].cElements = 3; // AnalogInput, AnalogOutput, DigitalIO subsystems.
ps = SafeArrayCreate(VT_BSTR, 2, arrayBounds);
if (ps==NULL)
return E_FAIL;
// Set up the variant to contain subsystem constructor SafeArray
var.parray = ps;
var.vt = VT_ARRAY | VT_BSTR;
HRESULT hRes = SafeArrayAccessData(ps, (void **)&subsystems);
if (FAILED (hRes))
{
SafeArrayDestroy (ps);
return hRes;
}
// Now loop through each device, getting the ID, BoardName and subsystem support.
wchar_t str[40];
for (i=0; i < numDevices; i++)
{
// Allocate the ID
char* string;
string = new char[20];
_ltoa(deviceList[i].dwDeviceNum, string, 10);
IDs[i] = CComBSTR(string);
// Open Device
RETURN_ADVANTECH(DRV_DeviceOpen(deviceList[i].dwDeviceNum,(LONG far *)&lDriverHandle));
// Get BoardNames info
Names[i] = CComBSTR(deviceList[i].szDeviceName);
// Check to see which subsystems the current board supports.
// Get device features
ptDevFeatures.buffer = (LPDEVFEATURES)&DevFeatures;
ptDevFeatures.size = sizeof(DEVFEATURES);
RETURN_ADVANTECH(DRV_DeviceGetFeatures(lDriverHandle, (LPT_DeviceGetFeatures)&ptDevFeatures));
if ((DevFeatures.usMaxAIDiffChl + DevFeatures.usMaxAISiglChl) > 0)
{
swprintf(str, L"analoginput('%s',%s)", (wchar_t*)ConstructorName, (wchar_t*)IDs[i]);
subsystems[i]=str;
}
if (DevFeatures.usMaxAOChl > 0)
{
swprintf(str, L"analogoutput('%s',%s)", (wchar_t*)ConstructorName, (wchar_t*)IDs[i]);
subsystems[i + numDevices]=str;
}
if ((DevFeatures.usMaxDIChl + DevFeatures.usMaxDOChl) > 0)
{
swprintf(str, L"digitalio('%s',%s)",(wchar_t*) ConstructorName, (wchar_t*)IDs[i]);
subsystems[i + 2*numDevices] = str;
}
// Close device
RETURN_ADVANTECH(DRV_DeviceClose((LONG far *)&lDriverHandle));
}
// Return Object Constructor Names since they're in var already.
SafeArrayUnaccessData (ps);
RETURN_HRESULT(Container->put_MemberValue(L"objectconstructorname",var));
// Return the board names
var.Clear(); // resuse the same 'var' variable for the boardnames.
Names.Detach(&var);
RETURN_HRESULT(Container->put_MemberValue(L"boardnames",var));
// Return the board numbers
var.Clear(); //reuse the same 'var' variable for the IDs[]
IDs.Detach(&var);
RETURN_HRESULT(Container->put_MemberValue(L"installedboardids",var));
return S_OK;
} // end of AdaptorInfo()
int main(int argc, char *argv[])
{
PTR_T fd;
char err_msg[100];
unsigned char *buffer;
int i, ret;
INT8U dir[MAX_DIO_PORT_NUM];
INT32U trigger[MAX_GROUPS_NUM];
PT_EnableEvent enable_event;
PT_CheckEvent check_event;
PT_TimerCountSetting tmr_count_setting;
unsigned int cascademode;
if(argc != 2) {
printf("\nUsage: tmr_cnt_set <device node>\n");
exit(-1);
}
/* step 1: open device */
ret = DRV_DeviceOpen(argv[1], &fd);
if(ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
return -1;
}
/* step 2: set device's property */
for (i = 0; i < MAX_GROUPS_NUM; i++) {
trigger[i] = 0x03;
}
ret = DRV_DeviceSetProperty(fd, CFG_InterruptTriggerSource, trigger, MAX_GROUPS_NUM*sizeof(INT32U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
/* some device can set counter 0 and counter 1 with cascade mode */
if ( 0 ) {
cascademode = 1;
ret = DRV_DeviceSetProperty(fd, CFG_CascadeMode, &cascademode , sizeof(INT32U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
}
for (i = 0; i < MAX_COUNTER_NUM; i++) {
tmr_count_setting.counter = i;
tmr_count_setting.Count = 0x3e803e8;
ret = DRV_TimerCountSetting(fd, &tmr_count_setting);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
}
/* step 3: Enable Event */
enable_event.EventType = ADS_EVT_INTERRUPT_TIMER1;
enable_event.Enabled = 1;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
}
enable_event.EventType = ADS_EVT_TERMINATE_CNT2;
enable_event.Enabled = 1;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
}
/* step 4: wait event */
printf("Waitting for Event, Sleepping... (Ctrl-C to stop)\n");
signal(SIGINT, stop_loop);
stop_flag = 0;
while (1) {
if (stop_flag)
break;
check_event.EventType = 0;
check_event.Milliseconds = 1000;
ret = DRV_CheckEvent(fd, &check_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
break;
}
switch(check_event.EventType)
{
case ADS_EVT_INTERRUPT_TIMER1:
printf("ADS_EVT_INTERRUPT_TIMER1 Interrupt \n");
break;
case ADS_EVT_TERMINATE_CNT0:
printf("ADS_EVT_TERMINATE_CNT0 Interrupt \n");
break;
case ADS_EVT_TERMINATE_CNT1:
printf("ADS_EVT_TERMINATE_CNT1 Interrupt \n");
break;
case ADS_EVT_TERMINATE_CNT2:
printf("ADS_EVT_TERMINATE_CNT2 Interrupt \n");
break;
case ADS_EVT_TIME_OUT:
printf("TimeOut\n");
break;
default:
//printf("TimeOut\n");
break;
}
}
/* step 4: disable event */
enable_event.EventType = ADS_EVT_TERMINATE_CNT2;
enable_event.Enabled = 0;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
}
enable_event.EventType = ADS_EVT_INTERRUPT_TIMER1;
enable_event.Enabled = 0;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
}
/* step 5: close device */
DRV_DeviceClose(&fd);
return 0;
}
int main(int argc, char *argv[])
{
PT_CheckEvent check_event;
PT_EnableEvent enable_event;
DiEnableChannel di_enable_chan;
DiPortValue di_port_value;
unsigned int ret;
char err_msg[100];
INT32U hi_val[8];
INT32U low_val[8];
INT32U cnt_te;
INT32U cnt_match;
INT32U cnt_preset[8];
INT32U cnt_value[8];
INT32U cnt_overflow;
INT32U cnt_trigger;
INT32U counter_enable;
INT8U filter_enable;
INT32U di_status;
int fd;
int i;
for (i = 0; i < 8; ++i) {
hi_val[i] = 1;
low_val[i] = 1;
cnt_preset[i] = 300;
cnt_value[i] = 1000;
}
cnt_match = 0xff;
counter_enable = 0x80;
cnt_te = 0xff;
cnt_overflow = 0xff;
cnt_trigger = 0xff;
filter_enable = 0x80;
if (argc != 2) {
printf("\nUsage: di_pattn <device node>\n");
printf("\nPlease input a relative DEVICE NODE!\n\n");
exit(1);
}
/* step 1: open device */
ret = DRV_DeviceOpen((char *)argv[1], &fd);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
return -1;
}
/* step 2: set property */
#if 1
/*1. pattern match */
printf("DI pattern match function:\n");
printf("DiEnableChannel.port = ");
scanf("%d", &di_enable_chan.port);
printf("\nDiEnableChannel.status = 0x");
scanf("%x", &di_enable_chan.status);
printf("\nDiPortValue.port= %d\n", di_enable_chan.port);
printf("DiPortValue.value = 0x");
scanf("%x", &di_port_value.value);
di_port_value.port = di_enable_chan.port;
ret = DRV_DeviceSetProperty(fd, CFG_DiPatternMatchEnabledChannel,
&di_enable_chan, sizeof(DiEnableChannel));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiPatternMatchValue,
&di_port_value, sizeof(DiPortValue));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
/* 2. Di status change */
di_status = 0x80;
ret = DRV_DeviceSetProperty(fd, CFG_DiStatusChangeOnRisingEdge, &di_status, sizeof(INT32U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiFilterEnable, &filter_enable, sizeof(INT8U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiFilterLowValue, low_val, sizeof(low_val));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiFilterHiValue, hi_val, sizeof(hi_val));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiCounterEnable, &counter_enable, sizeof(INT32U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiCounterTrigEdge, &cnt_trigger, sizeof(INT32U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiCounterMatchEnable, &cnt_match, sizeof(INT8U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiCounterPreset, cnt_preset, sizeof(cnt_preset));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiCounterValue, &cnt_value, sizeof(cnt_value));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
ret = DRV_DeviceSetProperty(fd, CFG_DiCounterOverflow, &cnt_overflow, sizeof(INT32U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
#endif
/* step 3: enable event */
i = 0;
while (event_support[i] != 0) {
memset(&enable_event, 0, sizeof(PT_EnableEvent));
enable_event.EventType = event_support[i]; /* you can choose */
enable_event.Enabled = 1;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
i++;
}
/* step 4: check event */
memset(&check_event, 0, sizeof(PT_CheckEvent));
printf("Waitting for Event, Sleepping... (Ctrl-C to stop)\n");
signal(SIGINT, stop_loop);
stop_flag = 0;
while (1) {
if (stop_flag)
break;
check_event.EventType = 0; /* 0 - check all */
check_event.Milliseconds = 1000; /* wait for one second */
ret = DRV_CheckEvent(fd, &check_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
continue;
}
switch(check_event.EventType) {
case ADS_EVT_DI_PATTERNMATCH_PORT0:
printf("PORT0 pattern match occured!\n");
break;
case ADS_EVT_DI_STATUSCHANGE_PORT0:
printf("PORT0 status change occured!\n");
break;
case ADS_EVT_COUNTERMATCH:
printf("counter match occured!\n");
break;
case ADS_EVT_COUNTEROVERFLOW:
printf("counter overflow occured!\n");
break;
}
}
/* step 3: enable event */
i = 0;
while (event_support[i] != 0) {
memset(&enable_event, 0, sizeof(PT_EnableEvent));
enable_event.EventType = event_support[i]; /* you can choose */
enable_event.Enabled = 0;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
i++;
}
/* step 4: close device */
DRV_DeviceClose(&fd);
return 0;
}
int main(int argc, char *argv[])
{
PT_EnableEvent enable_event;
PT_CheckEvent check_event;
struct timeval prev, now;
double time, freq;
unsigned int count;
unsigned int buffer;
char *filename;
char err_msg[100];
int ret;
int fd;
if (argc != 2) {
printf("\nUsage: di_int <device node>\n");
printf("\nPlease input a relative DEVICE NODE!\n\n");
exit(1);
}
filename = argv[1];
/* step 1: open device */
ret = DRV_DeviceOpen(filename, &fd);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
return -1;
}
/* step 2: set property */
buffer = 0x0001; /* set interrupt trig edge (1: enable, 0: disable) */
ret = DRV_DeviceSetProperty(fd, CFG_DiInterruptTriggerOnRisingEdge,
&buffer, sizeof(unsigned int));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
/* step 3: enable event */
memset(&enable_event, 0, sizeof(PT_EnableEvent));
enable_event.EventType = ADS_EVT_DI_INTERRUPT0; /* you can choose */
enable_event.Enabled = 1;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
/* step 4: check event */
printf("Waitting for Event, Sleepping... (Ctrl-C to stop)\n");
signal(SIGINT, stop_loop);
stop_flag = 0;
while (1) {
if (stop_flag)
break;
check_event.EventType = 0; /* 0 - check all */
check_event.Milliseconds = 1000; /* wait for one second */
ret = DRV_CheckEvent(fd, &check_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
continue;
}
switch (check_event.EventType) {
case ADS_EVT_DI_INTERRUPT0:
printf("DI0 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT8:
printf("DI8 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT16:
printf("DI16 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT24:
printf("DI24 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT32:
printf("DI32 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT40:
printf("DI40 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT48:
printf("DI48 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT56:
printf("DI56 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT63:
printf("DI63 interrupt!\n");
break;
case ADS_EVT_DEVREMOVED:
printf("Device removed!\n");
goto out;
default:
printf("NO Event!\n");
break;
}
count++;
gettimeofday(&now, NULL);
time = (now.tv_sec - prev.tv_sec) + (now.tv_usec - prev.tv_usec)
/ (double) 1000000;
if (time >= 0.5) {
freq = (double) enable_event.Count * count / time;
printf("frequency is %f, count: %d, time: %f\n", freq, count, time);
count = 0;
prev = now;
}
}
out: /* step 4: disable event */
memset(&enable_event, 0, sizeof(PT_EnableEvent));
enable_event.EventType = ADS_EVT_DI_INTERRUPT0; /* you can choose */
enable_event.Enabled = 0;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
/* step 5: close device */
DRV_DeviceClose(&fd);
return 0;
}
int main(int argc, char *argv[])
{
PT_EnableEvent enable_event;
PT_CheckEvent check_event;
struct timeval prev, now;
double time, freq;
unsigned int count;
char *filename;
char err_msg[100];
int ret;
int fd;
int groups_int[MAX_GROUPS_NUM];
int i;
if (argc != 2) {
printf("\nUsage: di_int <device node>\n");
printf("\nPlease input a relative DEVICE NODE!\n\n");
exit(1);
}
filename = argv[1];
/* step 1: open device */
ret = DRV_DeviceOpen(filename, &fd);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
return -1;
}
/* step 2: set property */
if ( 1 ) {
/* For that device which DIO's direction can be set by SW */
INT8U dir[MAX_DIO_PORT_NUM];
for (i = 0; i < MAX_DIO_PORT_NUM; i++)
dir[i] = DIO_ChannelDir_DI;
ret = DRV_DeviceSetProperty(fd, CFG_DioChannelDirection, &dir, MAX_DIO_PORT_NUM*sizeof(INT8U));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
}
/* set tirgger source */
for (i = 0; i < MAX_GROUPS_NUM; i++) {
groups_int[i] = 0x01;
}
ret = DRV_DeviceSetProperty(fd, CFG_InterruptTriggerSource,
groups_int, sizeof(groups_int));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
/* set interrupt trigger edge (1: rising edge, 0: falling edge) */
if (0) {
unsigned int buffer;
buffer = 0x0001;
ret = DRV_DeviceSetProperty(fd, CFG_DiInterruptTriggerOnRisingEdge,
&buffer, sizeof(unsigned int));
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
}
/* step 3: enable event */
i = 0;
while (event_support[i] != 0) {
memset(&enable_event, 0, sizeof(PT_EnableEvent));
enable_event.EventType = event_support[i]; /* you can choose */
enable_event.Enabled = 1;
enable_event.Count = 1;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
printf("event_supprt[%d] is not supported by this device\n", i);
DRV_DeviceClose(&fd);
return -1;
}
i++;
}
/* step 4: check event */
printf("Waitting for Event, Sleepping... (Ctrl-C to stop)\n");
signal(SIGINT, stop_loop);
stop_flag = 0;
while (1) {
if (stop_flag)
break;
check_event.EventType = 0; /* 0 - check all */
check_event.Milliseconds = 1000; /* wait for one second */
ret = DRV_CheckEvent(fd, &check_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
continue;
}
switch (check_event.EventType) {
case ADS_EVT_DI_INTERRUPT0:
printf("DI0 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT8:
printf("DI8 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT16:
printf("DI16 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT24:
printf("DI24 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT32:
printf("DI32 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT40:
printf("DI40 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT48:
printf("DI48 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT56:
printf("DI56 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT63:
printf("DI63 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT64:
printf("DI64 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT88:
printf("DI88 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT112:
printf("DI112 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT136:
printf("DI136 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT160:
printf("DI160 interrupt!\n");
break;
case ADS_EVT_DI_INTERRUPT184:
printf("DI184 interrupt!\n");
break;
case ADS_EVT_DEVREMOVED:
printf("Device removed!\n");
break;
default:
printf("NO Event!\n");
break;
}
count++;
gettimeofday(&now, NULL);
time = (now.tv_sec - prev.tv_sec) + (now.tv_usec - prev.tv_usec)
/ (double) 1000000;
if (time >= 0.5) {
freq = (double) enable_event.Count * count / time;
printf("frequency is %f, count: %d, time: %f\n", freq, count, time);
count = 0;
prev = now;
}
}
out: /* step 4: disable event */
i = 0;
while (event_support[i] != 0) {
memset(&enable_event, 0, sizeof(PT_EnableEvent));
enable_event.EventType = event_support[i]; /* you can choose */
enable_event.Enabled = 0;
ret = DRV_EnableEvent(fd, &enable_event);
if (ret) {
DRV_GetErrorMessage(ret, err_msg);
printf("err msg: %s\n", err_msg);
printf("event_supprt[%d] is not supported by this device\n", i);
}
i++;
}
/* step 5: close device */
DRV_DeviceClose(&fd);
return 0;
}
int main(int argc, char *argv[])
{
PT_EnableEvent enable_event;
PT_FAIDmaStart fai_dma_start;
PT_CheckEvent check_event;
PT_FAITransfer fai_transfer;
PT_FAICheck fai_check;
unsigned short start_chan;
unsigned short num_chan;
unsigned short gain_code;
unsigned long buffer;
unsigned short *gain_array;
unsigned short *reading_array;
unsigned short overrun;
float *voltage_array;
void *bufptr_inp; /* buffer pointer for input */
void *bufptr_out; /* buffer pointer for output */
char *filename = NULL;
char err_msg[100];
int tmp;
int fd;
int i = 0;
/* get argument */
if (argc < 2) {
printf("Usage: ad_dma_bm <device node> [start channel] [channel numbers] [gain code]\n");
return -1;
}
filename = argv[1];
if (argv[2] != NULL) {
start_chan = (unsigned short) atoi(argv[2]);
} else {
start_chan = 0;
}
if (argv[3] != NULL) {
num_chan = (unsigned short) atoi(argv[3]);
if (num_chan == 0) { /* channel numbers must > 0 */
num_chan = 1;
}
} else {
num_chan = 1;
}
if (argv[4] != NULL) {
gain_code = (unsigned short) atoi(argv[4]);
} else {
gain_code = 0;
}
/* Step 1: Open Device */
tmp = DRV_DeviceOpen(filename, &fd);
if (tmp < 0) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
return -1;
}
/* Step 2: Initialize */
gain_array = (unsigned short *) malloc(num_chan * sizeof(unsigned short));
reading_array = (unsigned short *) malloc(CONVERTION_NUMBER * sizeof(unsigned short));
voltage_array = (float *) malloc(CONVERTION_NUMBER * sizeof(float));
memset(gain_array, gain_code, num_chan * sizeof(unsigned short));
memset(reading_array, 0, CONVERTION_NUMBER * sizeof(unsigned short));
memset(voltage_array, 0, CONVERTION_NUMBER * sizeof(float));
memset(&fai_dma_start, 0, sizeof(PT_FAIDmaStart));
memset(&enable_event, 0, sizeof(PT_EnableEvent));
memset(&check_event, 0, sizeof(PT_CheckEvent));
memset(&fai_transfer, 0, sizeof(PT_FAITransfer));
/* Step 3: Set Single-end or Differential */
/* buffer = 0x0000; /\* 0: single-end */
/* * 1: differential *\/ */
/* tmp = DRV_DeviceSetProperty(fd, CFG_AiChanConfig, &buffer, sizeof(unsigned long) * 2); */
/* if (tmp) { */
/* DRV_GetErrorMessage(tmp, err_msg); */
/* /\* printf("err msg: %s\n", err_msg); *\/ */
/* } */
/* for (i = 0; i < 4; i++) { */
/* gain_array[i] = (unsigned short) i; /\* 0,1,2,3 *\/ */
/* } */
/* Step 4: Enable event
*
* U can enable following event:
*
* ADS_EVT_AI_BUFCHANGE
* ADS_EVT_AI_TERMINATED
* ADS_EVT_AI_OVERRUN */
enable_event.EventType = ADS_EVT_AI_LOBUFREADY;
enable_event.Enabled = 1;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array, reading_array, voltage_array);
return -1;
}
enable_event.EventType = ADS_EVT_AI_HIBUFREADY;
enable_event.Enabled = 1;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array, reading_array, voltage_array);
return -1;
}
enable_event.EventType = ADS_EVT_AI_TERMINATED;
enable_event.Enabled = 1;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array, reading_array, voltage_array);
return -1;
}
enable_event.EventType = ADS_EVT_AI_OVERRUN;
enable_event.Enabled = 1;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array, reading_array, voltage_array);
return -1;
}
/* Step 5: Start DMA Transfer */
fai_dma_start.TrigSrc = 0; /* 0: internal; 1: external */
fai_dma_start.chan = 0;
fai_dma_start.count = CONVERTION_NUMBER;
fai_dma_start.SampleRate = 80000;
fai_dma_start.gain = gain_array[0];
fai_dma_start.buffer = reading_array;
tmp = DRV_FAIDmaStart(fd, &fai_dma_start);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
region_busy = 1;
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
switch (DATA_TYPE) {
case 0: /* binary in */
bufptr_inp = (void *) reading_array;
bufptr_out = (void *) reading_array;
break;
case 1: /* voltage in */
bufptr_inp = (void *) voltage_array;
bufptr_out = NULL;
break;
default:
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
/* Step 6: Check event */
printf("Waitting for Event, Sleepping... (Ctrl-C to stop)\n");
signal(SIGINT, stop_loop);
stop_flag = 0;
while (1) {
if ((stop_flag)
|| (check_event.EventType == ADS_EVT_AI_TERMINATED)) {
printf("Out of loop, safe!\n");
break;
}
check_event.EventType = 0; /* check all event */
check_event.Milliseconds = 0;
tmp = DRV_CheckEvent(fd, &check_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
continue;
}
switch (check_event.EventType) {
case ADS_EVT_AI_LOBUFREADY:
i++;
printf("Low buffer ready! (interrupt: %d)\n", i);
fai_transfer.DataBuffer = bufptr_inp;
fai_transfer.DataType = DATA_TYPE;
fai_transfer.start = 0;
fai_transfer.count = CONVERTION_NUMBER / 2;
fai_transfer.overrun = &overrun;
tmp = DRV_FAITransfer(fd, &fai_transfer);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
tmp = event_process_func(fd,
0,
num_chan,
bufptr_out,
voltage_array);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
tmp = DRV_FAICheck(fd, &fai_check);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
printf("FAICheck:\n");
printf("\tstopped: %d\n", fai_check.stopped);
printf("\tretrieved: %d\n", fai_check.retrieved);
printf("\toverrun: %d\n", fai_check.overrun);
printf("\tHalfReady: %d\n\n", fai_check.HalfReady);
/* tmp = DRV_ClearFlag(fd, ADS_EVT_AI_LOBUFREADY); */
/* if (tmp) { */
/* release_region_func(fd, &enable_event, gain_array, */
/* reading_array, voltage_array); */
/* return -1; */
/* } */
break;
case ADS_EVT_AI_HIBUFREADY:
i++;
printf("High buffer ready! (interrupt: %d)\n", i);
fai_transfer.DataBuffer = bufptr_inp;
fai_transfer.DataType = DATA_TYPE;
fai_transfer.start = 0;//CONVERTION_NUMBER / 2;
fai_transfer.count = CONVERTION_NUMBER ;/// 2;
fai_transfer.overrun = &overrun;
tmp = DRV_FAITransfer(fd, &fai_transfer);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
tmp = event_process_func(fd,
0,//CONVERTION_NUMBER / 2,
num_chan,
bufptr_out,
voltage_array);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
tmp = DRV_FAICheck(fd, &fai_check);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, &enable_event, gain_array,
reading_array, voltage_array);
return -1;
}
printf("FAICheck:\n");
printf("\tstopped: %d\n", fai_check.stopped);
printf("\tretrieved: %d\n", fai_check.retrieved);
printf("\toverrun: %d\n", fai_check.overrun);
printf("\tHalfReady: %d\n\n", fai_check.HalfReady);
/* tmp = DRV_ClearFlag(fd, ADS_EVT_AI_HIBUFREADY); */
/* if (tmp) { */
/* release_region_func(fd, &enable_event, gain_array, */
/* reading_array, voltage_array); */
/* return -1; */
/* } */
break;
case ADS_EVT_AI_TERMINATED:
i++;
printf("Interrupt AI terminated! (interrupt: %d)\n", i);
break;
case ADS_EVT_AI_OVERRUN:
i++;
printf("Buffer overrun! (interrupt: %d)\n", i);
/* tmp = event_process_func(fd, */
/* start_chan, */
/* num_chan, */
/* NULL, */
/* voltage_array); */
/* if (tmp) { */
/* release_region_func(fd, &enable_event, gain_array, */
/* reading_array, voltage_array); */
/* return -1; */
/* } */
break;
}
}
/* Step 7: Disable event */
enable_event.EventType = ADS_EVT_AI_LOBUFREADY;
enable_event.Enabled = 0;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array,
reading_array, voltage_array);
return -1;
}
enable_event.EventType = ADS_EVT_AI_HIBUFREADY;
enable_event.Enabled = 0;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array,
reading_array, voltage_array);
return -1;
}
enable_event.EventType = ADS_EVT_AI_OVERRUN;
enable_event.Enabled = 0;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array,
reading_array, voltage_array);
return -1;
}
enable_event.EventType = ADS_EVT_AI_TERMINATED;
enable_event.Enabled = 0;
enable_event.Count = 1;
tmp = DRV_EnableEvent(fd, &enable_event);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
release_region_func(fd, NULL, gain_array,
reading_array, voltage_array);
return -1;
}
/* Step 8. Stop DMA */
DRV_FAITerminate(fd);
/* Step 9: Close Device
free(gain_array);
free(reading_array);
free(voltage_array);*/
DRV_DeviceClose(&fd);
return 0;
}
int main(int argc, char *argv[])
{
PT_CounterPWMSetting counter_pwm_setting;
unsigned short counter;
char *filename = NULL;
char err_msg[100];
int tmp;
PTR_T fd;
/* get argument */
if (argc < 2) {
printf("Usage: pwm_out <device node> [counter index]\n");
return -1;
}
filename = argv[1];
if (argv[2] != NULL) {
counter = (unsigned short) atoi(argv[2]);
} else {
counter = 0;
}
/* Step 1: Open Device */
tmp = DRV_DeviceOpen(filename, &fd);
if (tmp) {
return -1;
}
/* Step 2: Config Counter PWM */
memset(&counter_pwm_setting, 0, sizeof(PT_CounterPWMSetting));
counter_pwm_setting.Port = counter;
counter_pwm_setting.Period = 1; /* seconds */
counter_pwm_setting.HiPeriod = 0.5; /* should be > 0.5 */
counter_pwm_setting.OutCount = 0; /* 0 for cyclic mode */
counter_pwm_setting.GateMode = 0;
tmp = DRV_CounterPWMSetting(fd, &counter_pwm_setting);
if (tmp) {
DRV_GetErrorMessage(tmp, err_msg);
printf("err msg: %s\n", err_msg);
DRV_DeviceClose(&fd);
return -1;
}
/* Step 3: Enable Counter PWM Out */
tmp = DRV_CounterPWMEnable(fd, counter);
if (tmp) {
DRV_DeviceClose(&fd);
return -1;
}
printf("PWM Out...(press any key to stop)\n");
signal(SIGINT, stop_loop);
stop_flag = 0;
while (1) {
if (stop_flag)
break;
}
/* Step 4: Reset Counter */
tmp = DRV_CounterReset(fd, counter);
if (tmp) {
DRV_DeviceClose(&fd);
return -1;
}
/* Step 5: Close Device */
DRV_DeviceClose(&fd);
return 0;
}
Control_Entrada_Salida::Control_Entrada_Salida()
: TThread(false)
{
//Abrir el driver
Status = DRV_DeviceOpen (0, &USB_4711A);
//2a tarjeta
Status2 = DRV_DeviceOpen (1, &USB_4711A_2);
//Configurar todos E/S
//Volante: AO canal 0. range: +/- 10v
PT_AOConfig Configuracion_Canal_Vol;
Configuracion_Canal_Vol.chan = 0;
Configuracion_Canal_Vol.RefSrc = 0;
Configuracion_Canal_Vol.MaxValue = 10.0;
Configuracion_Canal_Vol.MinValue = -10.0;
DRV_AOConfig (USB_4711A,&Configuracion_Canal_Vol);
//Acelerador: AO canal 1. range: 0-5v
PT_AOConfig Configuracion_Canal_Acel;
Configuracion_Canal_Acel.chan = 1;
Configuracion_Canal_Acel.RefSrc = 0;
Configuracion_Canal_Acel.MaxValue = 5.0;
Configuracion_Canal_Acel.MinValue = 0;
DRV_AOConfig (USB_4711A,&Configuracion_Canal_Acel);
//Velocidad: AI canal 1. range: 0-5v
PT_AIConfig Configuracion_Canal_Vel;
Configuracion_Canal_Vel.DasChan = 1;
Configuracion_Canal_Vel.DasGain = 0;
DRV_AIConfig( USB_4711A, &Configuracion_Canal_Vel );
//Configuro a 0 el buffer de las salidas digitales
DO_Byte = 0x00;
AdxDioWriteDoPorts(USB_4711A,0,1, &DO_Byte);
//Configurar la 2a tarjeta
/**********************************************************************/
if (Status2 == SUCCESS){
//Acelerador 100%: AO canal 0. range: 0-5v
PT_AOConfig Configuracion_Canal_Acel_2T_P0;
Configuracion_Canal_Acel_2T_P0.chan = 0;
Configuracion_Canal_Acel_2T_P0.RefSrc = 0;
Configuracion_Canal_Acel_2T_P0.MaxValue = 0;
Configuracion_Canal_Acel_2T_P0.MinValue = 5.0;
DRV_AOConfig (USB_4711A_2,&Configuracion_Canal_Acel_2T_P0);
//Acelerador 50%: AO canal 1. range: 0-5v
PT_AOConfig Configuracion_Canal_Acel_2T_P1;
Configuracion_Canal_Acel_2T_P1.chan = 1;
Configuracion_Canal_Acel_2T_P1.RefSrc = 0;
Configuracion_Canal_Acel_2T_P1.MaxValue = 5.0;
Configuracion_Canal_Acel_2T_P1.MinValue = 0;
DRV_AOConfig (USB_4711A_2,&Configuracion_Canal_Acel_2T_P1);
}
/**********************************************************************/
//activo el bucle de control
Fin = false;
FreeOnTerminate = true;
}
