koennecke
385 lines
9.8 KiB
C
385 lines
9.8 KiB
C
/*--------------------------------------------------------------------------
|
|
|
|
I T C 4 U T I L
|
|
|
|
A few utility functions for dealing with a ITC4 temperature controller
|
|
within the SINQ setup: host -- TCP/IP -- MAC --- RS-232.
|
|
|
|
Mark Koennecke, Juli 1997
|
|
|
|
Copyright:
|
|
|
|
Labor fuer Neutronenstreuung
|
|
Paul Scherrer Institut
|
|
CH-5423 Villigen-PSI
|
|
|
|
|
|
The authors hereby grant permission to use, copy, modify, distribute,
|
|
and license this software and its documentation for any purpose, provided
|
|
that existing copyright notices are retained in all copies and that this
|
|
notice is included verbatim in any distributions. No written agreement,
|
|
license, or royalty fee is required for any of the authorized uses.
|
|
Modifications to this software may be copyrighted by their authors
|
|
and need not follow the licensing terms described here, provided that
|
|
the new terms are clearly indicated on the first page of each file where
|
|
they apply.
|
|
|
|
IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
|
|
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
|
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
|
|
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
|
|
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
|
|
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
|
|
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
|
|
MODIFICATIONS.
|
|
---------------------------------------------------------------------------- */
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include "serialsinq.h"
|
|
#include "itc4util.h"
|
|
/* -------------------------------------------------------------------------*/
|
|
|
|
int ITC4_Open(pITC4 * pData, char *pHost, int iPort, int iChannel,
|
|
int iMode)
|
|
{
|
|
int iRet;
|
|
char pCommand[80];
|
|
char pReply[132];
|
|
pITC4 self = NULL;
|
|
|
|
self = (pITC4) malloc(sizeof(ITC4));
|
|
if (self == NULL) {
|
|
return ITC4__BADMALLOC;
|
|
}
|
|
*pData = self;
|
|
self->iControl = 1;
|
|
self->iRead = 1;
|
|
self->iReadOnly = iMode;
|
|
self->fDiv = 10.;
|
|
self->fMult = 10.;
|
|
|
|
iRet = SerialOpen(&self->pData, pHost, iPort, iChannel);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
|
|
/* set an lengthy timeout for the configuration in order to
|
|
prevent problems.
|
|
*/
|
|
iRet = SerialConfig(&self->pData, 100);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
|
|
/* an identification test has been here, but I had to removed as not all
|
|
ITC4 controllers at SINQ answer the V command. Some versions of the
|
|
controller do not recognize it. Sighhhhhhh. I had to put it in again
|
|
in order to check for ITC-503, but I handle the thing by default as
|
|
an ITC4 if I do not get a proper response.
|
|
*/
|
|
self->i503 = 0;
|
|
iRet = SerialWriteRead(&self->pData, "V\r\n", pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (strstr(pReply, "ITC503") != NULL) {
|
|
self->i503 = 1;
|
|
}
|
|
|
|
if (!self->iReadOnly) {
|
|
/* switch to remote and locked operation */
|
|
iRet = SerialWriteRead(&self->pData, "C3\r\n", pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
|
|
/* set the control sensor, for this we need to switch A0 first,
|
|
the do it and switch back
|
|
*/
|
|
iRet = SerialWriteRead(&self->pData, "A0\r\n", pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
|
|
sprintf(pCommand, "H%1.1d\r\n", self->iControl);
|
|
iRet = SerialWriteRead(&self->pData, pCommand, pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
|
|
/* controls to automatic */
|
|
iRet = SerialWriteRead(&self->pData, "A3\r\n", pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
/* reset timeout */
|
|
iRet = SerialConfig(&self->pData, 10);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
void ITC4_Close(pITC4 * pData)
|
|
{
|
|
char pReply[132];
|
|
int iRet;
|
|
pITC4 self;
|
|
|
|
self = *pData;
|
|
|
|
/* switch to local operation */
|
|
iRet = SerialWriteRead(&self->pData, "C0\r\n", pReply, 131);
|
|
/* ignore errors on this one, the thing may be down */
|
|
|
|
/* close connection */
|
|
SerialClose(&self->pData);
|
|
|
|
/* free memory */
|
|
free(self);
|
|
*pData = NULL;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
int ITC4_Config(pITC4 * pData, int iTmo, int iRead, int iControl,
|
|
float fDiv, float fMult)
|
|
{
|
|
int iRet;
|
|
char pReply[132];
|
|
char pCommand[10];
|
|
pITC4 self;
|
|
|
|
self = *pData;
|
|
|
|
/* first timeout */
|
|
if (iTmo > 0) {
|
|
iRet = SerialConfig(&self->pData, iTmo);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
}
|
|
|
|
/* Read Sensor */
|
|
if ((iRead > 0) && (iRead < 5) && (self->iRead != iRead)) {
|
|
self->iRead = iRead;
|
|
}
|
|
|
|
/* Control Sensor */
|
|
if ((iControl > 0) && (iControl < 5)) {
|
|
/* set the control sensor, for this we need to switch A0 first,
|
|
the do it and switch back
|
|
*/
|
|
iRet = SerialWriteRead(&self->pData, "A0\r\n", pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
|
|
/* set sensor */
|
|
sprintf(pCommand, "H%1.1d\r\n", iControl);
|
|
iRet = SerialWriteRead(&self->pData, pCommand, pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
|
|
/* controls to automatic */
|
|
iRet = SerialWriteRead(&self->pData, "A3\r\n", pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
}
|
|
self->fDiv = fDiv;
|
|
self->fMult = fMult;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------------*/
|
|
int ITC4_Send(pITC4 * pData, char *pCommand, char *pReply, int iLen)
|
|
{
|
|
pITC4 self;
|
|
|
|
self = *pData;
|
|
|
|
/* make sure, that there is a \r at the end of the command */
|
|
if (strchr(pCommand, (int) '\r') == NULL) {
|
|
strcat(pCommand, "\r");
|
|
}
|
|
return SerialWriteRead(&self->pData, pCommand, pReply, iLen);
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
int ITC4_Read(pITC4 * pData, float *fVal)
|
|
{
|
|
char pCommand[10], pReply[132];
|
|
int iRet;
|
|
float fRead = -9999999.;
|
|
pITC4 self;
|
|
|
|
self = *pData;
|
|
|
|
|
|
/* format and send R command */
|
|
sprintf(pCommand, "R%1.1d\r\n", self->iRead);
|
|
iRet = SerialWriteRead(&self->pData, pCommand, pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
|
|
/* analyse reply */
|
|
if (pReply[0] != 'R') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
|
|
iRet = sscanf(&pReply[1], "%f", &fRead);
|
|
if (iRet != 1) {
|
|
return ITC4__BADREAD;
|
|
}
|
|
if (self->i503) {
|
|
*fVal = fRead;
|
|
} else {
|
|
*fVal = fRead / self->fDiv;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------*/
|
|
int ITC4_Set(pITC4 * pData, float fVal)
|
|
{
|
|
char pCommand[10], pReply[132];
|
|
int iRet, i, iRead;
|
|
const float fPrecision = 0.0001;
|
|
float fSet, fDelta, fRead, fDum;
|
|
pITC4 self;
|
|
int iSet;
|
|
|
|
self = *pData;
|
|
|
|
if (self->iReadOnly) {
|
|
return ITC4__READONLY;
|
|
}
|
|
|
|
/* format command */
|
|
if (self->i503) {
|
|
sprintf(pCommand, "T%-7.3f\r\n", fVal);
|
|
} else {
|
|
fSet = fVal;
|
|
iSet = (int) (fSet * self->fMult);
|
|
sprintf(pCommand, "T%5.5d\r\n", iSet);
|
|
}
|
|
|
|
/* try three times: send, read, test, if OK return, else
|
|
resend. This must be done because the ITC4 tends to loose
|
|
characters
|
|
*/
|
|
for (i = 0; i < 3; i++) {
|
|
/* send command */
|
|
iRet = SerialWriteRead(&self->pData, pCommand, pReply, 131);
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
if (pReply[0] == '?') {
|
|
strcpy(self->pAns, pReply);
|
|
return ITC4__BADCOM;
|
|
}
|
|
/* read the set value again */
|
|
iRead = self->iRead;
|
|
self->iRead = 0; /* make a R0 */
|
|
fDum = self->fDiv;
|
|
self->fDiv = self->fMult;
|
|
iRet = ITC4_Read(pData, &fRead);
|
|
self->iRead = iRead;
|
|
self->fDiv = fDum;
|
|
if (iRet != 1) {
|
|
return iRet;
|
|
}
|
|
/* check the value read back */
|
|
if (self->i503) {
|
|
fDelta = fRead - fVal;
|
|
} else {
|
|
fDelta = fRead - fSet;
|
|
}
|
|
if (fDelta < 0)
|
|
fDelta = -fDelta;
|
|
if (fDelta < fPrecision) {
|
|
/* Success, go home */
|
|
return 1;
|
|
}
|
|
}
|
|
return ITC4__BADSET;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------*/
|
|
void ITC4_ErrorTxt(pITC4 * pData, int iCode, char *pError, int iLen)
|
|
{
|
|
char pBueffel[512];
|
|
pITC4 self;
|
|
|
|
self = *pData;
|
|
|
|
switch (iCode) {
|
|
case ITC4__BADCOM:
|
|
sprintf(pBueffel, "ITC4: Invalid command or offline, got %s",
|
|
self->pAns);
|
|
strncpy(pError, pBueffel, iLen);
|
|
break;
|
|
case ITC4__BADPAR:
|
|
strncpy(pError, "ITC4: Invalid parameter specified", iLen);
|
|
break;
|
|
case ITC4__BADMALLOC:
|
|
strncpy(pError, "ITC4: Error allocating memory in ITC4", iLen);
|
|
break;
|
|
case ITC4__BADREAD:
|
|
strncpy(pError, "ITC4: Badly formatted answer", iLen);
|
|
break;
|
|
case ITC4__BADSET:
|
|
strncpy(pError,
|
|
"ITC4: Failed three times to write new set value to ITC4",
|
|
iLen);
|
|
break;
|
|
default:
|
|
SerialError(iCode, pError, iLen);
|
|
break;
|
|
}
|
|
}
|