диплом / 8_ПЗ06151

Приложение г

Листинг результирующей программы

#pragma DB OE SB CD OR LC LA

#pragma ot(9, SIZE)

#include "xa0.h"

#ifndef __isheader

#define __global

#define __comment /##/

#else

#define __global extern

#define _at_ ;/##/

#define __comment

#endif

#ifdef __isheader

#include <cF120.h>

#ifndef STRINGHINCLUDED

#define STRINGHINCLUDED

#include <string.h>

#endif

#define CodeAddr(x) 0x50##x

#define CalibrAddr(x) 0xe4##x

#define ModemAddr(x) 0xe##x##00

#define ModemBufAddr(x) 0xa##x

#define _RAMSavedLoc 0x100

#define _ROMSavedLoc 0xf000

#define _ZFSavedBytes 0x60

#define FFLOATBLANK BlankSpace.FloatBlank

#define IINTBLANK BlankSpace.IntBlank

#define BBOOLBLANK BlankSpace.BoolBlank

#define false 0

#define true 1

#define FALSE 0

#define TRUE 1

#define NULL 0

#define DEVICE_MC8_125

#endif

__global xdata union{

float FloatBlank;

int IntBlank;

unsigned char BoolBlank;

}BlankSpace;

__global xdata char _INNUM;

__global xdata char _OUTNUM;

__global xdata unsigned char begram _at_ 0x0;

__global data char NullFuncReserve1[40] _at_ 0x0;

__global data char NullFuncReserve2[77] _at_ 0x30;

// Analog inputs

__global xdata float AI[8] _at_ 0x01;

__comment #define AI(x) AI[x]

__global code float Ureference _at_ CalibrAddr(18);

__global code float Coefs[8][5] _at_ CalibrAddr(1c);

__comment #define T50 0

__comment #define T1000 1

__comment #define T10k 2

__comment #define C20 3

__comment #define V10 4

// Analog outputs

__comment #define _DACCount 2

__global xdata float AO[_DACCount] _at_ 0xc14;

__comment #define AO(x) AO[x]

__global xdata unsigned char _MANUALAO _at_ 0x104;

__comment #define DACManual _MANUALAO

__global xdata float DACLimits[_DACCount][2] _at_ 0x105;

__global xdata unsigned int dacs[_DACCount] _at_ 0x5e4;

__global code float DACSet[_DACCount][4] _at_ CalibrAddr(bc);

__global xdata float DACf[_DACCount] _at_ 0xc00;

__global xdata unsigned char DI[4] _at_ 0xc08;

__global xdata unsigned char DO[8] _at_ 0xc0c;

__global xdata unsigned char ManualOnMask _at_ 0x102;

__global xdata unsigned char ManualOffMask _at_ 0x103;

__global xdata unsigned char DigOutsManual[2] _at_ 0x102;

__global xdata unsigned char calendar[7] _at_ 0x4d;

__global xdata unsigned int WatchDogAlg _at_ 0x66;

__global xdata unsigned char _CycleInterval _at_ 0x155;

__comment #define _CYCLE (((float)_CycleInterval)/100.0)

__comment #define _CYCLEINT _CycleInterval

__comment #define temtba 0x1feb

__comment #define temtra 0x1fff

__global code unsigned char ModemParTable _at_ ModemAddr(0);

__global code unsigned char ModemErrTable _at_ ModemAddr(1);

__comment #define _PARPAGELOC CodeAddr(01)

__global code unsigned short AddrPlannerStruct _at_ CodeAddr(06);

__global xdata char NeZanimat[1792] _at_ 0x500;

__comment #define TempZoneSize 5092

__global xdata char TempZone[1] _at_ 0xc1c;

__global bdata char Dinputs _at_ 0x22;

__global bdata char Doutputs _at_ 0x23;

__global bdata char _INIT_BITS _at_ 0x28;

#ifndef __isheader

sbit ED = P3 ^ 5;

sbit SLAVE = P3 ^ 7;

// Digital inputs

#define DI(x) Dinput_##x

sbit Dinput_0 = Dinputs^0;

sbit Dinput_1 = Dinputs^1;

sbit Dinput_2 = Dinputs^2;

sbit Dinput_3 = Dinputs^3;

//Digital outputs

#define DO(x) Doutput_##x

sbit Doutput_0 = Doutputs^0;

sbit Doutput_1 = Doutputs^1;

sbit Doutput_2 = Doutputs^2;

sbit Doutput_3 = Doutputs^3;

sbit Doutput_4 = Doutputs^4;

sbit Doutput_5 = Doutputs^5;

sbit Doutput_6 = Doutputs^6;

sbit Doutput_7 = Doutputs^7;

sbit _Inited = _INIT_BITS^0;

sbit _UART1_Inited = _INIT_BITS^1;

sbit _10ms_Inited = _INIT_BITS^2;

data int _Save_Command _at_ 0x38;

data unsigned char *getptr _at_ 0x30;

data unsigned char *copyptr _at_ 0x33;

void DACNorm(unsigned char OutputNum, float inp)

{

if(!(DACManual & 1<<OutputNum))

DACf[OutputNum] = inp;

}

void _DACService()

{

#define xdata

unsigned char i;

for(i = 0; i < _DACCount; i++)

DACNorm(i, AO(i));

}

xdata float xdata* FFLOATPTR;

xdata unsigned int xdata* IINTPTR;

xdata unsigned char xdata* BBOOLPTR;

#endif

#ifdef __isheader

struct Timers{

unsigned char Status;

unsigned long Delay;

};

struct TPWMConfig{

unsigned char CoupleNum :4;

unsigned char Open :1;

unsigned char Close :1;

unsigned char Stop :1;

unsigned char Used :1;

unsigned long delay;

long sum;

unsigned int pulsetime;

unsigned int backlash :9;

unsigned int pause :1;

unsigned int up :1;

unsigned int down :1;

unsigned int st :1;

unsigned int rt :1;

unsigned int OldOpen :1;

unsigned int OldClose :1;

};

#endif

xdata char RAMCheckByte _at_ 0x1dff;

#define VOLATILE(x) ((x < 0xb6) || (x >= (0xb6 + 50)))

__comment #define BOOLCOUNTO 36

__global xdata unsigned char BOOLARRO[36] _at_ 0xc1c;

__comment #define INTCOUNTO 11

__global xdata int INTARRO[11] _at_ 0xc40;

__comment #define FLOATCOUNTO 21

__global xdata float FLOATARRO[21] _at_ 0xc56;

__comment #define PWM2COUNTO 1

__global xdata unsigned char PWM2ARRO[1] _at_ 0xcaa;

__comment #define BOOLCOUNTAO 1

__global xdata unsigned char BOOLARRAO[1] _at_ 0xcab;

__comment #define _ALLTHESTATICS 0

__comment #define _ALLTHERETAINS 0

__global xdata unsigned char _ARR0[12];

__global xdata unsigned char _ARR1[9];

__global xdata float X53327236_TIME;

__global xdata unsigned char X53327236_STATE;

__global xdata float X53376856_YIN_1;

__global xdata float X53376856_XN_1;

__global xdata float X53376856_YD1N_1;

__global xdata float X53376856_YAN_1;

__global xdata float X53376856_YULM;

__global xdata unsigned char X53700776_PREVIOUS;

__global xdata unsigned char X34078064_FAUL;

__global xdata float X34078064_INPUTN_1;

__global xdata float X34078064_STORAGE;

__global xdata unsigned char X34078064_FLAG;

__global xdata unsigned char X34078064_EXCN_1;

__global xdata unsigned char X25528264_FAUL;

__global xdata float X25528264_INPUTN_1;

__global xdata float X25528264_STORAGE;

__global xdata unsigned char X25528264_FLAG;

__global xdata unsigned char X25528264_EXCN_1;

__global xdata int X53634564_COUNT;

__global xdata int X53610812_COUNT;

__global xdata int X53797644_COUNT;

__global xdata int X53831064_COUNT;

__global xdata int X53412616_BLOCKID;

__global xdata int X53414548_BLOCKID;

__global xdata int X53415124_BLOCKID;

__global xdata int X48414408_BLOCKID;

__global xdata int X53741192_BLOCKID;

__global xdata int X53460520_BLOCKID;

__global xdata int X48422568_BLOCKID;

__global xdata int X48436796_BLOCKID;

__global xdata int X48438080_BLOCKID;

__global xdata int X48453704_BLOCKID;

__global xdata int X48503916_BLOCKID;

__global xdata int X48585676_BLOCKID;

__global xdata int X48577916_BLOCKID;

__global xdata int X48395640_BLOCKID;

__global xdata int X48450212_BLOCKID;

__global xdata int X53604948_COUNT;

__global xdata int X53516744_COUNT;

__global xdata int X53568164_COUNT;

__global xdata float X53536616_TIME;

__global xdata unsigned char X53536616_ZN_1;

#define IS_SLAVE false

//--------------Piecewise-linear approximation--------------

#ifndef USEPIECEWISE

#define USEPIECEWISE

void _PIECEWISE(float CurrentX, float* Y, char* XS, char* YS)

{

#define xdata

float Result;

unsigned char Count;

float *Xtable, *Ytable;

unsigned char Amount, XAmount, YAmount;

XAmount = XS[0];

YAmount = YS[0];

Amount = (XAmount < YAmount) ? XAmount : YAmount;

Xtable = (float*)&XS[1];

Ytable = (float*)&YS[1];

if (CurrentX<Xtable[0]) {*Y = Ytable[0]; return;}

if (CurrentX>=Xtable[Amount-1]) {*Y = Ytable[Amount-1]; return;}

for (Count=0; Count<Amount-1; Count++)

{

if ((CurrentX>=Xtable[Count])&&(CurrentX<Xtable[Count+1]))

{

Result=((Ytable[Count+1]-Ytable[Count])*(CurrentX-Xtable[Count]))/(Xtable[Count+1]-Xtable[Count])+Ytable[Count];

break;

}

*Y = Result;

}

#endif

#ifndef USEPULSESFLUS

#define USEPULSESFLUS

xdata float _PULSESFLUS_TIME;

xdata unsigned char _PULSESFLUS_STATE;

void _PULSESFLUS(unsigned char Q, unsigned char* Z, float X, float T)

{

#define xdata

float realx;

if(X > 100)

X = 100;

if(X < 0)

X = 0;

if(!_Inited) {

_PULSESFLUS_TIME = 0;

_PULSESFLUS_STATE = false;

}

if(Q) {

if(_PULSESFLUS_TIME > 0)

_PULSESFLUS_TIME -= _CYCLE;

else {

realx = (_PULSESFLUS_STATE) ? 100-X : X;

_PULSESFLUS_TIME = T * realx / 100;

_PULSESFLUS_STATE = !_PULSESFLUS_STATE;

if(_PULSESFLUS_TIME > 0)

*Z = _PULSESFLUS_STATE;

}

else{

*Z = _PULSESFLUS_STATE = false;

_PULSESFLUS_TIME = 0;

}

#endif

//-------------------------------------------------

// Period - mS

// Analog - %

//-------------------------------------------------

#ifndef USEPWM2

#define USEPWM2

xdata float _PWM2_TIME;

xdata unsigned char _PWM2_STATE;

void _PWM2(float PeriodF, float Analog, unsigned char* Copy)

{

_PULSESFLUS_TIME = _PWM2_TIME;

_PULSESFLUS_STATE = _PWM2_STATE;

_PULSESFLUS(true, Copy, Analog, PeriodF);

_PWM2_TIME = _PULSESFLUS_TIME;

_PWM2_STATE = _PULSESFLUS_STATE;

}

#endif

//-------------------------------------------------

#ifndef USEUNBALANSE

#define USEUNBALANSE

#define _UNBALANSE(X1, X2, Y) Y=X1-(X2)

#endif

//-----------Filter Block------------------------------------

#ifndef USEFILTER

#define USEFILTER

void _FILTER(float INPUT, float* OUTPUT, float TF)

{

if(!_Inited)

*OUTPUT = INPUT;

else{

if(TF > _CYCLE)

{

(*OUTPUT) += ((INPUT - (*OUTPUT))*_CYCLE)/(TF + _CYCLE);

}

else

(*OUTPUT) = INPUT;

}

#endif

//-----------------------------------------------------------

#ifndef USEVALUEVAR

#define USEVALUEVAR

#define _VALUEVAR(x, y) y=x

#endif

//-----------PDD' Block--------------------------------------

#ifndef USEPDD

#define USEPDD

xdata float _PDD_XN_1, _PDD_YD1N_1, _PDD_YAN_1;

void _PDD(float YIN, float INPUT, unsigned char MANUAL, float* OUTPUT, float KP, float TI, float D, float YDN, float YUP)

{

#define xdata

float Xn;

float Yp;

float Yd;

float Yan;

float Yd1n;

float Yd2;

float Td;

if(TI < 1) TI = 1;

if(D < 0) D = 0;

Xn = KP*INPUT;

if(!_Inited)

{

_PDD_YD1N_1 = _PDD_YAN_1 = 0;

_PDD_XN_1 = Xn;

}

if(MANUAL)

{

Yp = Yd = 0;

_PDD_XN_1 = Xn;

Yan = 8.0*Xn;

_PDD_YD1N_1 = 0;

}

else{

if (YIN > YUP) {

if (KP > 0)

Yp = (INPUT > 0) ? 0 : (Xn*_CYCLE)/TI;

else

Yp = (INPUT < 0) ? 0 : (Xn*_CYCLE)/TI;

}

else if(YIN < YDN) {

if (KP > 0)

Yp = (INPUT < 0) ? 0 : (Xn*_CYCLE)/TI;

else

Yp = (INPUT > 0) ? 0 : (Xn*_CYCLE)/TI;

}

else

Yp=(Xn*_CYCLE)/TI;

Yd = Xn - _PDD_XN_1;

Td = D*TI;

Yan = _PDD_YAN_1 + ((Xn*8.0 - _PDD_YAN_1)/(1.0 + Td/(_CYCLE*8.0)));

}

Yd1n = Xn*8.0 - Yan;

Yd2 = Yd1n - _PDD_YD1N_1;

(*OUTPUT) = Yp + Yd + Yd2;

_PDD_XN_1 = Xn;

_PDD_YAN_1 = Yan;

_PDD_YD1N_1 = Yd1n;

}

#endif

//------------Dead zone block--------------------------------

#ifndef USEDEADZONE

#define USEDEADZONE

void _DEADZONE(float INPUT, float* OUTPUT, float DEADZONE)

{

if(DEADZONE < 0) DEADZONE = 0;

if ((INPUT >= DEADZONE/2) || (INPUT <= (-DEADZONE)/2))

{

if (INPUT >= DEADZONE/2)

(*OUTPUT) = INPUT - DEADZONE/2;

if (INPUT <= (-DEADZONE)/2.0)

(*OUTPUT) = INPUT + DEADZONE/2;

}

else

(*OUTPUT) = 0;

}

#endif

//-----------Integrator Block--------------------------------

#ifndef USEINTEGRATOR

#define USEINTEGRATOR

xdata float _INTEGRATOR_YIN_1;

void _INTEGRATOR(float DYIN, float* YIN, unsigned char OFF)

{

if(!_Inited) {

#ifdef DEVICE_MC8_125

if (VOLATILE (YIN))

_INTEGRATOR_YIN_1 = 0;

else

_INTEGRATOR_YIN_1 = *YIN;

#else

_INTEGRATOR_YIN_1 = 0;

#endif

}

*YIN = _INTEGRATOR_YIN_1;

if(!OFF)

(*YIN) += DYIN;

_INTEGRATOR_YIN_1 = (*YIN);

}

#endif

//-----------Saturation Block--------------------------------

#ifndef USESATURATION

#define USESATURATION

void _SATURATION(float INPUT, float* OUTPUT, float YDN, float YUP)

{

if ( INPUT > YUP )

(*OUTPUT) = YUP;

else if ( INPUT < YDN )

(*OUTPUT) = YDN;

else

(*OUTPUT) = INPUT;

}

#endif

//-------------PID Regulator Block---------------------------

#ifndef USEPID2AOOVR

#define USEPID2AOOVR

xdata float _PID2AOOVR_YIN_1;

xdata float _PID2AOOVR_XN_1, _PID2AOOVR_YD1N_1, _PID2AOOVR_YAN_1;

xdata float _PID2AOOVR_YULM;

void _PID2AOOVR(float INPUT, float* OUTPUT, float* YULM, unsigned char ManualMode, float DEADZONE, float KP, float TI,

float D, float YDN, float YUP, unsigned char OWR, float SET)

{

code mask[4]={1,2,0x10,0x20};

#define xdata

float _DEADZONE_OUTPUT;

float _PDD_OUTPUT;

float ydn, yup;

unsigned char MANUAL, ExternManual;

if(!_Inited)

_PID2AOOVR_YULM = 0.0;

if (_OUTNUM >= 0) {

#if defined DEVICE_MC5

ydn = DACLimits [0];

yup = DACLimits [1];

#elif defined DEVICE_MC8_125

if(_OUTNUM<2)

{

ydn = DACLimits [_OUTNUM][0];

yup = DACLimits [_OUTNUM][1];

}

else

{

ydn = 0;

yup = 100;

}

#endif

}

else {

ydn = YDN;

yup = YUP;

}

ExternManual = (_OUTNUM >= 0) ? (_MANUALAO & mask[_OUTNUM]):false;

// ExternManual = (_OUTNUM >= 0) ? (_MANUALAO & (1<<_OUTNUM)):false;

MANUAL = ManualMode || ExternManual;

_DEADZONE(INPUT, &_DEADZONE_OUTPUT, DEADZONE);

_PDD_XN_1 = _PID2AOOVR_XN_1;

_PDD_YD1N_1 = _PID2AOOVR_YD1N_1;

_PDD_YAN_1 = _PID2AOOVR_YAN_1;

_PDD(_PID2AOOVR_YULM, _DEADZONE_OUTPUT, MANUAL, &_PDD_OUTPUT, KP, TI, D, ydn, yup);

_PID2AOOVR_XN_1 = _PDD_XN_1;

_PID2AOOVR_YD1N_1 = _PDD_YD1N_1;

_PID2AOOVR_YAN_1 = _PDD_YAN_1;

_INTEGRATOR_YIN_1 = _PID2AOOVR_YIN_1;

_INTEGRATOR(_PDD_OUTPUT, &_PID2AOOVR_YULM, OWR || ExternManual);

if(!ExternManual)

_PID2AOOVR_YIN_1 = OWR ? SET : _INTEGRATOR_YIN_1;

else

_PID2AOOVR_YIN_1 = DACf[_OUTNUM];

_SATURATION(_PID2AOOVR_YULM, OUTPUT, ydn, yup);

*YULM = _PID2AOOVR_YULM;

}

#endif

#ifndef USEMULT

#define USEMULT

void _MULT(unsigned char* X, float* Y)

{

#define xdata

int i;

float Result;

float xdata* InpArr;

if(X != NULL)

{

Result = 1;

InpArr = (float*)&X[1];

for(i = 0; i < X[0]; i++)

Result *= InpArr[i];

*Y = Result;

}

#endif

//-------conditional operator----------

#ifndef USECONDITIONAL

#define USECONDITIONAL

#define _CONDITIONAL(X1, X2, Q, Y) Y=Q?X1:X2

#endif

//-----------------------------------------------------------

#ifndef USEOR

#define USEOR

void _OR(unsigned char* X, unsigned char* Y)

{

#define xdata

int i;

unsigned char Result;

unsigned char* InpArr;

if(X != NULL)

{

Result = false;

InpArr = (unsigned char*)&X[1];

for(i = 0; i < X[0]; i++)

Result = Result||InpArr[i];

*Y = Result;

}

#endif

//-----------------------------------------------------------

#ifndef USEBOOLVAR

#define USEBOOLVAR

#define _BOOLVAR(x, y) y=x

#endif

//-------conditional operator----------

#ifndef USECONDB

#define USECONDB

#define _CONDB(X1, X2, Q, Y) Y=Q?X1:X2

#endif

#ifndef USEBUTTON

#define USEBUTTON

xdata char _BUTTON_PREVIOUS;

unsigned char _BUTTON(unsigned char Q, unsigned char *Z)

{

*Z = Q;

if(Q&&!_BUTTON_PREVIOUS)

{

Q = false;

_Save_Command = 0x5555;

}

_BUTTON_PREVIOUS=*Z;

return Q;

}

#endif

//------------------------------------------------------

#ifndef USESPLITFLOAT

#define USESPLITFLOAT

//------------------------------------------------------

struct FloatExpAndMan

{

short exponent;

float mantissa;

};

union FloatBitStruct

{

float value;

long bits;

};

void SplitFloat(float value, struct FloatExpAndMan *result)

{

#define xdata

union FloatBitStruct bitStruct;

bitStruct.value = value;

result->exponent = (short) ( ( bitStruct.bits >> 23) & 0x000000ff ) - 0x7e;

bitStruct.bits &= 0x807fffff;

bitStruct.bits |= 0x3f000000;

result->mantissa = bitStruct.value;

}

//------------------------------------------------------

#endif

//------------------------------------------------------

#ifndef USELN

#define USELN

void _LN (float x, float *y)

{

const float code a0 = -2.1724098;

const float code a1 = 4.1744959;

const float code a2 = -2.8551644;

const float code a3 = 8.5375156E-1;

const float code LN2 = 0.6931572;

struct FloatExpAndMan xdata xExpAndMan;

if(x <= 0)

{

*y = 0;

return;

}

SplitFloat(x, &xExpAndMan);

*y = (a0 + a1*xExpAndMan.mantissa +

a2*xExpAndMan.mantissa*xExpAndMan.mantissa +

a3*xExpAndMan.mantissa*xExpAndMan.mantissa*xExpAndMan.mantissa) +

LN2*xExpAndMan.exponent;

}

#endif

//---------------Thermister function-----------------------------------------------

#ifndef USETHERMISTOR

#define USETHERMISTOR

void _THERMISTOR(float INPUT, float* CEL, float* FAR, int TYPE)

{

#define ThermA2 1.129241E-3

#define ThermB2 2.341077E-4

#define ThermC2 8.775468E-8

#define ThermA3 1.028444E-3

#define ThermB3 2.392435E-4

#define ThermC3 1.562216E-7

#define xdata

float b;

xdata float RT;

float RealTemp;

float ThermA, ThermB, ThermC;

#ifdef DEVICE_MC8_125

PSBANK=0x21;

#endif

if (INPUT)

RT = Coefs[_INNUM][T10k]/(Ureference/INPUT - 1);

else

RT = 0;

#ifdef DEVICE_MC8_125

PSBANK=0x11;

#endif

if(TYPE==3)

{

ThermA = ThermA3;

ThermB = ThermB3;

ThermC = ThermC3;

}

else{

ThermA = ThermA2;

ThermB = ThermB2;

ThermC = ThermC2;

}

if(RT > 0.0)

{

_LN(RT, &b);

RealTemp = 1/(ThermA + ThermB*b + ThermC*b*b*b) - 273.16;

}

else

RealTemp = -273.16;

*CEL = RealTemp;

*FAR = RealTemp*1.8 + 32;

}

#endif

//---------------Thermister function-----------------------------------------------

#ifndef USETHERMISTORBR

#define USETHERMISTORBR

xdata unsigned char _THERMISTORBR_FAUL;

xdata float _THERMISTORBR_INPUTN_1;

xdata float _THERMISTORBR_STORAGE;

xdata unsigned char _THERMISTORBR_FLAG;

xdata unsigned char _THERMISTORBR_EXCN_1;

void _THERMISTORBR(float INPUT, float* CEL, float* FAR, unsigned char *FAULT, int TYPE)

{

#define xdata

float Temp;

float Speed;

unsigned char Faul;

unsigned char Exceeding;

float ShortCircuitLimit, BreakLimit;

#ifdef DEVICE_MC5

ShortCircuitLimit = 10;

BreakLimit = 0.95*Ureference;

#else

ShortCircuitLimit = 5;

BreakLimit = 2400;

#endif

#define _THERMISTORBR_MAX_SPEED 400

if (!_Inited) {

_THERMISTORBR_FAUL = false;

_THERMISTORBR_INPUTN_1 = INPUT;

_THERMISTORBR_STORAGE = 0;

_THERMISTORBR_FLAG = false;

_THERMISTORBR_EXCN_1 = false;

}

Faul = (INPUT < ShortCircuitLimit) || (INPUT > BreakLimit);

Speed = (INPUT - _THERMISTORBR_INPUTN_1) / _CYCLE;

if (Speed < 0)

Speed = -1 * Speed;

Exceeding = (Speed > _THERMISTORBR_MAX_SPEED);

if (((Faul && !(_THERMISTORBR_FAUL & 0x1f)) && !Exceeding && !(_THERMISTORBR_EXCN_1 & 0x3)) ||

(Exceeding && !_THERMISTORBR_FLAG && !(_THERMISTORBR_FAUL & 0x1f))) {

if (Exceeding)

_THERMISTORBR_FLAG = true;

_THERMISTORBR_STORAGE = _THERMISTORBR_INPUTN_1;

}

if (!Exceeding || Faul)

_THERMISTORBR_FLAG = false;

if (_THERMISTORBR_FLAG || Faul || (_THERMISTORBR_EXCN_1 & 0x3) || (_THERMISTORBR_FAUL & 0x3))

Temp = _THERMISTORBR_STORAGE;

else

Temp = INPUT;

_THERMISTOR (Temp, CEL, FAR, TYPE);

*FAULT = Faul && (_THERMISTORBR_FAUL & 1);

_THERMISTORBR_INPUTN_1 = INPUT;

_THERMISTORBR_FAUL = _THERMISTORBR_FAUL << 1;

if (Faul)

_THERMISTORBR_FAUL |= 1;

_THERMISTORBR_EXCN_1 = _THERMISTORBR_EXCN_1 << 1;

if (Exceeding)

_THERMISTORBR_EXCN_1 |= 1;

}

#endif

//-----------Alarm forming function----------------

#ifndef USEALARMFORM

#define USEALARMFORM

xdata int _ALARMFORM_COUNT;

void _ALARMFORM(unsigned char Q, unsigned char* Z, int Increment,

int Decrement, int Limit, unsigned char Reset)

{

if(!_Inited || Reset)

_ALARMFORM_COUNT = 0;

if(Increment < 1)

Increment = 1;

if(Decrement < 0)

Decrement = 0;

if(Limit < 1)

Limit = 1;

if(Q)

{

_ALARMFORM_COUNT += Increment;

if(_ALARMFORM_COUNT >= Limit)

{

*Z = !Reset;

_ALARMFORM_COUNT = Limit;

}

else if(Reset)

*Z = false;

}

else{

_ALARMFORM_COUNT -= Decrement;

if(_ALARMFORM_COUNT <= 0)

{

*Z = false;

_ALARMFORM_COUNT = 0;

}

#endif

#ifndef USERSTRIGGER

#define USERSTRIGGER

void _RSTRIGGER(unsigned char Set, unsigned char Reset, unsigned char* Y)

{

if(Set)

*Y = true;

if(Reset)

*Y = false;

}

#endif

//-------------------------------------------------

#ifndef USENOT

#define USENOT

#define _NOT(Q, Z) Z=!Q

#endif

//------------------------------------------------------------

#ifndef USEAND

#define USEAND

void _AND(unsigned char* X, unsigned char* Y)

{

#define xdata

int i;

unsigned char Result;

unsigned char* InpArr;

if(X != NULL)

{

Result = true;

InpArr = (unsigned char*)&X[1];

for(i = 0; i < X[0]; i++)

Result = Result&&InpArr[i];

*Y = Result;

}

#endif

#ifndef USEPC485SERVICE

#define USEPC485SERVICE

#ifndef STDIOHINCLUDED

#define STDIOHINCLUDED

#include <stdio.h>

#endif

#ifndef STDLIBHINCLUDED

#define STDLIBHINCLUDED

#include <stdlib.h>

#endif

#define PROTOCESSORFFP485_1AR "DA_AV_02"

#define PROTOCESSORFFP485_2AR "DA_BV_02"

#define PROTOCESSORFFP485_WF true

#define PROTOCESSORFFP485_RF false

#define PROTOCESSORFFP485_WERR -2

#define PROTOCESSORFFP485_LERR -1

xdata unsigned char TimeoutCounter;

xdata unsigned int CommandOK;

xdata unsigned int BlocksCount;

xdata unsigned char uart1obuf [256] _at_ 0xa00;

xdata unsigned char uart1ibuf [256] _at_ 0xb00;

unsigned char *uart1optr;

unsigned char *uart1iptr;

unsigned char uart1ocount;

unsigned char uart1icount;

//-------------------------------------------------------------------------

void _PC485SERVICE(void)

{

if (SCON1&1)

{

*uart1iptr++=SBUF1;

uart1icount++;

SCON1&=0xfc;

}

if (SCON1&2)

{

SCON1&=0xfd;

if (uart1ocount)

{

SBUF1=*uart1optr++; uart1ocount--;

}

//---------------------------------------------------------------------------

unsigned char SendToProtocessorFFP485 (unsigned char OutBytes)

{

if (!TimeoutCounter) {

memset (uart1ibuf, 0, 100);

uart1optr = &uart1obuf; uart1iptr = &uart1ibuf; uart1icount = 0;

uart1ocount = OutBytes;

SFRPAGE=1; SBUF1 = *uart1optr++; uart1ocount--; SFRPAGE=0;

}

TimeoutCounter++;

if (uart1icount > 0 && uart1ibuf[uart1icount - 1] == 0x0D)

return true;

}

//---------------------------------------------------------------------------

void FormQueryFrame (unsigned char Wr, unsigned char Destination, int Offset, const void *Data, unsigned char *Format, unsigned char *OutBytes)

{

uart1obuf[0] = ':'; uart1obuf[1] = Wr ? 'W' : 'R'; uart1obuf[2] = 'D';

uart1obuf[3] = '-'; uart1obuf[4] = 'N'; uart1obuf[5] = 'A';

uart1obuf[6] = ':';

*OutBytes = 7;

switch (Destination) {

case 1: memcpy (&uart1obuf[7], PROTOCESSORFFP485_1AR, strlen (PROTOCESSORFFP485_1AR));

(*OutBytes) += strlen (PROTOCESSORFFP485_1AR);

break;

case 2: memcpy (&uart1obuf[7], PROTOCESSORFFP485_2AR, strlen (PROTOCESSORFFP485_2AR));

(*OutBytes) += strlen (PROTOCESSORFFP485_2AR);

break;

default: break;

}

uart1obuf[(*OutBytes)++] = ',';

uart1obuf[(*OutBytes)++] = 'O';

uart1obuf[(*OutBytes)++] = 'F';

uart1obuf[(*OutBytes)++] = ':';

(*OutBytes) += sprintf (&uart1obuf[*OutBytes], "%d", Offset);

if (Wr) {

uart1obuf[(*OutBytes)++] = ',';

uart1obuf[(*OutBytes)++] = 'V';

uart1obuf[(*OutBytes)++] = 'A';

uart1obuf[(*OutBytes)++] = ':';

switch (Format[0]) {

case 'D': (*OutBytes) += sprintf (&uart1obuf[*OutBytes], "%d", *((int *)Data));

break;

case 'U': (*OutBytes) += sprintf (&uart1obuf[*OutBytes], "%u", *((unsigned int *)Data));

break;

case 'F': (*OutBytes) += sprintf (&uart1obuf[*OutBytes], "%f", *((float *)Data));

break;

default: (*OutBytes) += sprintf (&uart1obuf[*OutBytes], "%d", (int)*((unsigned char *)Data));

break;

}

switch (Format[0]) {

case 'D': uart1obuf[(*OutBytes)++] = ',';

uart1obuf[(*OutBytes)++] = 'F';

uart1obuf[(*OutBytes)++] = 'M';

uart1obuf[(*OutBytes)++] = 'T';

uart1obuf[(*OutBytes)++] = ':';

uart1obuf[(*OutBytes)++] = 'D';

break;

case 'U': uart1obuf[(*OutBytes)++] = ',';

uart1obuf[(*OutBytes)++] = 'F';

uart1obuf[(*OutBytes)++] = 'M';

uart1obuf[(*OutBytes)++] = 'T';

uart1obuf[(*OutBytes)++] = ':';

uart1obuf[(*OutBytes)++] = 'U';

break;

case 'F': uart1obuf[(*OutBytes)++] = ',';

uart1obuf[(*OutBytes)++] = 'F';

uart1obuf[(*OutBytes)++] = 'M';

uart1obuf[(*OutBytes)++] = 'T';

uart1obuf[(*OutBytes)++] = ':';

uart1obuf[(*OutBytes)++] = 'F';

break;

default: break;

}

uart1obuf[(*OutBytes)++] = 0x0D;

}

//-------------------------------------------------------------

/*void ResetOut (unsigned char *Format, void *Out)

{

switch (Format[0]) {

case 'D':

case 'U':

*((int *)Out) = 0;

break;

case 'F': *((float *)Out) = 0;

break;

default: *((unsigned char *)Out) = 0;

break;

}

}*/

//-------------------------------------------------------------

void DecodeResponse (unsigned char Wr, int *Error, unsigned char *Format, void *Out)

{

if (!strncmp(uart1ibuf, ":ERR", 4)) {

*Error = atoi (&uart1ibuf[4]);//sscanf (&uart1ibuf[4], "%d", Error);

// ResetOut (Format, Out);

return;

}

if (Wr) {

if (strncmp(uart1ibuf, ":OK", 3) && !*Error) {

*Error = PROTOCESSORFFP485_WERR;

}

return;

}

switch (Format[0]) {

case 'D': *((int *)Out) = atoi (&uart1ibuf[1]);//sscanf (&uart1ibuf[1], "%d", ((int *)Out));

break;

case 'U': *((int *)Out) = atoi (&uart1ibuf[1]);//sscanf (&uart1ibuf[1], "%u", ((unsigned int *)Out));

break;

case 'F': *((float *)Out) = atof (&uart1ibuf[1]);//sscanf (&uart1ibuf[1], "%f", ((float *)Out));

break;

default: *((unsigned char *)Out) = atoi (&uart1ibuf[1]);//sscanf (&uart1ibuf[1], "%c", ((unsigned char *)Out));

break;

}

#endif

#ifndef USEPC485INIT

#define USEPC485INIT

void _PC485INIT(void)

{

BlocksCount = 1; TimeoutCounter=0; CommandOK=0; SFRPAGE=1; SCON1=0x10; SFRPAGE=0; CKCON=1; TH1=0x70; //CycleCnt=0;

}

#endif

#ifndef USEPC485WRITEANALOG

#define USEPC485WRITEANALOG

xdata unsigned int _PC485WRITEANALOG_BLOCKID;

void _PC485WRITEANALOG(int Offset, float Data, unsigned char Wrpr, int *Error)

{

#define xdata

unsigned char result = false;

unsigned char Outbytes;

if (!_Inited)

_PC485WRITEANALOG_BLOCKID = BlocksCount++;

if (Wrpr && CommandOK != _PC485WRITEANALOG_BLOCKID)

return;

if (CommandOK == 0 || CommandOK == _PC485WRITEANALOG_BLOCKID) {

CommandOK = _PC485WRITEANALOG_BLOCKID;

FormQueryFrame (PROTOCESSORFFP485_WF, 1, Offset, (void *)&Data, "F", &Outbytes);

result = SendToProtocessorFFP485 (Outbytes);

if (result) {

*Error = 0;

DecodeResponse (PROTOCESSORFFP485_WF, Error, "F", NULL);

TimeoutCounter = 0;

CommandOK = 0;

}

if (TimeoutCounter > 10) {

TimeoutCounter = 0;

CommandOK = 0;

*Error = PROTOCESSORFFP485_LERR;

}

#endif

#ifndef USEPC485READANALOG

#define USEPC485READANALOG

xdata unsigned int _PC485READANALOG_BLOCKID;

void _PC485READANALOG(int Offset, float *Out, int *Error)

{

#define xdata

unsigned char result = false;

unsigned char Outbytes;

if (!_Inited)

_PC485READANALOG_BLOCKID = BlocksCount++;

if (CommandOK == 0 || CommandOK == _PC485READANALOG_BLOCKID) {

CommandOK = _PC485READANALOG_BLOCKID;

FormQueryFrame (PROTOCESSORFFP485_RF, 1, Offset, NULL, "F", &Outbytes);

result = SendToProtocessorFFP485 (Outbytes);

if (result) {

*Error = 0;

DecodeResponse (PROTOCESSORFFP485_RF, Error, "F", (void *)Out);

TimeoutCounter = 0;

CommandOK = 0;

}

if (TimeoutCounter > 10) {

TimeoutCounter = 0;

CommandOK = 0;

*Error = PROTOCESSORFFP485_LERR;

}

#endif

#ifndef USEEQUALI

#define USEEQUALI

#define _EQUALI(X1,X2,Z) Z=(X1==(X2))

#endif

//-------------------------------------------------------------

#ifndef USENOR

#define USENOR

void _NOR(unsigned char* X, unsigned char* Y)

{

#define xdata

int i;

unsigned char Result;

unsigned char* InpArr;

if(X != NULL)

{

Result = false;

InpArr = (unsigned char*)&X[1];

for(i = 0; i < X[0]; i++)

Result = Result||InpArr[i];

*Y = !Result;

}

#endif

#ifndef USEPC485READBIT

#define USEPC485READBIT

xdata unsigned int _PC485READBIT_BLOCKID;

void _PC485READBIT(int Offset, unsigned char *Out, int *Error)

{

#define xdata

unsigned char result = false;

unsigned char Outbytes;

if (!_Inited)

_PC485READBIT_BLOCKID = BlocksCount++;

if (CommandOK == 0 || CommandOK == _PC485READBIT_BLOCKID) {

CommandOK = _PC485READBIT_BLOCKID;

FormQueryFrame (PROTOCESSORFFP485_RF, 2, Offset, NULL, NULL, &Outbytes);

result = SendToProtocessorFFP485 (Outbytes);

if (result) {

*Error = 0;

DecodeResponse (PROTOCESSORFFP485_RF, Error, NULL, (void *)Out);

TimeoutCounter = 0;

CommandOK = 0;

}

if (TimeoutCounter > 10) {

TimeoutCounter = 0;

CommandOK = 0;

*Error = PROTOCESSORFFP485_LERR;

}

#endif

#ifndef USEPC485WRITEBIT

#define USEPC485WRITEBIT

xdata unsigned int _PC485WRITEBIT_BLOCKID;

void _PC485WRITEBIT(int Offset, unsigned char Data, unsigned char Wrpr, int *Error)

{

#define xdata

unsigned char result = false;

unsigned char Outbytes;

if (!_Inited)

_PC485WRITEBIT_BLOCKID = BlocksCount++;

if (Wrpr && CommandOK != _PC485WRITEBIT_BLOCKID)

return;

if (CommandOK == 0 || CommandOK == _PC485WRITEBIT_BLOCKID) {

CommandOK = _PC485WRITEBIT_BLOCKID;

FormQueryFrame (PROTOCESSORFFP485_WF, 2, Offset, (void *)&Data, NULL, &Outbytes);

result = SendToProtocessorFFP485 (Outbytes);

if (result) {

*Error = 0;

DecodeResponse (PROTOCESSORFFP485_WF, Error, NULL, NULL);

TimeoutCounter = 0;

CommandOK = 0;

}

if (TimeoutCounter > 10) {

TimeoutCounter = 0;

CommandOK = 0;

*Error = PROTOCESSORFFP485_LERR;

}

#endif

//-----------------------------------------------------------

#ifndef USEDECODER

#define USEDECODER

void _DECODER(int X, unsigned char* Z)

{

#define xdata

int i;

unsigned char* OutArr = &Z[1];

for(i = 0; i < Z[0]; i++)

OutArr[i] = ( (X & (1 << i)) != false );

}

#endif

#ifndef USESANTISHORT

#define USESANTISHORT

xdata float _ANTISHORT_TIME;

xdata unsigned char _ANTISHORT_ZN_1;

void _ANTISHORT (unsigned char Q, float MinOn, float MinOff, unsigned char *Z)

{

if (!_Inited) {

_ANTISHORT_TIME = 0;

_ANTISHORT_ZN_1 = false;

}

_ANTISHORT_TIME -= _CYCLE;

if (_ANTISHORT_TIME <= 0)

*Z = Q;

if (*Z && !_ANTISHORT_ZN_1)

_ANTISHORT_TIME = MinOn;

if (!(*Z) && _ANTISHORT_ZN_1)

_ANTISHORT_TIME = MinOff;

_ANTISHORT_ZN_1 = *Z;

}

#endif

//------------------------------------------------------------

void _10ms_func()

{

#define xdata

char _SAVE_INNUM, _SAVE_OUTNUM;

_10ms_Inited = true;

}

//--------------------------------------------------------

void TENMS()

{

_10ms_func();

}

//-------------------------------------------------

#if defined(DEVICE_ME20) || defined(DEVICE_MC5) || defined(DEVICE_MC6) || defined(DEVICE_MR8M)

xdata unsigned char _int_1ms_count;

#endif

void _1ms_func()

{

#define xdata

char _SAVE_INNUM, _SAVE_OUTNUM;

#if defined(DEVICE_ME20) || defined(DEVICE_MC5) || defined(DEVICE_MC1) || defined(DEVICE_MR8M)

_int_1ms_count++;

if(_int_1ms_count >= 10)

{

_int_1ms_count = 0;

quasi_10ms_func();

}

#endif

}

//---------------------------------------------------------

void ONEMS()

{

_1ms_func();

}

//------------------------------------------------------

void UART1_func()

{

_PC485SERVICE();

SCON1 &= 0xfc;

}

//--------------------------------------------------------

void UART1()

{

UART1_func();

}

//-----------Initialization unit----------------

#ifndef STRINGHINCLUDED

#define STRINGHINCLUDED

#include <string.h>

#endif

void INIT_func()

{

#define xdata

int _counter;

#ifdef _TimesCount

struct Timers xdata *TimersPtr;

#endif

/* #ifdef BOOLCOUNTO

for(_counter = 0; _counter < BOOLCOUNTO; _counter++)

BOOLARRO[_counter] = 0;

#endif

#ifdef BOOLCOUNTN

for(_counter = 0; _counter < BOOLCOUNTN; _counter++)

BOOLARRN[_counter] = 0;

#endif

#ifdef INTCOUNTO

for(_counter = 0; _counter < INTCOUNTO; _counter++)

INTARRO[_counter] = 0;

#endif

#ifdef INTCOUNTN

for(_counter = 0; _counter < INTCOUNTN; _counter++)

INTARRN[_counter] = 0;

#endif

#ifdef FLOATCOUNTO

for(_counter = 0; _counter < FLOATCOUNTO; _counter++)

FLOATARRO[_counter] = 0;

#endif

#ifdef FLOATCOUNTN

for(_counter = 0; _counter < FLOATCOUNTN; _counter++)

FLOATARRN[_counter] = 0;

#endif

#ifdef TIMECOUNTO

for(_counter = 0; _counter < TIMECOUNTO; _counter++)

TIMEARRO[_counter] = 0;

#endif

#ifdef TIMECOUNTN

for(_counter = 0; _counter < TIMECOUNTN; _counter++)

TIMEARRN[_counter] = 0;

#endif

#ifdef DATECOUNTO

for(_counter = 0; _counter < DATECOUNTO; _counter++)

DATEARRO[_counter] = 0;

#endif

#ifdef DATECOUNTN

for(_counter = 0; _counter < DATECOUNTN; _counter++)

DATEARRN[_counter] = 0;

#endif

#ifdef BOOLCOUNTAO

for(_counter = 0; _counter < BOOLCOUNTAO; _counter++)

BOOLARRAO[_counter] = 0;

#endif

#ifdef BOOLCOUNTAN

for(_counter = 0; _counter < BOOLCOUNTAN; _counter++)

BOOLARRAN[_counter] = 0;

#endif

#ifdef INTCOUNTAO

for(_counter = 0; _counter < INTCOUNTAO; _counter++)

INTARRAO[_counter] = 0;

#endif

#ifdef INTCOUNTAN

for(_counter = 0; _counter < INTCOUNTAN; _counter++)

INTARRAN[_counter] = 0;

#endif

#ifdef FLOATCOUNTAO

for(_counter = 0; _counter < FLOATCOUNTAO; _counter++)

FLOATARRAO[_counter] = 0;

#endif

#ifdef FLOATCOUNTAN

for(_counter = 0; _counter < FLOATCOUNTAN; _counter++)

FLOATARRAN[_counter] = 0;

#endif

#ifdef DATECOUNTAO

for(_counter = 0; _counter < DATECOUNTAO; _counter++)

DATEARRAO[_counter] = 0;

#endif

#ifdef DATECOUNTAN

for(_counter = 0; _counter < DATECOUNTAN; _counter++)

DATEARRAN[_counter] = 0;

#endif

#ifdef TIMECOUNTAO

for(_counter = 0; _counter < TIMECOUNTAO; _counter++)

TIMEARRAO[_counter] = 0;

#endif

#ifdef TIMECOUNTAN

for(_counter = 0; _counter < TIMECOUNTAN; _counter++)

TIMEARRAN[_counter] = 0;

#endif*/

memset(TempZone, 0, TempZoneSize);

#ifdef _TimesCount

TimersPtr = &begram + AddrTimerStruct;

for(_counter = 0; _counter < _TimesCount; _counter++)

{

TimersPtr->Status = 0;

TimersPtr->Delay = 0;

TimersPtr++;

}

#endif

#ifdef _DACCount

for(_counter = 0; _counter < _DACCount; _counter++)

AO(_counter)=0;

#endif

_INNUM = -1;

_OUTNUM = -1;

_PC485INIT();

#if defined(DEVICE_MC8)

#ifdef IS_SLAVE

SLAVE = IS_SLAVE;

#endif

_Inited = false;

_10ms_Inited = false;

}

//----------------------------------------------------

void INIT()

{

INIT_func();

}

//----------Getting Digital Inputs--------------------

void _GETDIS()

{

DI[0] = Dinput_0;

DI[1] = Dinput_1;

DI[2] = Dinput_2;

DI[3] = Dinput_3;

}

//-------------------------------------------------------------------

typedef void (*MagicFuncTyp)(void);

#include <intrins.h>

xdata int CheckAllTheFloats_i;

xdata unsigned char CheckAllTheFloats_ch_res;

xdata MagicFuncTyp CheckAllTheFloats_MagicFunc;

xdata unsigned char CheckAllTheFloats_Counter;

xdata unsigned char CheckAllTheFloats_OK;

void CheckAllTheFloats()

{

if(!_Inited)

CheckAllTheFloats_Counter = 0;

CheckAllTheFloats_OK = true;

#ifdef FLOATCOUNTO

for(CheckAllTheFloats_i=0; CheckAllTheFloats_i<FLOATCOUNTO;CheckAllTheFloats_i++)

{

CheckAllTheFloats_ch_res = _chkfloat_(FLOATARRO[CheckAllTheFloats_i]);

if(!(CheckAllTheFloats_ch_res==0 || CheckAllTheFloats_ch_res==1))

{

if(CheckAllTheFloats_Counter > 100)

{

CheckAllTheFloats_MagicFunc = 0;

CheckAllTheFloats_MagicFunc();

}

else{

FLOATARRO[CheckAllTheFloats_i] = 0;

if(CheckAllTheFloats_OK)

CheckAllTheFloats_Counter++;

}

CheckAllTheFloats_OK = false;

}

if(CheckAllTheFloats_OK)

CheckAllTheFloats_Counter = 0;

#endif

#ifdef FLOATCOUNTL

for(CheckAllTheFloats_i=0; CheckAllTheFloats_i<FLOATCOUNTL;CheckAllTheFloats_i++)

{

CheckAllTheFloats_ch_res = _chkfloat_(FLOATARRL[CheckAllTheFloats_i]);

if(!(CheckAllTheFloats_ch_res==0 || CheckAllTheFloats_ch_res==1))

{

if(CheckAllTheFloats_Counter > 100)

{

CheckAllTheFloats_MagicFunc = 0;

CheckAllTheFloats_MagicFunc();

}

else{

FLOATARRL[CheckAllTheFloats_i] = 0;

if(CheckAllTheFloats_OK)

CheckAllTheFloats_Counter++;

}

CheckAllTheFloats_OK = false;

}

if(CheckAllTheFloats_OK)

CheckAllTheFloats_Counter = 0;

#endif

#ifdef FLOATCOUNTN

for(CheckAllTheFloats_i=0;CheckAllTheFloats_i<FLOATCOUNTN;CheckAllTheFloats_i++)

{

CheckAllTheFloats_ch_res = _chkfloat_(FLOATARRN[CheckAllTheFloats_i]);

if(!(CheckAllTheFloats_ch_res==0 || CheckAllTheFloats_ch_res==1))

FLOATARRN[CheckAllTheFloats_i] = 0;

}

#endif

#ifdef FCELLCOUNT

for(CheckAllTheFloats_i=0;CheckAllTheFloats_i<FCELLCOUNT;CheckAllTheFloats_i++)

{

CheckAllTheFloats_ch_res = _chkfloat_(FLOATCELLS[CheckAllTheFloats_i]);

if(!(CheckAllTheFloats_ch_res==0 || CheckAllTheFloats_ch_res==1))

FLOATCELLS[CheckAllTheFloats_i] = 0;

}

#endif

}

//-------------------------------------------------------------------

xdata unsigned int RestoreStatics_Counter;

#define _StaticsWithZF (_ALLTHESTATICS + _ZFSavedBytes)

xdata char _RAMSavedPtr[_StaticsWithZF] _at_ _RAMSavedLoc;

code char _ROMSavedPtr[_StaticsWithZF] _at_ _ROMSavedLoc;

void RestoreStatics()

{

xdata int i;

xdata unsigned char OK;

#ifdef DEVICE_MC8_125

PSBANK=0x21;

#endif

if(!_Inited)

RestoreStatics_Counter = 0;

OK = true;

for(i = 0; i < _StaticsWithZF; i++)

{

if(_RAMSavedPtr[i] != _ROMSavedPtr[i])

{

RestoreStatics_Counter++;

OK = false;

break;

}

if(OK)

RestoreStatics_Counter = 0;

if(RestoreStatics_Counter > (6000/_CYCLEINT))

{

for(i = 0; i < _StaticsWithZF; i++)

_RAMSavedPtr[i] = _ROMSavedPtr[i];

RestoreStatics_Counter = 0;

}

#ifdef DEVICE_MC8_125

PSBANK=0x11;

#endif

}

//-------------------------------------------------------------------

#if _ALLTHERETAINS>0

xdata char _RAMRetainPtr[_ALLTHERETAINS] _at_ _RAMSavedLoc;

code char _ROMRetainPtr[_ALLTHERETAINS] _at_ _ROMSavedLoc;

void SaveRetains()

{

#define xdata

int i;

#ifdef DEVICE_MC8_125

PSBANK=0x21;

#endif

for(i = 0; i < _ALLTHERETAINS; i++)

{

if(_RAMRetainPtr[i+_ALLTHESTATICS] != _ROMRetainPtr[i+_ALLTHESTATICS])

{

_Save_Command = 0x5555;

break;

}

#ifdef DEVICE_MC8_125

PSBANK=0x11;

#endif

}

#endif

//-------------------------------------------------------------------

void main_func()

{

#define xdata

char _SAVE_INNUM, _SAVE_OUTNUM;

static unsigned char CylclesPassed;

if(CylclesPassed < 3)

{

CylclesPassed++;

return;

}

#if _ALLTHESTATICS>0

RestoreStatics();

#endif

#if _ALLTHERETAINS>0

SaveRetains();

#endif

CheckAllTheFloats();

_GETDIS();

#ifdef DEVICE_MC5

_ADCService();

#endif

#ifdef DEVICE_MC1

_ADCService();

#endif

#ifdef DEVICE_MC6

_ADCService();

#endif

_CONDITIONAL(-1,1,FALSE,FLOATARRO[9]);

_BUTTON_PREVIOUS = X53700776_PREVIOUS;

_BUTTON(FALSE,&BOOLARRO[3]);

X53700776_PREVIOUS = _BUTTON_PREVIOUS;

_BOOLVAR(FALSE,BOOLARRO[4]);

_VALUEVAR(0,FLOATARRO[16]);

_VALUEVAR(0,FLOATARRO[17]);

_VALUEVAR(0,FLOATARRO[18]);

_VALUEVAR(0,FLOATARRO[19]);

_THERMISTORBR_FAUL = X34078064_FAUL;

_THERMISTORBR_INPUTN_1 = X34078064_INPUTN_1;

_THERMISTORBR_STORAGE = X34078064_STORAGE;

_THERMISTORBR_FLAG = X34078064_FLAG;

_THERMISTORBR_EXCN_1 = X34078064_EXCN_1;

_SAVE_INNUM = _INNUM;

_INNUM = 0;

_THERMISTORBR(AI(0),&FFLOATBLANK,&FFLOATBLANK,&BBOOLBLANK,0);

X34078064_FAUL = _THERMISTORBR_FAUL;

X34078064_INPUTN_1 = _THERMISTORBR_INPUTN_1;

X34078064_STORAGE = _THERMISTORBR_STORAGE;

X34078064_FLAG = _THERMISTORBR_FLAG;

X34078064_EXCN_1 = _THERMISTORBR_EXCN_1;

_INNUM = _SAVE_INNUM;

_THERMISTORBR_FAUL = X25528264_FAUL;

_THERMISTORBR_INPUTN_1 = X25528264_INPUTN_1;

_THERMISTORBR_STORAGE = X25528264_STORAGE;

_THERMISTORBR_FLAG = X25528264_FLAG;

_THERMISTORBR_EXCN_1 = X25528264_EXCN_1;

_SAVE_INNUM = _INNUM;

_INNUM = 1;

_THERMISTORBR(AI(1),&FLOATARRO[20],&FFLOATBLANK,&BOOLARRO[5],0);

X25528264_FAUL = _THERMISTORBR_FAUL;

X25528264_INPUTN_1 = _THERMISTORBR_INPUTN_1;

X25528264_STORAGE = _THERMISTORBR_STORAGE;

X25528264_FLAG = _THERMISTORBR_FLAG;

X25528264_EXCN_1 = _THERMISTORBR_EXCN_1;

_INNUM = _SAVE_INNUM;

_BOOLVAR(BOOLARRO[3],BOOLARRO[13]);

_PC485WRITEANALOG_BLOCKID = X53412616_BLOCKID;

_PC485WRITEANALOG(0,FLOATARRO[19],FALSE,&INTARRO[0]);

X53412616_BLOCKID = _PC485WRITEANALOG_BLOCKID;

_PC485READANALOG_BLOCKID = X53414548_BLOCKID;

_PC485READANALOG(0,&FFLOATBLANK,&INTARRO[1]);

X53414548_BLOCKID = _PC485READANALOG_BLOCKID;

_PC485WRITEANALOG_BLOCKID = X53415124_BLOCKID;

_PC485WRITEANALOG(0,FLOATARRO[18],FALSE,&INTARRO[2]);

X53415124_BLOCKID = _PC485WRITEANALOG_BLOCKID;

_EQUALI(INTARRO[0],0,BOOLARRO[19]);

_EQUALI(INTARRO[2],0,BOOLARRO[21]);

_PC485READBIT_BLOCKID = X48414408_BLOCKID;

_PC485READBIT(0,&BBOOLBLANK,&INTARRO[3]);

X48414408_BLOCKID = _PC485READBIT_BLOCKID;

_PC485READBIT_BLOCKID = X53741192_BLOCKID;

_PC485READBIT(0,&BBOOLBLANK,&INTARRO[4]);

X53741192_BLOCKID = _PC485READBIT_BLOCKID;

_PC485READBIT_BLOCKID = X53460520_BLOCKID;

_PC485READBIT(0,&BBOOLBLANK,&INTARRO[5]);

X53460520_BLOCKID = _PC485READBIT_BLOCKID;

_PC485READANALOG_BLOCKID = X48422568_BLOCKID;

_PC485READANALOG(0,&FFLOATBLANK,&INTARRO[6]);

X48422568_BLOCKID = _PC485READANALOG_BLOCKID;

_PC485WRITEBIT_BLOCKID = X48436796_BLOCKID;

_PC485WRITEBIT(0,FALSE,FALSE,&INTARRO[7]);

X48436796_BLOCKID = _PC485WRITEBIT_BLOCKID;

_PC485WRITEBIT_BLOCKID = X48438080_BLOCKID;

_PC485WRITEBIT(0,FALSE,FALSE,&INTARRO[8]);

X48438080_BLOCKID = _PC485WRITEBIT_BLOCKID;

_EQUALI(INTARRO[8],0,BOOLARRO[23]);

_EQUALI(INTARRO[3],0,BOOLARRO[26]);

_EQUALI(INTARRO[4],0,BOOLARRO[27]);

_PC485READANALOG_BLOCKID = X48503916_BLOCKID;

_PC485READANALOG(0,&FFLOATBLANK,&INTARRO[10]);

X48503916_BLOCKID = _PC485READANALOG_BLOCKID;

_EQUALI(INTARRO[5],0,BOOLARRO[28]);

_EQUALI(INTARRO[1],0,BOOLARRO[29]);

_EQUALI(INTARRO[6],0,BOOLARRO[30]);

_PC485WRITEANALOG_BLOCKID = X48585676_BLOCKID;

_PC485WRITEANALOG(0,0,FALSE,&IINTBLANK);

X48585676_BLOCKID = _PC485WRITEANALOG_BLOCKID;

_PC485WRITEBIT_BLOCKID = X48577916_BLOCKID;

_PC485WRITEBIT(0,FALSE,FALSE,&IINTBLANK);

X48577916_BLOCKID = _PC485WRITEBIT_BLOCKID;

_PC485READANALOG_BLOCKID = X48395640_BLOCKID;

_PC485READANALOG(0,&FFLOATBLANK,&IINTBLANK);

X48395640_BLOCKID = _PC485READANALOG_BLOCKID;

_PC485READBIT_BLOCKID = X48450212_BLOCKID;

_PC485READBIT(0,&BBOOLBLANK,&IINTBLANK);

X48450212_BLOCKID = _PC485READBIT_BLOCKID;

_NOT(BOOLARRO[4],BOOLARRO[31]);

_ARR0[0] = 1;

_DECODER(0,_ARR0);

BBOOLPTR = (unsigned char*)&_ARR0[1];

BOOLARRAO[0] = *BBOOLPTR;

_ALARMFORM_COUNT = X53604948_COUNT;

_SAVE_INNUM = _INNUM;

_INNUM = 1;

_ALARMFORM(DI(1),&BOOLARRO[32],0,0,0,BOOLARRO[3]);

X53604948_COUNT = _ALARMFORM_COUNT;

_INNUM = _SAVE_INNUM;

_ALARMFORM_COUNT = X53516744_COUNT;

_SAVE_INNUM = _INNUM;

_INNUM = 0;

_ALARMFORM(DI(0),&BOOLARRO[33],0,0,0,BOOLARRO[3]);

X53516744_COUNT = _ALARMFORM_COUNT;

_INNUM = _SAVE_INNUM;

_ALARMFORM_COUNT = X53568164_COUNT;

_SAVE_INNUM = _INNUM;

_INNUM = 2;

_ALARMFORM(DI(2),&BOOLARRO[34],0,0,0,BOOLARRO[3]);

X53568164_COUNT = _ALARMFORM_COUNT;

_INNUM = _SAVE_INNUM;

_ANTISHORT_TIME = X53536616_TIME;

_ANTISHORT_ZN_1 = X53536616_ZN_1;

_SAVE_INNUM = _INNUM;

_INNUM = 3;

_ANTISHORT(DI(3),0,0,&BOOLARRO[35]);

X53536616_TIME = _ANTISHORT_TIME;

X53536616_ZN_1 = _ANTISHORT_ZN_1;

_INNUM = _SAVE_INNUM;

_ARR0[0] = 1;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = 0;

_ARR1[0] = 1;

FFLOATPTR = (float*)&_ARR1[1];

*FFLOATPTR = 0;

_PIECEWISE(FLOATARRO[19],&FLOATARRO[2],_ARR0,_ARR1);

_VALUEVAR(FLOATARRO[2],FLOATARRO[5]);

_VALUEVAR(FLOATARRO[20],FLOATARRO[6]);

_ARR0[0] = 2;

BBOOLPTR = (unsigned char*)&_ARR0[1];

*BBOOLPTR = BOOLARRO[32];

BBOOLPTR = (unsigned char*)&_ARR0[2];

*BBOOLPTR = BOOLARRO[34];

_OR(_ARR0,&BOOLARRO[0]);

_CONDITIONAL(0,0,BOOLARRO[33],FLOATARRO[14]);

_ALARMFORM_COUNT = X53634564_COUNT;

_ALARMFORM(BOOLARRO[5],&BOOLARRO[6],0,0,0,BOOLARRO[13]);

X53634564_COUNT = _ALARMFORM_COUNT;

_ALARMFORM_COUNT = X53610812_COUNT;

_ALARMFORM(BOOLARRAO[0],&BOOLARRO[7],0,0,0,BOOLARRO[13]);

X53610812_COUNT = _ALARMFORM_COUNT;

_RSTRIGGER(BOOLARRO[6],BOOLARRO[13],&BOOLARRO[8]);

_RSTRIGGER(BOOLARRO[7],BOOLARRO[13],&BOOLARRO[9]);

_ALARMFORM_COUNT = X53797644_COUNT;

_ALARMFORM(BOOLARRO[32],&BOOLARRO[12],0,0,0,BOOLARRO[13]);

X53797644_COUNT = _ALARMFORM_COUNT;

_EQUALI(INTARRO[7],0,BOOLARRO[22]);

_PC485WRITEBIT_BLOCKID = X48453704_BLOCKID;

_PC485WRITEBIT(0,BOOLARRO[31],FALSE,&INTARRO[9]);

X48453704_BLOCKID = _PC485WRITEBIT_BLOCKID;

_EQUALI(INTARRO[9],0,BOOLARRO[24]);

_EQUALI(INTARRO[10],0,BOOLARRO[25]);

_FILTER(FLOATARRO[6],&FLOATARRO[4],2);

_RSTRIGGER(BOOLARRO[12],BOOLARRO[13],&BOOLARRO[10]);

_ARR0[0] = 11;

BBOOLPTR = (unsigned char*)&_ARR0[1];

*BBOOLPTR = BOOLARRO[19];

BBOOLPTR = (unsigned char*)&_ARR0[2];

*BBOOLPTR = BOOLARRO[21];

BBOOLPTR = (unsigned char*)&_ARR0[3];

*BBOOLPTR = BOOLARRO[22];

BBOOLPTR = (unsigned char*)&_ARR0[4];

*BBOOLPTR = BOOLARRO[23];

BBOOLPTR = (unsigned char*)&_ARR0[5];

*BBOOLPTR = BOOLARRO[24];

BBOOLPTR = (unsigned char*)&_ARR0[6];

*BBOOLPTR = BOOLARRO[25];

BBOOLPTR = (unsigned char*)&_ARR0[7];

*BBOOLPTR = BOOLARRO[26];

BBOOLPTR = (unsigned char*)&_ARR0[8];

*BBOOLPTR = BOOLARRO[27];

BBOOLPTR = (unsigned char*)&_ARR0[9];

*BBOOLPTR = BOOLARRO[28];

BBOOLPTR = (unsigned char*)&_ARR0[10];

*BBOOLPTR = BOOLARRO[29];

BBOOLPTR = (unsigned char*)&_ARR0[11];

*BBOOLPTR = BOOLARRO[30];

_NOR(_ARR0,&BOOLARRO[20]);

_UNBALANSE(FLOATARRO[5],FLOATARRO[4],FLOATARRO[3]);

_ARR0[0] = 2;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = FLOATARRO[3];

FFLOATPTR = (float*)&_ARR0[5];

*FFLOATPTR = FLOATARRO[9];

_MULT(_ARR0,&FLOATARRO[8]);

_ARR0[0] = 1;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = 0;

_ARR1[0] = 1;

FFLOATPTR = (float*)&_ARR1[1];

*FFLOATPTR = 0;

_PIECEWISE(FLOATARRO[3],&FLOATARRO[10],_ARR0,_ARR1);

_SAVE_OUTNUM = _OUTNUM;

_OUTNUM = 0;

_ARR0[0] = 2;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = 0;

FFLOATPTR = (float*)&_ARR0[5];

*FFLOATPTR = 100;

_ARR1[0] = 2;

FFLOATPTR = (float*)&_ARR1[1];

*FFLOATPTR = 0;

FFLOATPTR = (float*)&_ARR1[5];

*FFLOATPTR = FLOATARRO[10];

_PIECEWISE(FLOATARRO[17],&FLOATARRO[13],_ARR0,_ARR1);

_OUTNUM = _SAVE_OUTNUM;

AO(0) = FLOATARRO[13];

_ALARMFORM_COUNT = X53831064_COUNT;

_ALARMFORM(BOOLARRO[20],&BOOLARRO[15],0,0,0,BOOLARRO[13]);

X53831064_COUNT = _ALARMFORM_COUNT;

_ARR0[0] = 2;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = 0;

FFLOATPTR = (float*)&_ARR0[5];

*FFLOATPTR = 100;

_ARR1[0] = 2;

FFLOATPTR = (float*)&_ARR1[1];

*FFLOATPTR = FLOATARRO[14];

FFLOATPTR = (float*)&_ARR1[5];

*FFLOATPTR = FLOATARRO[10];

_PIECEWISE(FLOATARRO[18],&FLOATARRO[0],_ARR0,_ARR1);

_ARR0[0] = 2;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = 0;

FFLOATPTR = (float*)&_ARR0[5];

*FFLOATPTR = 100;

_ARR1[0] = 2;

FFLOATPTR = (float*)&_ARR1[1];

*FFLOATPTR = 0;

FFLOATPTR = (float*)&_ARR1[5];

*FFLOATPTR = 100;

_PIECEWISE(FLOATARRO[0],&FLOATARRO[1],_ARR0,_ARR1);

_PID2AOOVR_YIN_1 = X53376856_YIN_1;

_PID2AOOVR_XN_1 = X53376856_XN_1;

_PID2AOOVR_YD1N_1 = X53376856_YD1N_1;

_PID2AOOVR_YAN_1 = X53376856_YAN_1;

_PID2AOOVR_YULM = X53376856_YULM;

_PID2AOOVR(FLOATARRO[8],&FLOATARRO[7],&FFLOATBLANK,FALSE,0.5,2.5,300,0,0,100,BOOLARRO[0],0);

X53376856_YIN_1 = _PID2AOOVR_YIN_1;

X53376856_XN_1 = _PID2AOOVR_XN_1;

X53376856_YD1N_1 = _PID2AOOVR_YD1N_1;

X53376856_YAN_1 = _PID2AOOVR_YAN_1;

X53376856_YULM = _PID2AOOVR_YULM;

_ARR0[0] = 1;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = 0;

_ARR1[0] = 1;

FFLOATPTR = (float*)&_ARR1[1];

*FFLOATPTR = 0;

_PIECEWISE(FLOATARRO[7],&FLOATARRO[11],_ARR0,_ARR1);

_CONDITIONAL(FLOATARRO[11],0,BOOLARRO[4],FLOATARRO[12]);

_ARR0[0] = 1;

FFLOATPTR = (float*)&_ARR0[1];

*FFLOATPTR = 0;

_ARR1[0] = 1;

FFLOATPTR = (float*)&_ARR1[1];

*FFLOATPTR = 0;

_PIECEWISE(FLOATARRO[7],&FFLOATBLANK,_ARR0,_ARR1);

_RSTRIGGER(BOOLARRO[15],BOOLARRO[13],&BOOLARRO[11]);

_ARR0[0] = 4;

BBOOLPTR = (unsigned char*)&_ARR0[1];

*BBOOLPTR = BOOLARRO[8];

BBOOLPTR = (unsigned char*)&_ARR0[2];

*BBOOLPTR = BOOLARRO[9];

BBOOLPTR = (unsigned char*)&_ARR0[3];

*BBOOLPTR = BOOLARRO[10];

BBOOLPTR = (unsigned char*)&_ARR0[4];

*BBOOLPTR = BOOLARRO[11];

_OR(_ARR0,&BOOLARRO[14]);

_ARR0[0] = 2;

BBOOLPTR = (unsigned char*)&_ARR0[1];

*BBOOLPTR = BOOLARRO[14];

BBOOLPTR = (unsigned char*)&_ARR0[2];

*BBOOLPTR = FALSE;

_SAVE_OUTNUM = _OUTNUM;

_OUTNUM = 1;

_OR(_ARR0,&BOOLARRO[16]);

_OUTNUM = _SAVE_OUTNUM;

DO(1) = BOOLARRO[16];

_NOT(BOOLARRO[14],BOOLARRO[17]);

_ARR0[0] = 2;

BBOOLPTR = (unsigned char*)&_ARR0[1];

*BBOOLPTR = BOOLARRO[35];

BBOOLPTR = (unsigned char*)&_ARR0[2];

*BBOOLPTR = BOOLARRO[17];

_AND(_ARR0,&BOOLARRO[18]);

_PWM2_TIME = X53327236_TIME;

_PWM2_STATE = X53327236_STATE;

_PWM2(FLOATARRO[16],FLOATARRO[12],&PWM2ARRO[0]);

X53327236_TIME = _PWM2_TIME;

X53327236_STATE = _PWM2_STATE;

_BOOLVAR(BOOLARRO[18],BOOLARRO[1]);

_SAVE_OUTNUM = _OUTNUM;

_OUTNUM = 0;

_CONDB(PWM2ARRO[0],FALSE,BOOLARRO[1],BOOLARRO[2]);

_OUTNUM = _SAVE_OUTNUM;

DO(0) = BOOLARRO[2];

_SAVE_OUTNUM = _OUTNUM;

_OUTNUM = 1;

_CONDITIONAL(FLOATARRO[1],0,BOOLARRO[1],FLOATARRO[15]);

_OUTNUM = _SAVE_OUTNUM;

AO(1) = FLOATARRO[15];

#if defined(DEVICE_MC8) || defined(DEVICE_MC8_125) || defined(DEVICE_MC5) || defined(DEVICE_MC1) || defined(DEVICE_MC6) || defined(DEVICE_MR4)

_DACService();

#endif

_Inited = true;

}

//-------------------------------------------------------------

main()

{

main_func();

}

__global xdata char __RAMCheckByte;

#undef __global

#undef __comment

Содержание