linse/sicspsi
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Adapted indenation to new agreed upon system

Browse Source 
- Fixed bad status in poldi zug driver
This commit is contained in:
koennecke
2009-02-13 09:01:03 +00:00
parent 6c7bb14fad
commit eb72d5c486
151 changed files with 38234 additions and 38208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

420
ecbcounter.c
View File

@@ -19,21 +19,21 @@
/*------------------ our private data structure ------------------------*/
typedef struct {
pECB ecb; /* the ECB system we talk to */
unsigned char prescaler[8]; /* an array for the prescaler values */
int tfreq; /* timer frequency */
unsigned char control; /* marks the control monitor */
int state; /* current counting state */
}ECBCounter, *pECBCounter;
pECB ecb; /* the ECB system we talk to */
unsigned char prescaler[8]; /* an array for the prescaler values */
int tfreq; /* timer frequency */
unsigned char control; /* marks the control monitor */
int state; /* current counting state */
} ECBCounter, *pECBCounter;
/*----------------- private defines ------------------------------------*/
#define STFRD 137
#define STREAD 138
#define STOPS 136
#define STOPS 136
#define STCLEA 134
#define PRELOA 139
#define STLOAD 156
#define STCPRE 133
#define STCPRE 133
#define STARTS 135
#define SPCSTA 169
@@ -42,7 +42,7 @@ typedef struct {
#define COUNT 2
#define NOBEAM 3
/*--------------------------------------------------------------------*/
#define MAX_COUNT 4294967295.0
#define MAX_COUNT 4294967295.0
/*------------------ error codes --------------------------------------*/
#define COMMERROR -300
#define TOMANYCOUNTS -301
@@ -51,14 +51,15 @@ typedef struct {
#define INVALIDPRESCALER -305
#define BADFREQ -306
/*======================================================================*/
static int readScaler(pECBCounter pPriv, int scaler, int *count){
static int readScaler(pECBCounter pPriv, int scaler, int *count)
{
int status;
Z80_reg in, out;
Ecb_pack data;
in.c = (unsigned char)scaler;
status = ecbExecute(pPriv->ecb,STREAD,in,&out);
if(status != 1){
in.c = (unsigned char) scaler;
status = ecbExecute(pPriv->ecb, STREAD, in, &out);
if (status != 1) {
return COMMERROR;
}
@@ -66,23 +67,25 @@ static int readScaler(pECBCounter pPriv, int scaler, int *count){
data.b.byt2 = out.b;
data.b.byt1 = out.d;
data.b.byt0 = out.e;
if(scaler == 0){
*count = data.result/pPriv->tfreq;
if (scaler == 0) {
*count = data.result / pPriv->tfreq;
} else {
*count = data.result;
}
return 1;
}
/*---------------------------------------------------------------------------*/
static int readTime(pECBCounter pPriv,float *time){
static int readTime(pECBCounter pPriv, float *time)
{
int status;
Z80_reg in, out;
Ecb_pack data;
in.c = (unsigned char)0;
status = ecbExecute(pPriv->ecb,STREAD,in,&out);
if(status != 1){
in.c = (unsigned char) 0;
status = ecbExecute(pPriv->ecb, STREAD, in, &out);
if (status != 1) {
return COMMERROR;
}
@@ -90,124 +93,135 @@ static int readTime(pECBCounter pPriv,float *time){
data.b.byt2 = out.b;
data.b.byt1 = out.d;
data.b.byt0 = out.e;
*time = (float)data.result/(float)pPriv->tfreq;
*time = (float) data.result / (float) pPriv->tfreq;
return 1;
}
/*---------------------------------------------------------------------*/
static int check4Beam(struct __COUNTER *pCter, int *beam){
static int check4Beam(struct __COUNTER *pCter, int *beam)
{
Z80_reg in, out;
pECBCounter self = NULL;
int status;
self = (pECBCounter)pCter->pData;
self = (pECBCounter) pCter->pData;
assert(self);
in.c = 1;
status = ecbExecute(self->ecb,SPCSTA,in,&out);
if(status != 1){
status = ecbExecute(self->ecb, SPCSTA, in, &out);
if (status != 1) {
pCter->iErrorCode = COMMERROR;
return HWFault;
}
*beam = (int)out.d;
*beam = (int) out.d;
return 1;
}
/*----------------------------------------------------------------------*/
static int stopScalers(pECBCounter self){
static int stopScalers(pECBCounter self)
{
int status;
Z80_reg in, out;
status = ecbExecute(self->ecb,STOPS,in,&out);
if(status != 1){
status = ecbExecute(self->ecb, STOPS, in, &out);
if (status != 1) {
return COMMERROR;
}
return 1;
}
/*========================================================================
These two functions currently rely on the idea that the ECB stops
and starts without clearing counters in between. The sequence of
things necessary to start it, suggests this. If this is not the case then
this will not work.
===========================================================================*/
static int ECBPause(struct __COUNTER *self){
static int ECBPause(struct __COUNTER *self)
{
int status;
pECBCounter pPriv = NULL;
assert(self);
pPriv = (pECBCounter)self->pData;
pPriv = (pECBCounter) self->pData;
assert(pPriv);
if((status = stopScalers(pPriv)) <= 0){
if ((status = stopScalers(pPriv)) <= 0) {
self->iErrorCode = status;
return HWFault;
}
return OKOK;
}
/*=======================================================================*/
static int ECBContinue(struct __COUNTER *self){
static int ECBContinue(struct __COUNTER *self)
{
int status;
pECBCounter pPriv = NULL;
Z80_reg in, out;
assert(self);
pPriv = (pECBCounter)self->pData;
pPriv = (pECBCounter) self->pData;
assert(pPriv);
status = ecbExecute(pPriv->ecb,STARTS,in,&out);
if(status != 1){
status = ecbExecute(pPriv->ecb, STARTS, in, &out);
if (status != 1) {
self->iErrorCode = status;
return HWFault;
}
return OKOK;
}
/*=======================================================================*/
static int ECBHalt(struct __COUNTER *self){
static int ECBHalt(struct __COUNTER *self)
{
int status;
pECBCounter pPriv = NULL;
assert(self);
pPriv = (pECBCounter)self->pData;
pPriv = (pECBCounter) self->pData;
assert(pPriv);
pPriv->state = IDLE;
if((status = stopScalers(pPriv)) <= 0){
if ((status = stopScalers(pPriv)) <= 0) {
self->iErrorCode = status;
return HWFault;
}
return OKOK;
}
/*-----------------------------------------------------------------------*/
static int ECBGetStatus(struct __COUNTER *self, float *fControl){
pECBCounter pPriv = (pECBCounter)self->pData;
static int ECBGetStatus(struct __COUNTER *self, float *fControl)
{
pECBCounter pPriv = (pECBCounter) self->pData;
int status, result, scaler;
Z80_reg in, out;
int count, beam;
float time;
assert(pPriv);
/*
This can happen after a stop
*/
if(pPriv->state == IDLE){
This can happen after a stop
*/
if (pPriv->state == IDLE) {
return HWIdle;
}
/*
read status bit
*/
status = ecbExecute(pPriv->ecb,STFRD,in,&out);
if(status != 1){
read status bit
*/
status = ecbExecute(pPriv->ecb, STFRD, in, &out);
if (status != 1) {
self->iErrorCode = COMMERROR;
pPriv->state = IDLE;
return HWFault;
}
/*
read beam status
*/
status = check4Beam(self,&beam);
if(status != 1){
read beam status
*/
status = check4Beam(self, &beam);
if (status != 1) {
self->iErrorCode = COMMERROR;
return HWFault;
}
@@ -218,23 +232,23 @@ static int ECBGetStatus(struct __COUNTER *self, float *fControl){
the thing can be in. Complicated by the fact that the status becomes
idle (out.d = 0) when the measurement is paused due to the lack of
beam.
*/
if(pPriv->state == COUNT && beam == 1){
*/
if (pPriv->state == COUNT && beam == 1) {
ECBPause(self);
pPriv->state = NOBEAM;
SetStatus(eOutOfBeam);
result = HWNoBeam;
}
if(pPriv->state == NOBEAM && beam == 0){
if (pPriv->state == NOBEAM && beam == 0) {
ECBContinue(self);
pPriv->state = COUNT;
SetStatus(eCounting);
return HWBusy;
}
if(pPriv->state == NOBEAM && beam == 1){
if (pPriv->state == NOBEAM && beam == 1) {
return HWNoBeam;
}
if(out.d == 0 && pPriv->state == COUNT){
if (out.d == 0 && pPriv->state == COUNT) {
result = HWIdle;
pPriv->state = IDLE;
} else {
@@ -242,97 +256,105 @@ static int ECBGetStatus(struct __COUNTER *self, float *fControl){
}
/*
select which scaler to read
*/
if(self->eMode == eTimer){
select which scaler to read
*/
if (self->eMode == eTimer) {
scaler = 0;
readTime(pPriv,fControl);
}else {
readTime(pPriv, fControl);
} else {
scaler = pPriv->control;
readScaler(pPriv,scaler,&count);
*fControl = (float)count;
readScaler(pPriv, scaler, &count);
*fControl = (float) count;
}
if(*fControl > self->fPreset){
if (*fControl > self->fPreset) {
ECBHalt(self);
}
}
return result;
}
/*=====================================================================*/
static int clearScalers(pECBCounter self){
static int clearScalers(pECBCounter self)
{
int status;
Z80_reg in, out;
status = ecbExecute(self->ecb,STCLEA,in,&out);
if(status != 1){
status = ecbExecute(self->ecb, STCLEA, in, &out);
if (status != 1) {
return COMMERROR;
}
return 1;
}
/*----------------------------------------------------------------------*/
static int loadPrescalers(pECBCounter self){
static int loadPrescalers(pECBCounter self)
{
Z80_reg in, out;
int status, i;
for(i = 0; i < 8; i++){
in.c = (unsigned char)i;
for (i = 0; i < 8; i++) {
in.c = (unsigned char) i;
in.d = self->prescaler[i];
status = ecbExecute(self->ecb,PRELOA,in,&out);
if(status != 1){
status = ecbExecute(self->ecb, PRELOA, in, &out);
if (status != 1) {
return COMMERROR;
}
}
return 1;
}
/*----------------------------------------------------------------------*/
static int loadPreset(pECBCounter self, int preset, unsigned char control){
static int loadPreset(pECBCounter self, int preset, unsigned char control)
{
Z80_reg in, out;
Ecb_pack data;
int status, i;
data.result = preset;
in.c = data.b.byt3;
in.b = data.b.byt2;
in.e = data.b.byt1;
in.d = data.b.byt0;
status = ecbExecute(self->ecb,STLOAD,in,&out);
if(status != 1){
status = ecbExecute(self->ecb, STLOAD, in, &out);
if (status != 1) {
return COMMERROR;
}
in.b = data.b.byt2;
in.e = data.b.byt1;
in.d = data.b.byt0;
in.c = 4*control;
status = ecbExecute(self->ecb,STCPRE,in,&out);
if(status != 1){
in.c = 4 * control;
status = ecbExecute(self->ecb, STCPRE, in, &out);
if (status != 1) {
return COMMERROR;
}
return 1;
}
/*-----------------------------------------------------------------------*/
static int ECBStart(struct __COUNTER *self){
static int ECBStart(struct __COUNTER *self)
{
pECBCounter pPriv = NULL;
int preset, status, controlUnit;
Z80_reg in, out;
assert(self);
pPriv = (pECBCounter)self->pData;
pPriv = (pECBCounter) self->pData;
assert(pPriv);
/*
check if the preset is permissible
*/
preset = (int)rint(self->fPreset);
if(preset > MAX_COUNT){
check if the preset is permissible
*/
preset = (int) rint(self->fPreset);
if (preset > MAX_COUNT) {
self->iErrorCode = TOMANYCOUNTS;
return HWFault;
}
if(self->eMode == eTimer){
if (self->eMode == eTimer) {
controlUnit = 0;
preset *= pPriv->tfreq;
if(preset > MAX_COUNT){
preset *= pPriv->tfreq;
if (preset > MAX_COUNT) {
self->iErrorCode = TOMANYCOUNTS;
return HWFault;
}
@@ -340,107 +362,114 @@ static int ECBStart(struct __COUNTER *self){
controlUnit = pPriv->control;
}
if((status = stopScalers(pPriv)) <= 0){
if ((status = stopScalers(pPriv)) <= 0) {
self->iErrorCode = status;
return HWFault;
}
if((status = clearScalers(pPriv)) <= 0){
if ((status = clearScalers(pPriv)) <= 0) {
self->iErrorCode = status;
return HWFault;
}
if((status = loadPrescalers(pPriv)) <= 0){
if ((status = loadPrescalers(pPriv)) <= 0) {
self->iErrorCode = status;
return HWFault;
}
if((status = loadPreset(pPriv, preset,(unsigned char)controlUnit)) <= 0){
if ((status =
loadPreset(pPriv, preset, (unsigned char) controlUnit)) <= 0) {
self->iErrorCode = status;
return HWFault;
}
status = ecbExecute(pPriv->ecb,STARTS,in,&out);
if(status != 1){
status = ecbExecute(pPriv->ecb, STARTS, in, &out);
if (status != 1) {
self->iErrorCode = status;
return HWFault;
}
pPriv->state = COUNT;
return OKOK;
}
/*=======================================================================*/
static int ECBTransfer(struct __COUNTER *self){
static int ECBTransfer(struct __COUNTER *self)
{
int status, count, i;
pECBCounter pPriv = NULL;
assert(self);
pPriv = (pECBCounter)self->pData;
pPriv = (pECBCounter) self->pData;
assert(pPriv);
/*
read time
*/
status = readTime(pPriv,&self->fTime);
if(status <= 0){
read time
*/
status = readTime(pPriv, &self->fTime);
if (status <= 0) {
self->iErrorCode = COMMERROR;
return HWFault;
}
/*
read other scalers
*/
for(i = 1; i < 8; i++){
status = readScaler(pPriv,i,&count);
if(status <= 0){
read other scalers
*/
for (i = 1; i < 8; i++) {
status = readScaler(pPriv, i, &count);
if (status <= 0) {
self->iErrorCode = COMMERROR;
return HWFault;
}
self->lCounts[i-1] = count;
self->lCounts[i - 1] = count;
}
return OKOK;
}
/*======================================================================*/
static int ECBGetError(struct __COUNTER *self, int *iCode,
char *errorText, int errlen){
char *errorText, int errlen)
{
char pBueffel[132];
*iCode = self->iErrorCode;
switch(self->iErrorCode){
switch (self->iErrorCode) {
case COMMERROR:
strncpy(errorText,"Communication error with ECB",errlen);
strncpy(errorText, "Communication error with ECB", errlen);
break;
case TOMANYCOUNTS:
strncpy(errorText,"Preset is to high!",errlen);
strncpy(errorText, "Preset is to high!", errlen);
break;
case NOSEND:
strncpy(errorText,"Cannot send naked data to ECB",errlen);
strncpy(errorText, "Cannot send naked data to ECB", errlen);
break;
case UNKNOWNPAR:
strncpy(errorText,"parameter unknown",errlen);
strncpy(errorText, "parameter unknown", errlen);
break;
case INVALIDCOUNTER:
strncpy(errorText,"Invalid counter number requested, 0-7 allowed",
errlen);
strncpy(errorText, "Invalid counter number requested, 0-7 allowed",
errlen);
break;
case INVALIDPRESCALER:
strncpy(errorText,"Invalid prescaler value, allowed 1 or 10",
errlen);
strncpy(errorText, "Invalid prescaler value, allowed 1 or 10", errlen);
break;
case BADFREQ:
strncpy(errorText,"Bad timer frequency: 10 or 1000 allowed",errlen);
strncpy(errorText, "Bad timer frequency: 10 or 1000 allowed", errlen);
break;
default:
sprintf(pBueffel,"Unknown error code %d", self->iErrorCode);
strncpy(errorText,pBueffel,errlen);
sprintf(pBueffel, "Unknown error code %d", self->iErrorCode);
strncpy(errorText, pBueffel, errlen);
break;
}
return 1;
}
/*=======================================================================*/
static int ECBFixIt(struct __COUNTER *self, int iCode){
static int ECBFixIt(struct __COUNTER *self, int iCode)
{
return COTERM;
}
/*======================================================================*/
/*******************************************************************************
@@ -449,72 +478,71 @@ static int ECBFixIt(struct __COUNTER *self, int iCode){
* of f.ex a motor position. 'divide' specifies how many times the po-
* sition is to be divided by two before it is displayed.
******************************************************************************/
static void
Dot_divide (int device, int data, pECB ecb)
static void Dot_divide(int device, int data, pECB ecb)
{
int function, dot, divide;
Z80_reg x_inreg, out;
if (data == 0) /* If zero, dont send dot/divide) */
if (data == 0) /* If zero, dont send dot/divide) */
return;
dot = 0;
while ((data%10) == 0)
{
dot++;
data /= 10;
}
while ((data % 10) == 0) {
dot++;
data /= 10;
}
divide = 0;
while ((data%2) == 0)
{
divide++;
data /= 2;
}
if (data != 1) /* If != 1, not a binary No. */
while ((data % 2) == 0) {
divide++;
data /= 2;
}
if (data != 1) /* If != 1, not a binary No. */
return;
if (dot > 0)
dot = 8 - dot;
x_inreg.c = 0; /* Specify input */
x_inreg.c = 0; /* Specify input */
x_inreg.b = (unsigned char) device;
x_inreg.d = (unsigned char) dot; /* Dot position */
x_inreg.e = (unsigned char) divide; /* No. of times to divide by 2 */
x_inreg.d = (unsigned char) dot; /* Dot position */
x_inreg.e = (unsigned char) divide; /* No. of times to divide by 2 */
ecbExecute(ecb,170,x_inreg,&out);
ecbExecute(ecb, 170, x_inreg, &out);
return;
}
/*-----------------------------------------------------------------------*/
static int ECBSet(struct __COUNTER *self, char *name,
int iCter, float fVal){
static int ECBSet(struct __COUNTER *self, char *name,
int iCter, float fVal)
{
pECBCounter pPriv = NULL;
int iVal;
assert(self);
pPriv = (pECBCounter)self->pData;
pPriv = (pECBCounter) self->pData;
assert(pPriv);
iVal = (int)rint(fVal);
iVal = (int) rint(fVal);
if(strcmp(name,"prescaler") == 0){
if(iCter < 0 || iCter > 7){
if (strcmp(name, "prescaler") == 0) {
if (iCter < 0 || iCter > 7) {
self->iErrorCode = INVALIDCOUNTER;
return HWFault;
}
if(iVal != 1 && iVal != 10){
if (iVal != 1 && iVal != 10) {
self->iErrorCode = INVALIDPRESCALER;
return HWFault;
}
pPriv->prescaler[iCter] = (unsigned char)iVal;
pPriv->prescaler[iCter] = (unsigned char) iVal;
return OKOK;
} else if(strcmp(name,"tfreq") == 0){
if(fVal == 1000){
} else if (strcmp(name, "tfreq") == 0) {
if (fVal == 1000) {
pPriv->prescaler[0] = 1;
pPriv->tfreq = 1000;
Dot_divide(64,1000,pPriv->ecb);
Dot_divide(64, 1000, pPriv->ecb);
return OKOK;
} else if(fVal == 10){
} else if (fVal == 10) {
pPriv->tfreq = 10;
pPriv->prescaler[0] = 10;
Dot_divide(64,10,pPriv->ecb);
Dot_divide(64, 10, pPriv->ecb);
return OKOK;
} else {
self->iErrorCode = BADFREQ;
@@ -525,59 +553,65 @@ static int ECBSet(struct __COUNTER *self, char *name,
return HWFault;
}
}
/*===================================================================*/
static int ECBGet(struct __COUNTER *self, char *name,
int iCter, float *fVal){
static int ECBGet(struct __COUNTER *self, char *name,
int iCter, float *fVal)
{
pECBCounter pPriv = NULL;
assert(self);
pPriv = (pECBCounter)self->pData;
pPriv = (pECBCounter) self->pData;
assert(pPriv);
if(strcmp(name,"prescaler") == 0){
*fVal = (float)pPriv->prescaler[iCter];
if (strcmp(name, "prescaler") == 0) {
*fVal = (float) pPriv->prescaler[iCter];
return OKOK;
} else if(strcmp(name,"tfreq") == 0){
*fVal = (float)pPriv->tfreq;
} else if (strcmp(name, "tfreq") == 0) {
*fVal = (float) pPriv->tfreq;
return OKOK;
} else{
} else {
self->iErrorCode = UNKNOWNPAR;
return HWFault;
}
}
}
/*=====================================================================*/
static int ECBSend(struct __COUNTER *self, char *text,
char *reply, int replylen){
strncpy(reply,"ECB does not feast on ASCII strings, refused!",
replylen);
static int ECBSend(struct __COUNTER *self, char *text,
char *reply, int replylen)
{
strncpy(reply, "ECB does not feast on ASCII strings, refused!",
replylen);
return OKOK;
}
/*====================================================================*/
pCounterDriver MakeECBCounter(char *ecb){
pCounterDriver MakeECBCounter(char *ecb)
{
pECBCounter pPriv = NULL;
pCounterDriver self = NULL;
int i;
/*
memory for everybody
*/
self = CreateCounterDriver("ecb","ecb");
pPriv = (pECBCounter)malloc(sizeof(ECBCounter));
if(self == NULL || pPriv == NULL){
memory for everybody
*/
self = CreateCounterDriver("ecb", "ecb");
pPriv = (pECBCounter) malloc(sizeof(ECBCounter));
if (self == NULL || pPriv == NULL) {
return NULL;
}
memset(pPriv,0,sizeof(ECBCounter));
memset(pPriv, 0, sizeof(ECBCounter));
/*
initialize private data structure
*/
pPriv->ecb = (pECB)FindCommandData(pServ->pSics,ecb,"ECB");
if(pPriv->ecb == NULL){
initialize private data structure
*/
pPriv->ecb = (pECB) FindCommandData(pServ->pSics, ecb, "ECB");
if (pPriv->ecb == NULL) {
DeleteCounterDriver(self);
free(pPriv);
return NULL;
}
for(i = 0; i < 8; i++){
for (i = 0; i < 8; i++) {
pPriv->prescaler[i] = 1;
}
pPriv->tfreq = 1000;
@@ -585,19 +619,19 @@ pCounterDriver MakeECBCounter(char *ecb){
/*
assign function pointers
*/
self->GetStatus = ECBGetStatus;
self->Start = ECBStart;
self->Pause = ECBPause;
self->Continue = ECBContinue;
self->Halt = ECBHalt;
self->ReadValues = ECBTransfer;
self->GetError = ECBGetError;
assign function pointers
*/
self->GetStatus = ECBGetStatus;
self->Start = ECBStart;
self->Pause = ECBPause;
self->Continue = ECBContinue;
self->Halt = ECBHalt;
self->ReadValues = ECBTransfer;
self->GetError = ECBGetError;
self->TryAndFixIt = ECBFixIt;
self->Set = ECBSet;
self->Get = ECBGet;
self->Send = ECBSend;
self->Set = ECBSet;
self->Get = ECBGet;
self->Send = ECBSend;
self->KillPrivate = NULL;
self->iNoOfMonitors = 8;