void OutCntCanMonExt(void)
{
SaveDisplay();
sprintf(szHi,"—четчики: %02u-%02u",bInBuff6+1,bInBuff7+1); Clear();
if ((bInBuff6 < bCANALS) && (bInBuff7 < 12))
{
InitPushPtr();
if (GetDigitalPhone(bInBuff6) != 0)
{
PushChar(3);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
}
else if (mpboEnblCan[bInBuff6] == false)
{
PushChar(2);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
}
else
{
uchar p = ibPort;
double2 db2 = ReadCntMonCan(bInBuff7,bInBuff6);
ibPort = p;
if (db2.fValid == false)
{
PushChar(1);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
PushChar(0xFF);
}
else
{
PushChar(0);
PushFloat(db2.dbValue);
}
}
OutptrOutBuff(1+sizeof(float));
}
else Result(bRES_BADADDRESS);
LoadDisplay();
NextPause(); // внимание !
}
// требует установки diCurr
bool SafeDisconnect(void)
{
#ifdef FLOW
CloseFlow();
#endif
SaveDisplay();
bool fAlt = Disconnect();
LoadDisplay();
// QueResult(bRES_DISCONNECT, (uchar)fAlt);
// ResetAllSerial();
return(fAlt);
}
// требует установки diCurr
bool BreakConnect(void)
{
bool fAlt = ((diLast.ibPort != diCurr.ibPort) || (diLast.ibPhone != diCurr.ibPhone));
if (fAlt == 1)
{
SaveDisplay();
ShowPort(diCurr.ibPort);
ShowLo(szBreakConnect); DelayInf();
LoadDisplay();
}
// QueResult(bRES_BREAKCONNECT, (uchar)fAlt);
return(fAlt);
}
static void AddCall( instruction *ins, cn call ) {
/****************************************************/
name *proc_name;
if( _IsTargetModel(FLOATING_DS) && (call->state->attr&ROUTINE_NEEDS_DS_LOADED) ) {
AddIns( MakeMove( NearSegment(), AllocRegName( HW_DS ), U2 ) );
}
if( call->name->tipe == TypeProcParm ) {
proc_name = AllocTemp( ClassPointer );
/* what to do? proc_name->usage |= USE_REGISTER;*/
AddIns( MakeMove( ins->operands[CALL_OP_ADDR], proc_name, ClassPointer ));
ins->operands[CALL_OP_ADDR] = proc_name;
SetDisplay( GenIns( call->name ) );
AddIns( ins );
SaveDisplay( OP_POP );
} else {
AddCallIns( ins, call );
}
}
an BGCall( cn call, bool use_return, bool in_line )
/******************************************************/
{
instruction *call_ins;
call_state *state;
name *ret_ptr = NULL;
name *result;
name *temp;
name *reg_name;
instruction *ret_ins = NULL;
hw_reg_set return_reg;
hw_reg_set zap_reg;
if( call->name->tipe == TypeProcParm ) {
SaveDisplay( OP_PUSH );
}
state = call->state;
result = BGNewTemp( call->tipe );
call_ins = call->ins;
/* If we have a return value that won't fit in a register*/
/* pass a pointer to result as the first parm*/
if( call_ins->type_class == XX ) {
if( _RoutineIsFar16( state->attr ) ) {
if( state->attr & ROUTINE_ALLOCS_RETURN ) {
HW_CAsgn( state->return_reg, HW_EAX );
} else {
HW_CAsgn( state->return_reg, HW_EBX );
}
}
if( ( state->attr & ROUTINE_ALLOCS_RETURN ) == 0 ) {
if( HW_CEqual( state->return_reg, HW_EMPTY ) ) {
ret_ptr = AllocTemp( WD );
} else {
ret_ptr = AllocRegName( state->return_reg );
}
ret_ins = MakeUnary( OP_LA, result, ret_ptr, WD );
HW_TurnOn( state->parm.used, state->return_reg );
call_ins->flags.call_flags |= CALL_RETURNS_STRUCT;
}
}
if( _IsTargetModel(FLOATING_DS) && (state->attr&ROUTINE_NEEDS_DS_LOADED) ) {
HW_CTurnOn( state->parm.used, HW_DS );
}
if( _RoutineIsFar16( state->attr ) ) {
#if _TARGET & _TARG_80386
Far16Parms( call );
#endif
} else {
if( AssgnParms( call, in_line ) ) {
if( state->attr & ROUTINE_REMOVES_PARMS ) {
call_ins->flags.call_flags |= CALL_POPS_PARMS;
}
}
}
if( state->attr & (ROUTINE_MODIFIES_NO_MEMORY | ROUTINE_NEVER_RETURNS) ) {
/* a routine that never returns can not write any memory as far
as this routine is concerned */
call_ins->flags.call_flags |= CALL_WRITES_NO_MEMORY;
}
if( state->attr & ROUTINE_READS_NO_MEMORY ) {
call_ins->flags.call_flags |= CALL_READS_NO_MEMORY;
}
if( state->attr & ROUTINE_NEVER_RETURNS ) {
call_ins->flags.call_flags |= CALL_ABORTS;
}
if( _RoutineIsInterrupt( state->attr ) ) {
call_ins->flags.call_flags |= CALL_INTERRUPT | CALL_POPS_PARMS;
}
if( !use_return ) {
call_ins->flags.call_flags |= CALL_IGNORES_RETURN;
}
if( call_ins->type_class == XX ) {
reg_name = AllocRegName( state->return_reg );
if( state->attr & ROUTINE_ALLOCS_RETURN ) {
call_ins->result = reg_name;
AddCall( call_ins, call );
if( use_return ) {
temp = AllocTemp( WD ); /* assume near pointer*/
AddIns( MakeMove( reg_name, temp, WD ) );
temp = SAllocIndex( temp, NULL, 0,
result->n.type_class, call->tipe->length );
AddIns( MakeMove( temp, result, result->n.type_class ) );
}
} else {
call_ins->result = result;
AddIns( ret_ins );
if( HW_CEqual( state->return_reg, HW_EMPTY ) ) {
AddIns( MakeUnary( OP_PUSH, ret_ptr, NULL, WD ) );
state->parm.offset += TypeClassSize[WD];
call_ins->operands[CALL_OP_POPS] =
AllocS32Const( call_ins->operands[CALL_OP_POPS]->c.lo.int_value + TypeClassSize[WD] );
if( state->attr & ROUTINE_REMOVES_PARMS ) {
call_ins->flags.call_flags |= CALL_POPS_PARMS;
}
}
AddCall( call_ins, call );
}
} else {
return_reg = state->return_reg;
zap_reg = call_ins->zap->reg;
HW_CTurnOn( zap_reg, HW_FLTS );
HW_OnlyOn( return_reg, zap_reg );
call_ins->result = AllocRegName( return_reg );
reg_name = AllocRegName( state->return_reg );
AddCall( call_ins, call );
if( use_return ) {
ret_ins = MakeMove( reg_name, result, result->n.type_class );
if( HW_COvlap( reg_name->r.reg, HW_FLTS ) ) {
ret_ins->stk_entry = 1;
ret_ins->stk_exit = 0;
}
AddIns( ret_ins );
}
}
if( state->parm.offset != 0 && ( state->attr & ROUTINE_REMOVES_PARMS ) == 0 ) {
reg_name = AllocRegName( HW_SP );
AddIns( MakeBinary( OP_ADD, reg_name,
AllocS32Const( state->parm.offset ), reg_name, WD ) );
}
return( MakeTempAddr( result ) );
}
bool ResetFlash(void)
{
uint i;
ShowHi(szFlashErase);
wPage = 0;
ibSoftDay = 0;
ibSoftMon = 0; // TODO
uint m;
for (m=0; m<bMINUTES; m++)
{
if (FreeImpMnt(m) == false) return false;
ShowFlashErase();
}
uint wPageOut;
for (wPageOut=IMPHOUCAN; wPageOut<(IMPHOUCAN+IMPHOUCAN_PAGES); wPageOut++)
{
if (SafePageErase(wPageOut) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
memset(&mpimDayCan, 0, sizeof(mpimDayCan));
for (i=0; i<bDAYS; i++)
{
if (SaveImpDay(0,i,ibSoftDay) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
memset(&mpimMonCan, 0, sizeof(mpimMonCan));
for (i=0; i<bMONTHS; i++)
{
if (SaveImpMon(0,i,ibSoftMon) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
memset(&mppoDayGrp, 0, sizeof(mppoDayGrp));
for (i=0; i<bDAYS; i++)
{
if (SavePowDay(0,i,ibSoftDay) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
memset(&mppoMonGrp, 0, sizeof(mppoMonGrp));
for (i=0; i<bMONTHS; i++)
{
if (SavePowMon(0,i,ibSoftMon) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
memset(&mpdbCntMonCan, 0, sizeof(mpdbCntMonCan));
for (i=0; i<bMONTHS; i++)
{
if (SaveCntMon(0,i,ibSoftMon) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
for (wPageOut=PARAMS_VALUES; wPageOut<(PARAMS_VALUES+PARAMS_PAGES*wTIMES); wPageOut++)
{
if (SafePageErase(wPageOut) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
for (wPageOut=KEY_RECORD; wPageOut<(KEY_RECORD+bRECORD_PAGES*6+wRECORD2_PAGES*1); wPageOut++)
{
if (SafePageErase(wPageOut) == false) return false;
if (GetFlashStatus() != 0) return false;
ShowFlashErase();
}
if (CleanImpHouBuff() == false) return false;
if (CleanImpDayBuff() == false) return false;
if (CleanImpMonBuff() == false) return false;
if (CleanImpAbsBuff() == false) return false;
if (CleanPowDayBuff() == false) return false;
if (CleanPowMonBuff() == false) return false;
if (CleanCntMonBuff() == false) return false;
if (ClearDiagram() == false) return false;
ShowHi(szFlashRead);
wPage = 0;
bool f = true;
uint wPageIn;
for (wPageIn=FLASH_BEGIN; wPageIn<FLASH_END; wPageIn++)
{
if (SafePageRead(wPageIn) == false) return false;
if (GetFlashChecksum() == 0)
{
SaveDisplay();
ShowHi(szErrorCrc);
Clear(); sprintf(szLo+1,"страница: %u",wPageIn);
Beep();
DelayMsg();
LoadDisplay();
f = false;
}
ShowFlashRead();
}
return f;
}
