ione
23 de Febrero del 2005

Hola gente!

Estoy programando un switch, y las exigencias del guión piden que se haga dentro de un for. No se si esto es posible, ya que al hacer:

for (i=0; i<3; i++)
{
switch (step)
{
case i: /*codigo case*/
}
}

me da el siguiente error: (151):Error: case label does not reduce to an integer constant. Que según entiendo yo, necesita una constante y no una variable para ejecutarse.

¿Alguien sabe como se programaría para que funcionara dentro del for?

Gracias

c++
23 de Febrero del 2005

pon algo mas de codigo, tendras puesto step, como entero, ponlo como char

un saludo

ione
23 de Febrero del 2005

Ahí va todo el código. Si el switch lo hago uno a uno, sin el for, funciona. Y he probado poniedo step como char, pero tampoco funciona: si dejo i sigue dando el mismo error, y con \'i\' no hace lo q tiene que hacer.

#include <bur/plc.h> /* macros for B&R PLC programming */
#include <bur/plctypes.h>
#include <standard.h> /* prototypes for STANDARD-Library */

/* === constant definitions === */
#define FALSE 0
#define TRUE 1

#define NUMSTATES 3
#define NUMVAR 2

#define BELTRUN 50

/* === variables declaration === */
_LOCAL INT step, i, j;
_LOCAL BOOL INfotoC;
_LOCAL unsigned char count;
_LOCAL BOOL state0inINBelt, state0inOUTPush, state0outINBelt, state0outOUTPush;
_LOCAL BOOL state1inINBelt, state1inOUTPush, state1outINBelt, state1outOUTPush;
_LOCAL BOOL state2inINBelt, state2inOUTPush, state2outINBelt, state2outOUTPush;

_LOCAL struct variable
{
BOOL varS[NUMVAR];
BOOL Counter;
BOOL InitTimer;
BOOL StopTimer;
};

_LOCAL struct counters
{
BOOL IN;
BOOL Q;
INT PC;
INT EC;
};

_LOCAL struct resources /* timer and counter */
{
TON_typ TON_ton;
struct counters counter;
};

_LOCAL struct state
{
int number;
BOOL in; /* in condition */
struct variable variabletochange; /* if 1 change variable state */
BOOL out; /* out condition */
struct resources resource;
};

_LOCAL struct state state0, state1, state2;
_LOCAL struct state statesarray[NUMSTATES];
_LOCAL BOOL var[NUMVAR];


/* === init part of task === */
_INIT void init(void)
{
/* state0 */
state0.number = 0;
state0inINBelt = FALSE;
state0inOUTPush = FALSE;
state0.variabletochange.varS[0] = TRUE; /* INBelt */
state0.variabletochange.varS[1] = FALSE; /* OUTPush */
state0.variabletochange.Counter = TRUE;
state0.variabletochange.InitTimer = FALSE;
state0.variabletochange.StopTimer = FALSE;
state0.resource.counter.IN = FALSE;
state0.resource.counter.PC = BELTRUN;
state0.resource.counter.EC = 0;
state0outINBelt = FALSE;
state0outOUTPush = FALSE;

/* state1 */
state1.number = 1;
state1inINBelt = TRUE;
state1inOUTPush = FALSE;
state1.variabletochange.varS[0] = TRUE;
state1.variabletochange.varS[1] = TRUE;
state1.variabletochange.Counter = FALSE;
state1.variabletochange.InitTimer = TRUE;
state1.variabletochange.StopTimer = FALSE;
state1.resource.TON_ton.PT = 2000; /* set delay time */
state1outINBelt = FALSE;
state1outOUTPush = FALSE;

/* state2 */
state2.number = 2;
state2inINBelt = FALSE;
state2inOUTPush = TRUE;
state2.variabletochange.varS[0] = FALSE;
state2.variabletochange.varS[1] = TRUE;
state2.variabletochange.Counter = FALSE;
state2.variabletochange.InitTimer = FALSE;
state2.variabletochange.StopTimer = TRUE;
state2outINBelt = FALSE;
state2outOUTPush = FALSE;

statesarray[0] = state0;
statesarray[1] = state1;
statesarray[2] = state2;

/* outputs, step and others */
var[0] = FALSE;
var[1] = FALSE;
step = state0.number ;
count = 0;
}

/* === cyclic part of task === */
_CYCLIC void cyclic(void)
{
/********* simulate belt *************/
count++;
/*************************************/

/* Workout IN conditions */
statesarray[0].in = INfotoC && (var[0] == state0inINBelt) && (var[1] == state0inOUTPush);
statesarray[1].in = statesarray[0].resource.counter.Q && (var[0] == state1inINBelt) && (var[1] == state1inOUTPush);
statesarray[2].in = statesarray[1].resource.TON_ton.Q && (var[0] == state2inINBelt) && (var[1] == state2inOUTPush);

/**************************** STATE MACHINE *************************************/

for (i=0; i<(NUMSTATES+1); i++)
{
/* Timer call */
TON(&statesarray[i].resource.TON_ton);
/* Counter */
if (!statesarray[i].resource.counter.IN && statesarray[i].resource.counter.Q)
{
statesarray[i].resource.counter.EC = 0;
statesarray[i].resource.counter.Q = FALSE;
}

if (statesarray[i].resource.counter.IN)
{
statesarray[i].resource.counter.EC++;
if (statesarray[i].resource.counter.EC == statesarray[i].resource.counter.PC)
{
statesarray[i].resource.counter.Q = TRUE;
statesarray[i].resource.counter.IN = FALSE;
}
}
}


for (i=0; i<(NUMSTATES+1); i++)
{
switch (step)
{
case i: if (statesarray[i].in)
{
/* do */
for (j=0; j<(NUMVAR+1); j++)
if (statesarray[0].variabletochange.varS[j])
{
if (var[j])
var[j] = FALSE;
else
var[j] = TRUE;
}
/* Init counter */
if (statesarray[i].variabletochange.Counter)
statesarray[i].resource.counter.IN = TRUE;
/* Init timer */
if (statesarray[i].variabletochange.InitTimer)
statesarray[i].resource.TON_ton.IN = TRUE;
/* Finish timer */
if (statesarray[i].variabletochange.StopTimer)
statesarray[i-1].resource.TON_ton.IN = FALSE;
/* Next step */
if (i == NUMSTATES)
step = statesarray[0].number;
else
step = statesarray[i+1].number;
break;
}
}
}
/*************************************/
/* Workout OUT conditions */
statesarray[0].out = (var[0] == state0outINBelt) && (var[1] == state0outOUTPush);
statesarray[1].out = (var[0] == state1outINBelt) && (var[1] == state1outOUTPush);
statesarray[2].out = (var[0] == state2outINBelt) && (var[1] == state2outOUTPush);
}