calc.c

电路仿真程序 Classic Ladder is coded 100％ in C.It can be used for educational purposes or anything you wan

/* Classic Ladder Project */
/* Copyright (C) 2001 Marc Le Douarain */
/* [e-mail] */
/* http://www.multimania.com/mavati/classicladder */
/* February 2001 */
/* Last update : 19 January 2002 */
/* -------------- */
/* Refresh a rung */
/* -------------- */
/* This library is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU Lesser General Public */
/* License as published by the Free Software Foundation; either */
/* version 2.1 of the License, or (at your option) any later version. */

/* This library is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU */
/* Lesser General Public License for more details. */

/* You should have received a copy of the GNU Lesser General Public */
/* License along with this library; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#include <stdio.h>
#include <string.h>
#include "classicladder.h"
#include "global.h"
#include "vars_access.h"
#include "arithm_eval.h"
#include "calc.h"
#ifdef __RTL__
#include <rtl_printf.h>
#endif

void InitRungs()
{
    int NumRung;
    int x,y;
    for (NumRung=0;NumRung<NBR_RUNGS;NumRung++)
    {
        RungArray[NumRung].Used = FALSE;
        strcpy(RungArray[NumRung].Label,"");
        strcpy(RungArray[NumRung].Comment,"");
        for (y=0;y<RUNG_HEIGHT;y++)
        {
            for(x=0;x<RUNG_WIDTH;x++)
            {
                RungArray[NumRung].Element[x][y].Type = ELE_FREE;
                RungArray[NumRung].Element[x][y].ConnectedWithTop = 0;
                RungArray[NumRung].Element[x][y].VarType = 0;
                RungArray[NumRung].Element[x][y].VarNum = 0;
                RungArray[NumRung].Element[x][y].DynamicInput = 0;
                RungArray[NumRung].Element[x][y].DynamicState = 0;
                RungArray[NumRung].Element[x][y].DynamicVarBak = 0;
                RungArray[NumRung].Element[x][y].DynamicOutput = 0;
            }
        }
    }
    InfosGene->FirstRung = 0;
    InfosGene->LastRung = 0;
    InfosGene->CurrentRung = 0;
    RungArray[0].Used = TRUE;
}
/* Set DynamicVarBak (Element) to the right value before calculating the rungs */
/* for detecting rising/falling edges used in some elements */
void PrepareRungs()
{
    int NumRung;
    int x,y;
    char StateElement;
    for (NumRung=0;NumRung<NBR_RUNGS;NumRung++)
    {
        for (y=0;y<RUNG_HEIGHT;y++)
        {
            for(x=0;x<RUNG_WIDTH;x++)
            {
                if ( (RungArray[NumRung].Element[x][y].Type==ELE_RISING_INPUT)
                    || (RungArray[NumRung].Element[x][y].Type==ELE_FALLING_INPUT) )
                {
                    StateElement = ReadVar(RungArray[NumRung].Element[x][y].VarType,RungArray[NumRung].Element[x][y].VarNum);
                    if (RungArray[NumRung].Element[x][y].Type==ELE_FALLING_INPUT)
                        StateElement = !StateElement;
                    RungArray[NumRung].Element[x][y].DynamicVarBak = StateElement;
                }
            }
        }
    }
}
void PrepareTimers()
{
    int NumTimer;
    for (NumTimer=0; NumTimer<NBR_TIMERS; NumTimer++)
    {
        TimerArray[NumTimer].Value = TimerArray[NumTimer].Preset;
        TimerArray[NumTimer].InputEnable = 0;
        TimerArray[NumTimer].OutputDone = 0;
        TimerArray[NumTimer].OutputRunning = 0;
    }
}
void PrepareMonostables()
{
    int NumMonostable;
    for (NumMonostable=0; NumMonostable<NBR_MONOSTABLES; NumMonostable++)
    {
        MonostableArray[NumMonostable].Value = 0;
        MonostableArray[NumMonostable].Input = 0;
        MonostableArray[NumMonostable].OutputRunning = 0;
        MonostableArray[NumMonostable].InputBak = 0;
    }
}
void InitArithmExpr()
{
    int NumExpr;
    for (NumExpr=0; NumExpr<NBR_ARITHM_EXPR; NumExpr++)
        strcpy(ArithmExpr[NumExpr].Expr,"");
}

char StateOnLeft(int x,int y,StrRung * TheRung)
{
    char State = 0;
    int PosY;
    char StillConnected;
    if (x==0)
        return 1;
    /* Direct on left */
    if (TheRung->Element[x-1][y].DynamicOutput)
        State = 1;
    /* Up */
    PosY = y;
    StillConnected = TheRung->Element[x][PosY].ConnectedWithTop;
    while( (PosY>0) && StillConnected)
    {
        PosY--;
        if (TheRung->Element[x-1][PosY].DynamicOutput)
            State = 1;
        if ( !(TheRung->Element[x][PosY].ConnectedWithTop) )
            StillConnected = FALSE;
    }
    /* Down */
    if (y<RUNG_HEIGHT-1)
    {
        PosY = y+1;
        StillConnected = TheRung->Element[x][PosY].ConnectedWithTop;
        while( (PosY<RUNG_HEIGHT) && StillConnected)
        {
            if (TheRung->Element[x-1][PosY].DynamicOutput)
                State = 1;
            PosY++;
            if (PosY<RUNG_HEIGHT)
            {
                if ( !(TheRung->Element[x][PosY].ConnectedWithTop) )
                    StillConnected = FALSE;
            }
        }
    }
    return State;
}

/* Elements : -| |- and -|/|- */
char CalcTypeInput(int x,int y,StrRung * UpdateRung,char IsNot,char OnlyFronts)
{
    char State;
    char StateElement;
    char StateVar;

    StateElement = ReadVar(UpdateRung->Element[x][y].VarType,UpdateRung->Element[x][y].VarNum);
    if (IsNot)
        StateElement = !StateElement;
    StateVar = StateElement;
    if (OnlyFronts)
    {
        if (StateElement && UpdateRung->Element[x][y].DynamicVarBak)
            StateElement = 0;
    }
    UpdateRung->Element[x][y].DynamicState = StateElement;
    if (x==0)
    {
        State = StateElement;
    }
    else
    {
        UpdateRung->Element[x][y].DynamicInput = StateOnLeft(x,y,UpdateRung);
        State = StateElement && UpdateRung->Element[x][y].DynamicInput;
    }
    UpdateRung->Element[x][y].DynamicOutput = State;
    UpdateRung->Element[x][y].DynamicVarBak = StateVar;
    return State;
}
/* Element : --- */
char CalcTypeConnection(int x,int y,StrRung * UpdateRung)
{
    char State;
    char StateElement;
    StateElement = 1;
    if (x==0)
    {
        State = StateElement;
    }
    else
    {
        UpdateRung->Element[x][y].DynamicInput = StateOnLeft(x,y,UpdateRung);
        State = StateElement && UpdateRung->Element[x][y].DynamicInput;
    }
    UpdateRung->Element[x][y].DynamicState = State;
    UpdateRung->Element[x][y].DynamicOutput = State;
    return State;
}
/* Elements : -( )- and -(/)- */
char CalcTypeOutput(int x,int y,StrRung * UpdateRung,char IsNot)
{
    char State;
    State = StateOnLeft(x,y,UpdateRung);
    UpdateRung->Element[x][y].DynamicInput = State;
    UpdateRung->Element[x][y].DynamicState = State;
    if (IsNot)
        State = !State;
    WriteVar(UpdateRung->Element[x][y].VarType,UpdateRung->Element[x][y].VarNum,State);
    return State;
}
/* Elements : -(S)- and -(R)- */
char CalcTypeOutputSetReset(int x,int y,StrRung * UpdateRung,char IsReset)
{
    char State;
    UpdateRung->Element[x][y].DynamicInput = StateOnLeft(x,y,UpdateRung);
    State = UpdateRung->Element[x][y].DynamicInput;
    UpdateRung->Element[x][y].DynamicState = State;
    if (State)
    {
        if (IsReset)
            State = 0;  /* reset */
        else
            State = 1;  /* set */
        WriteVar(UpdateRung->Element[x][y].VarType,UpdateRung->Element[x][y].VarNum,State);
    }
    return State;
}
/* Element : -(J)- */
int CalcTypeOutputJump(int x,int y,StrRung * UpdateRung)
{
    char State;
    int Goto = -1;
    State = StateOnLeft(x,y,UpdateRung);
    if (State)
        Goto = UpdateRung->Element[x][y].VarNum;
    UpdateRung->Element[x][y].DynamicInput = State;
    UpdateRung->Element[x][y].DynamicState = State;
    return Goto;
}
/* Element : Timer (2x2 Blocks) */
void CalcTypeTimer(int x,int y,StrRung * UpdateRung)
{
    StrTimer * Timer;
    Timer = &TimerArray[UpdateRung->Element[x][y].VarNum];
    if (x==0)
    {
        Timer->InputEnable = 1;
    }
    else
    {
        Timer->InputEnable = StateOnLeft(x-1,y,UpdateRung);
    }
    if (!Timer->InputEnable)
    {
        Timer->OutputRunning = 0;
        Timer->OutputDone = 0;
        Timer->Value = Timer->Preset;
    }
    else
    {
        if (Timer->Value>0)
        {
            Timer->Value = Timer->Value - TIME_REFRESH_RUNG_MS;
            Timer->OutputRunning = 1;
            Timer->OutputDone = 0;
        }
        else
        {
            Timer->OutputRunning = 0;
            Timer->OutputDone = 1;
        }
    }
    UpdateRung->Element[x][y].DynamicOutput = Timer->OutputDone;
    UpdateRung->Element[x][y+1].DynamicOutput = Timer->OutputRunning;
}
/* Element : Monostable (2x2 Blocks) */
void CalcTypeMonostable(int x,int y,StrRung * UpdateRung)
{
    StrMonostable * Monostable;
    Monostable = &MonostableArray[UpdateRung->Element[x][y].VarNum];
    if (x==0)
    {
        Monostable->Input = 1;
    }
    else
    {
        Monostable->Input = StateOnLeft(x-1,y,UpdateRung);
    }
    /* detecting impulse on input, the monostable is not retriggerable */
    if (Monostable->Input && !Monostable->InputBak && (Monostable->Value==0) )
    {
        Monostable->OutputRunning = 1;
        Monostable->Value = Monostable->Preset;
    }
    if (Monostable->Value>0)
        Monostable->Value = Monostable->Value - TIME_REFRESH_RUNG_MS;
    else
        Monostable->OutputRunning = 0;
    Monostable->InputBak = Monostable->Input;
    UpdateRung->Element[x][y].DynamicOutput = Monostable->OutputRunning;
}

/* Element : Compar (3 Horizontal Blocks) */
char CalcTypeCompar(int x,int y,StrRung * UpdateRung)
{
    char State;
    char StateElement;

    StateElement = EvalCompare(ArithmExpr[UpdateRung->Element[x][y].VarNum].Expr);
    UpdateRung->Element[x][y].DynamicState = StateElement;
    if (x==2)
    {
        State = StateElement;
    }
    else
    {
        UpdateRung->Element[x-2][y].DynamicInput = StateOnLeft(x-2,y,UpdateRung);
        State = StateElement && UpdateRung->Element[x-2][y].DynamicInput;
    }
    UpdateRung->Element[x][y].DynamicOutput = State;
    return State;
}

/* Element : Operate (3 Horizontal Blocks) */
char CalcTypeOutputOperate(int x,int y,StrRung * UpdateRung)
{
    char State;
    State = StateOnLeft(x-2,y,UpdateRung);
    if (State)
        MakeCalc(ArithmExpr[UpdateRung->Element[x][y].VarNum].Expr,FALSE /* verify mode */);
    UpdateRung->Element[x][y].DynamicInput = State;
    UpdateRung->Element[x][y].DynamicState = State;
    return State;
}


int RefreshRung(StrRung * Rung)
{
    int x,y;
    int JumpTo = -1;
//    hrtime_t starttime,endtime;

//    starttime = gethrtime();

    for (x=0;x<RUNG_WIDTH;x++)
    {
        for(y=0;y<RUNG_HEIGHT;y++)
        {
            switch(Rung->Element[x][y].Type)
            {
                /* MLD,16/5/2001,V0.2.8 , fixed for drawing */
                case ELE_FREE:
                case ELE_UNUSABLE:
                    if (StateOnLeft(x,y,Rung))
                        Rung->Element[x][y].DynamicInput = 1;
                    else
                        Rung->Element[x][y].DynamicInput = 0;
                    break;
                /* End fix */
                case ELE_INPUT:
                    CalcTypeInput(x,y,Rung,FALSE,FALSE);
                    break;
                case ELE_INPUT_NOT:
                    CalcTypeInput(x,y,Rung,TRUE,FALSE);
                    break;
                case ELE_RISING_INPUT:
                    CalcTypeInput(x,y,Rung,FALSE,TRUE);
                    break;
                case ELE_FALLING_INPUT:
                    CalcTypeInput(x,y,Rung,TRUE,TRUE);
                    break;
                case ELE_CONNECTION:
                    CalcTypeConnection(x,y,Rung);
                    break;
                case ELE_TIMER:
                    CalcTypeTimer(x,y,Rung);
                    break;
                case ELE_MONOSTABLE:
                    CalcTypeMonostable(x,y,Rung);
                    break;
                case ELE_COMPAR:
                    CalcTypeCompar(x,y,Rung);
                    break;
                case ELE_OUTPUT:
                    CalcTypeOutput(x,y,Rung,FALSE);
                    break;
                case ELE_OUTPUT_NOT:
                    CalcTypeOutput(x,y,Rung,TRUE);
                    break;
                case ELE_OUTPUT_SET:
                    CalcTypeOutputSetReset(x,y,Rung,FALSE);
                    break;
                case ELE_OUTPUT_RESET:
                    CalcTypeOutputSetReset(x,y,Rung,TRUE);
                    break;
                case ELE_OUTPUT_JUMP:
                    JumpTo = CalcTypeOutputJump(x,y,Rung);
                    break;
                case ELE_OUTPUT_OPERATE:
                    CalcTypeOutputOperate(x,y,Rung);
                    break;
            }
        }
    }

//    endtime = gethrtime();
//    printf("Time elapsed for refresh = %lld nsec\n",endtime-starttime);
    return JumpTo;
}

void RefreshAllRungs()
{
    int NumRung;
    int Goto;
    int Done = FALSE;

    CycleStart();
    NumRung = InfosGene->FirstRung;
    do
    {
        Goto = RefreshRung(&RungArray[NumRung]);
        if (Goto!=-1)
        {
            if (!RungArray[Goto].Used)
            {
                Done = TRUE;
                debug_printf("Refresh rungs aborted - jump to an undefined rung found in rung No%d...\n",Goto);
            }
            NumRung = Goto;
        }
        else
        {
            if (NumRung == InfosGene->LastRung)
                Done = TRUE;
            else
                NumRung = RungArray[NumRung].NextRung;
        }
    }
    while(!Done);
    CycleEnd();
}

void CopyRungToRung(StrRung * RungSrc,StrRung * RungDest)
{
    memcpy(RungDest,RungSrc,sizeof(StrRung));
}