Выбор наиболее эффективной технологии передачи данных между уровнем устройств и уровнем диспетчеризации

_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_SPEED400

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_WFtrue

#define PROTOCESSORFFP485_RFfalse

#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

#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

Размещено на Allbest.ru

...