ioPAC RTU Controllers
C/C++ Sample Code Programming Guide
Functions
ioPAC8500_tag_rtd.c File Reference

ioPAC8500 RTD TAG Sample More...

#include <libmoxa_rtu.h>

Functions

int main (int argc, char **const argv)
 

Detailed Description

ioPAC8500 RTD TAG Sample

Date
06-18-2014
Author
TJ Tai
Version
V1.0
8500_tag_rtd.jpg
RTD TAG Sample
Introduction:
This is RTD TAG sample code. The controller will poll for RTD values, and set DO values according to the RTD level.
Example:
1. Using default: ./ioPAC8500_tag_rtd
2. Setting RTD slot and channel only: ./ioPAC8500_tag_rtd -i5 -c3
Default:
Slot of RTD module = 1
Channel on RTD module = 0
Slot of DO module = 2
Help:
root@Moxa:/tmp#./ioPAC8500_tag_rtd -h
RTD TAG sample program.

Usage: ./ioPAC8500_tag_rtd [OPTIONS]

Options:
    -i       Slot of RTD module [0-9]. Default slot = 1
    -c       Channel on RTD module [0-5]. Default channel = 0
    -r       Test threshold. Default threshold = 100.000
    -s       Slot of DO module [0-9]. Default slot = 2

Library:
RTD APIs
RTUxpress Project file:
ioPAC8500_tag_rtd.rtu
(Please right click on the link and ‘Save Target As…’ to save RTUxpress project file and open it with RTUxpress utility)

Function Documentation

int main ( int  argc,
char **const  argv 
)
/*******************************************************************************
* Copyright Moxa Inc.
*
* RTD TAG Sample Application
*
* Date Author Comment
* 06-18-2014 TJ Tai Created.
******************************************************************************/
#include <libmoxa_rtu.h>
int main(int argc, char **const argv)
{
int rc, i;
TAG_ERR_CODE retval = 0;
TAG_INFO tagInfo;
UINT32 rtdSlot = 1;
UINT32 doSlot = 2, slotMin = 0, slotMax = 9;
UINT32 rtdChannel = 0;
unsigned short burnStat;
int rtdChannelAmount = 6;
int doChannelAmount = 2; // Only use DO0 and DO1
float u32Val = 0;
char rtd[rtdChannelAmount][TAG_MAX_NAME_SIZE];
char do_tagName[doChannelAmount][TAG_MAX_NAME_SIZE];
UINT32 bitVal[2] = { 0, 1};
float fThreshold = 100.0f;
float fVal = 0;
while(-1 != (rc = getopt(argc, argv, "hi:c:r:s:")))
{
switch(rc)
{
case 'i':
rtdSlot = atoi(optarg);
if(rtdSlot < slotMin || rtdSlot > slotMax)
{
printf("Error parameter: slot: %d\n", rtdSlot);
return -1;
}
break;
case 'c':
rtdChannel = atoi(optarg);
if(rtdChannel < 0 || rtdChannel >= rtdChannelAmount)
{
printf("Error parameter: channel: %d\n", rtdChannel);
return -1;
}
break;
case 'r':
fThreshold = atof(optarg);
break;
case 's':
doSlot = atoi(optarg);
if(doSlot < slotMin || doSlot > slotMax)
{
printf("Error parameter: slot: %d\n", doSlot);
return -1;
}
break;
case '?':
case 'h':
default:
printf("RTD TAG sample program.\n\n");
printf("Usage: ./ioPAC8500_tag_rtd [OPTIONS]\n\n");
printf("Options:\n");
printf("\t%-8s Slot of RTD module [%d-%d]. Default slot = %d\n",
"-i", slotMin, slotMax, rtdSlot);
printf("\t%-8s Channel on RTD module [%d-%d]. Default channel = %d\n",
"-c", 0, rtdChannelAmount - 1, rtdChannel);
printf("\t%-8s Test threshold. Default threshold = %.3f\n",
"-r", fThreshold);
printf("\t%-8s Slot of DO module [%d-%d]. Default slot = %d\n",
"-s", slotMin, slotMax, doSlot);
printf("\n");
return 0;
}
}
printf("%-10s: %d\n", "RTD slot", rtdSlot);
printf("%-10s: %d\n", "RTD channel", rtdChannel);
printf("%-10s: %.3f\n", "Threshold", fThreshold);
printf("%-10s: %d\n", "DO slot", doSlot);
sprintf(rtd[0], "S%d_RTD%d_RTDValue", rtdSlot, rtdChannel);
sprintf(rtd[1], "S%d_RTD%d_RTDMaxValue", rtdSlot, rtdChannel);
sprintf(rtd[2], "S%d_RTD%d_RTDMinValue", rtdSlot, rtdChannel);
sprintf(rtd[3], "S%d_RTD%d_ResetMaxMin", rtdSlot, rtdChannel);
sprintf(rtd[4], "S%d_RTD%d_BurnOutState",rtdSlot, rtdChannel);
retval = MX_RTU_Tag_Init();
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Init(), return code = %d.\n", retval);
return 0;
}
// Config DO TAG
for(i = 0; i < doChannelAmount; i++)
{
sprintf(do_tagName[i], "S%d_DO%d_DOValue", doSlot, i);
}
// Reset DO to default
for(i = 0; i < doChannelAmount; i++)
{
retval = MX_RTU_Tag_Get_Info(do_tagName[i], &tagInfo);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Get_Info(%s), return code = %d.\n", do_tagName[i], retval);
break;
}
retval = MX_RTU_Tag_Write(do_tagName[i], bitVal + 0, tagInfo.tagSize);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Write(%s), return code = %d\r\n", do_tagName[i], retval);
break;
}
}
while(1)
{
// GetRTD
retval = MX_RTU_Tag_Read(rtd[0], &fVal, sizeof(fVal), NULL, NULL);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Read(%s) = %d\n", rtd[0], retval);
break;
}
// Burnout State Checking
retval = MX_RTU_Tag_Read(rtd[4], &burnStat, sizeof(burnStat), NULL, NULL);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Read(%s) = %d\n", rtd[4], retval);
break;
}
printf("\rRTD Value = %20f, RTD Burnout Status = %d", fVal, burnStat);
fflush(0);
// SetDO
// if burnout --> turn off DO0, turn on DO1
if(burnStat == 1)
{
retval = MX_RTU_Tag_Get_Info(do_tagName[0], &tagInfo);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Get_Info(%s), return code = %d.\n", do_tagName[0], retval);
break;
}
retval = MX_RTU_Tag_Write(do_tagName[0], bitVal + 0, tagInfo.tagSize);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Write(%s), return code = %d\r\n", do_tagName[0], retval);
break;
}
retval = MX_RTU_Tag_Get_Info(do_tagName[1], &tagInfo);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Get_Info(%s), return code = %d.\n", do_tagName[1], retval);
break;
}
retval = MX_RTU_Tag_Write(do_tagName[1], bitVal + 1, tagInfo.tagSize);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Write(%s), return code = %d\r\n", do_tagName[1], retval);
break;
}
}
else {
// turn off DO1
retval = MX_RTU_Tag_Get_Info(do_tagName[1], &tagInfo);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Get_Info(%s), return code = %d.\n", do_tagName[1], retval);
break;
}
retval = MX_RTU_Tag_Write(do_tagName[1], bitVal + 0, tagInfo.tagSize);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Write(%s), return code = %d\r\n", do_tagName[1], retval);
break;
}
// compare RTD value with threshold then set DO0 on
if(fVal > fThreshold)
{
retval = MX_RTU_Tag_Get_Info(do_tagName[0], &tagInfo);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Get_Info(%s), return code = %d.\n", do_tagName[0], retval);
break;
}
retval = MX_RTU_Tag_Write(do_tagName[0], bitVal + 1, tagInfo.tagSize);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Write(%s), return code = %d\r\n", do_tagName[0], retval);
break;
}
}
else {
retval = MX_RTU_Tag_Get_Info(do_tagName[0], &tagInfo);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Get_Info(%s), return code = %d.\n", do_tagName[0], retval);
break;
}
retval = MX_RTU_Tag_Write(do_tagName[0], bitVal + 0, tagInfo.tagSize);
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Write(%s), return code = %d\r\n", do_tagName[0], retval);
break;
}
}
}
}
retval = MX_RTU_Tag_Uninit();
if(retval != TAG_ERR_OK)
{
printf("MX_RTU_Tag_Uninit(), return code = %d\n", retval);
}
return 0;
}