Buenas tardes Ariel,
Leyendo tu mensaje, supongo que necesitas crear dos secuencias
que se ejecuten independientemente en lenguaje Pawn.
Viendo tu código, el inconveniente es el utilizar retardos
para realizar la secuencias de activación de reles, ya que esto
requiere implementar código adicional.
Es posible hacer dos secuencias independientes, pero
al utilizar retardos necesitas crear funciones que no te bloqueen
la ejecución del programa.
Es decir, la secuencia A debe llamarse y retornar inmediatamente
para llamar a la secuencia B, que tiene que ejecutar otro codigo.
Utilizando los timers del PLC es posible hacer "timeouts" a medida
para esto.
Te adjunto el mismo codigo que me pasaste en un proyecto
nuevo con dos secuencias:
Secuencia A: Conmuta los RELAY3 y RELAY5 segun tu logica.
Secuencia B: Conmuta los RELAY7 y RELAY8 solo para ejemplificar.
Compila el proyecto con StxLadder y ejecutalo en tu PLC para que veas
como las dos secuencias se ejecutan independientemente.
Cree en el proyecto dos funciones llamadas: CheckTimeoutCS() y SetTimeoutCS()
que son para comprobar y crear un timeout.
En el proyecto utilizo el timer1 para decrementar los timeout.
En Lenguaje Ladder es mas simple hacer este tipo de lógica, utilizando
los "Timer Ladders", pero es a titulo informativo.
El proyecto lo podes descargar de
www.slicetex.com/temp/FenixBioEnergy.zipIgual posteo el código a continuación.
Espero haber entendido tu consulta y cualquier duda, avísanos.
// --------------------------------------------------------------------------------
// Archivo : PlcMain.p
// Titulo : Script principal del PLC.
//
// Creado por : StxLadder Version 1.0.7.
// Fecha : 24/09/2012 19:49:38
//
// Descripcion :
//
// Aqui puede describir su proyecto.
//
// --------------------------------------------------------------------------------
// --------------------------------------------------------------------------------
// VARIABLES GLOBALES
// --------------------------------------------------------------------------------
// Timeout-1 en Centesimas de Segundos.
new Timeout1CS = 0
// Timeout-2 en Centesimas de Segundos.
new Timeout2CS = 0
// Almacena el numero de paso de la secuencia A.
new SecuenciaA_Paso = 0
// Almacena el numero de paso de la secuencia B.
new SecuenciaB_Paso = 0
// ********************************************************************************
// Funcion : PlcMain()
// Descripcion : Punto de entrada principal del PLC.
// ********************************************************************************
PlcMain()
{
// Activa el timer1 para generar un evento cada 100 mS.
Timer1SetEvent(100, true)
// INICIO
LcdClear()
LcdPrintf(0,0, "FENIX BIOEENERGY")
PauseMS(4000)
LcdClear()
LcdPrintf(0,0, "ENFRIADOR OK")
PauseMS(4000)
LcdClear()
LcdPrintf(0,0, "****CUIDADO*****")
PauseMS(3000)
LcdPrintf(0,0, "CONEXION TURBINA")
PauseMS(3000)
RelayClose (RELAY4)
DelayMS(3000)
LcdPrintf(0,0, " TURBINA CONECTADA")
PauseMS(3000)
// EMPEZAR SECUENCIA A POR PASO 1:
SecuenciaA_Paso = 1
// EMPEZAR SECUENCIA B POR PASO 1:
SecuenciaB_Paso = 1
// LOOP PRINCIPAL
while(true)
{
// Iniciar Secuencia A.
SecuenciaA(SecuenciaA_Paso)
// Iniciar Secuencia B.
SecuenciaB(SecuenciaB_Paso)
}
// Retorno.
return 0
}
// ********************************************************************************
// Funcion : OnTimer1()
// Descripcion : Evento OnTimer1 utilizado para actualizar los timeouts en
// centi-segundos.
// ********************************************************************************
@OnTimer1()
{
// Decrementa timeout 1.
if(Timeout1CS > 0)
{
Timeout1CS--
}
// Decrementa timeout 2.
if(Timeout2CS > 0)
{
Timeout2CS--
}
}
// ********************************************************************************
// Funcion : SecuenciaA()
// Descripcion : Secuencia A
//
// Entradas :
//
// - paso = Numero de paso a ejecutar.
//
// ********************************************************************************
SecuenciaA(paso)
{
switch(paso)
{
// Paso 1.
case 1:
{
RelayOpen (RELAY3)
// Establecer un Timeout en 30 centi-segundos.
SetTimeout1CS(30)
// Especificar proximo Paso.
SecuenciaA_Paso = 2
}
// Paso 2.
case 2:
{
// Comprobar Timeout.
if(CheckTimeout1CS())
{
// Timeout!... Especificar proximo paso.
SecuenciaA_Paso = 3
}
}
// Paso 3.
case 3:
{
RelayClose(RELAY3)
SetTimeout1CS(5)
SecuenciaA_Paso = 4
}
// Paso 4.
case 4:
{
if(CheckTimeout1CS())
{
SecuenciaA_Paso = 5
}
}
// Paso 5.
case 5:
{
RelayOpen (RELAY5)
SetTimeout1CS(30)
SecuenciaA_Paso = 6
}
// Paso 6.
case 6:
{
if(CheckTimeout1CS())
{
SecuenciaA_Paso = 7
}
}
// Paso 7.
case 7:
{
RelayClose(RELAY5)
SetTimeout1CS(5)
SecuenciaA_Paso = 8
}
// Paso 8.
case 8:
{
if(CheckTimeout1CS())
{
// Volver al inicio de la secuencia.
SecuenciaA_Paso = 1
}
}
}
}
// ********************************************************************************
// Funcion : SetTimeout1CS()
// Descripcion : Establece un timeout en 'cs' centi-segundos.
//
// Entradas :
//
// - cs = Tiempo para el timeout en centi-segundos (resolucion 100 ms).
// ********************************************************************************
SetTimeout1CS(cs)
{
Timeout1CS = cs
}
// ********************************************************************************
// Funcion : CheckTimeout1CS()
// Descripcion : Comprueba Timeout1CS, retorna 1 si hay un timeout.
// Retorn 0 si no hay timeout.
// ********************************************************************************
CheckTimeout1CS()
{
if(Timeout1CS <= 0)
{
// Timeout!.
return 1
}
else
{
// No hay timeout.
return 0
}
}
// ********************************************************************************
// Funcion : SecuenciaB()
// Descripcion : Secuencia B
//
// Entradas :
//
// - paso = Numero de paso a ejecutar.
//
// ********************************************************************************
SecuenciaB(paso)
{
switch(paso)
{
// Paso 1.
case 1:
{
RelayOpen(RELAY7)
// Establecer un Timeout en 30 centi-segundos.
SetTimeout2CS(30)
// Especificar proximo Paso.
SecuenciaB_Paso = 2
}
// Paso 2.
case 2:
{
// Comprobar Timeout.
if(CheckTimeout2CS())
{
// Timeout!... Especificar proximo paso.
SecuenciaB_Paso = 3
}
}
// Paso 3.
case 3:
{
RelayClose(RELAY7)
SetTimeout2CS(5)
SecuenciaB_Paso = 4
}
// Paso 4.
case 4:
{
if(CheckTimeout2CS())
{
SecuenciaB_Paso = 5
}
}
// Paso 5.
case 5:
{
RelayOpen(RELAY8)
SetTimeout2CS(30)
SecuenciaB_Paso = 6
}
// Paso 6.
case 6:
{
if(CheckTimeout2CS())
{
SecuenciaB_Paso = 7
}
}
// Paso 7.
case 7:
{
RelayClose(RELAY8)
SetTimeout2CS(5)
SecuenciaB_Paso = 8
}
// Paso 8.
case 8:
{
if(CheckTimeout2CS())
{
// Volver al inicio de la secuencia.
SecuenciaB_Paso = 1
}
}
}
}
// ********************************************************************************
// Funcion : SetTimeout2CS()
// Descripcion : Establece un timeout en 'cs' centi-segundos.
//
// Entradas :
//
// - cs = Tiempo para el timeout en centi-segundos (resolucion 100 ms).
// ********************************************************************************
SetTimeout2CS(cs)
{
Timeout2CS = cs
}
// ********************************************************************************
// Funcion : CheckTimeout2CS()
// Descripcion : Comprueba Timeout2CS, retorna 1 si hay un timeout.
// Retorn 0 si no hay timeout.
// ********************************************************************************
CheckTimeout2CS()
{
if(Timeout2CS <= 0)
{
// Timeout!.
return 1
}
else
{
// No hay timeout.
return 0
}
}
