Este documento describe un método para programar sistemas secuenciales simulados en GRAFCET utilizando Arduino. Explica 5 etapas para la implementación: 1) encontrar la solución en GRAFCET, 2) definir el diagrama de conexión, 3) conectar la alimentación, 4) elaborar el programa en Arduino IDE, 5) cargar y probar. Luego presenta ejemplos de programación de estructuras GRAFCET básicas como lineal y alternativa, incluyendo variables, conexiones y programas equivalentes en Arduino

1. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 1
GRAFCET CON ARDUINO Programa en Arduino sistemas secuenciales simulados en
GRAFCET , con un método confiable 100%
https://youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC-Vmimt
“METODOLOGÍA DE PROGRACIÓN”
El procedimiento general a seguir para la implementación de la metodología de programación
(GRAFCET sobre Arduino) se describe en las siguientes etapas:
Etapa1: Encontrar la solución a la situación planteada en lógica secuencial (GRAFCET) con el Software
Fluid Sim.
A partir del enunciado o análisis del problema planteado, que describe en forma precisa la situación a
solucionar, el programador/estudiante usa los conocimientos y competencias que tiene sobre
GRAFCET y plantea una solución al problema de automatización en forma de un gráfico funcional de
etapas y transiciones usando para ello se apoyará en el software de Simulación (Fluid Sim P).
Como resultado de esto, se contará con un GRAFCET que describe el funcionamiento deseado y
representa la lógica a ser implementada como programa en el Arduino.
Esta solución al ser simulada y verificada quedará fija como el algoritmo que debe ser traducido a
la tarjeta de control, esta solución será independiente del tipo de entradas con la que se quiera
implementar el programa en el Arduino.
Etapa 2: Definir el diagrama de conexión de entradas y salidas en el Arduino
En la etapa 1 se encontró una solución en términos de lógica secuencial , la cual puede ser
implementada de un sinnúmero de formas dependiendo de las características de las entradas que se
le conecten o escojan para hacerlo por esta razón se debe definir el número de entradas, el tipo de
entradas si son contactos NO o NC y que pines serán asignados a cada una, similar a lo mostrado
en los esquemas de conexión de entradas y salidas.
Etapa 3: Conectar alimentación del equipo de prácticas (sistema electromecánico /neumático + Arduino)
a la fuente de poder de 110VAC, conectar la alimentación neumática , verificar y definir los pines y las
conexiones de las entradas y salidas al Arduino las cuales están ya precableadas.
Etapa 4: Elaborar el programa equivalente en el IDE del Arduino
Se elaborará el programa equivalente del GRAFCET hecho Fluid Sim siguiendo los lineamientos
que a continuación se describen:

2. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 2
1. Todo programa de Arduino bajo esta metodología estará dividido en cuatro (3) secciones, el
Tratamiento previo, Tratamiento secuencial , el Tratamiento posterior y la subsección que queda
después del void loop dedicada a la programación de las subrutinas de temporización
 El tratamiento previo incluirá las subsecciones “antes del void setup” y el “void setup”.
Antes del void setup:
En esta sección del programa se hace la “Declaración de Variables “ en ella deben aparecer las
variables Ei correspondientes a las etapas de todos los GRAFCET`s, las variables Ii que
corresponden a las entradas de pulsador, interruptores, sensores que aparecen en para el
circuito/programa, las variables que corresponde a los pin de salidas acoplada a un LED, bobina o
relee.
También se declaran las variables asociadas a cada temporizador y las variables asociadas al
cada contador.
void setup:
En esta sección del programa se habilita la apertura del visualizador serial, se hace la
declaración de puertos digitales como entradas (INPUT) o como salidas digitales (OUTPUT) , se
declaran los estados iniciales de los pines de las salidas en LOW/apagadas.
 El tratamiento secuencial hace parte de la subsecciones “void loop”.
En el void loop: se capturan los valores de puertos digitales de entrada, se da inicio del tratamiento
Secuencial cíclico con la declaración de las ecuaciones características de cada ecuación derivada de
teoría binodal vista en la sección RE.
 El tratamiento posterior hace parte de la subsecciones “void loop” y se usa para ejecutar las
acciones de cada etapa, ya sean activando o desactivando salidas digitales, iniciando una
temporización o incrementando un contador entre otras.
 Después del void loop : se programan las subrutinas de temporización (para cada temporización se
asigna un subprograma //activetempx y un desactivetempx usando para ello comparaciones con el
comando millis).
Estas organización de tareas en la programación se verán aplicadas a cada uno de los cinco (4)
estructuras que hacen parte de la práctica Nº1.
Etapa 5: Configurar la comunicación entre el PC y el Arduino en términos de tipo de controlador
(Mega) y puerto serial de comunicación, cargar y probar el funcionamiento.

3. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 3
IMPLEMENTACIÓN DE LA METODOLOGÍA PARA TRADUCIR AL LENGUAJE “PROCESSING” UN
CIRCUITO ELÉCTRICO HECHO EN LADDER.
La implementación de la metodología iniciará con la programación de las cuatro (4) estructuras
secuenciales básicas , la estructura lineal, la estructura alternativa, la estructura simultánea y la
estructura repetitiva.
Las estructuras GRAFCET que se programaran describen la forma de activar luces LED que están
acopadas a las salidas por medio de una serie de pulsadores en las entradas, logrando que el
programa siga los caminos y ejecute las acciones previstas en dependencia de las ordenes de
entrada, estas prácticas se harán con el uso del sistema electromecánico didáctico, cada una de las
estructuras tendrá un nivel de complejidad creciente, al cabo de los cuales quedará claro como
hacer uso de los elementos de programación como : entradas digitales, salidas digitales,
memorias(relé), temporizaciones, contadores de eventos, entre otros , siguiendo una metodología.
Los pasos que se han de seguir en estos primeros casos van a ser similares para todas la demás
experiencias que se puedan realizar con el equipo y en caso se desarrollan completamente las 5
etapas del proceso .
Con la realización de estas prácticas se sientan las bases para programar cualquier GRAFCET que
sea una combinación de las estructuras anteriores,
Los elementos y equipos requeridos para realizar las 4 estructuras secuenciales básicas están
descritos en la tabla T.
Tabla T. Equipos y elementos requeridos
ITEM ELEMENTOS CANTIDAD
1 Luz piloto Led a 24 VDC 3
2 Fuente a 24 V DC 1
3 Pulsador Normalmente Abierto 6
4 Arduino Nano 1
5 Cable de Comunicación PC - Arduino 1
6 Cables de conexión
7
Computador con los Programas Fluid Sim P V4.2 y el IDE de
Arduino
1

4. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 4
COM
COM1
PIN 7
PIN 6
PIN 2
PIN 3
+24 V
S1
S0 Y2
Y3
A2 A1
A2 A1
4
3
PIN 9
PIN 8
S2
4
3
3 4
PIN 10
S4
S3
4
3
3 4
PIN 4
Y4
A2 A1
CASO N°1 - ESTRUCTURA LINEAL
Solución GRAFCET.
Fig. 1 GRAFCET estructura lineal
Fig. 2 Esquema de conexión de entradas /salidas para la "estructura lineal" en Arduino
ENTRADAS
SALIDAS
0V
+24 V 0V
S0
Y2

5. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 5
Programa en IDE del Arduino CASO N°1
//TRATAMIENTO PREVIO
//Decalaración de variables utilizadas para el programa
//La designación E corresponde a una "Etapa"
// La designación S corresponde a los pulsadores de entrada asociados a las transiciones
int E1; // Etapa 1
int E2; //Etapa 2
int E3; //Etapa 3
int E4; //Etapa 4
int S0 = 6; //Pulsador S0 conectado al pin 6 de Arduino
int S1 = 7;
int S2 = 8;
int S3 = 9;
int S4 = 10;
int Y2 = 2; //Salida Y2 conectada al pin 2 de Arduino
int Y3 = 3;
int Y4 = 4;
void setup() {
//Apertura del visualizador serial
Serial.begin(9600);
//Declaración de puertos digitales
pinMode(6, INPUT);
pinMode(7, INPUT);
pinMode(8, INPUT);
pinMode(9, INPUT);
pinMode(10, INPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
//Algunos dispositivos traen una configuración "Sinking and Sourcing" por eso es necesario colocar los
puertos de salida en 0v.
digitalWrite(Y2, LOW);
digitalWrite(Y3, LOW);
digitalWrite(Y4, LOW);
//Declaración del estado inicial de las etapas
E1 = HIGH; //La Etapa 1 es una Etapa inicial, debe estar activa al inicio del programa
E2 = LOW;
E3 = LOW;
E4 = LOW;
}
void loop() {
//Capturar valores de puertos digitales de entrada
S0 = digitalRead(6);
S1 = digitalRead(7);
S2 = digitalRead(8);
S3 = digitalRead(9);

6. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 6
S4 = digitalRead(10);
//TRATAMIENTO SECUENCIAL
E1 = ((E1 | (E4 & S3 )) & (~E2)); //Ecuación binaria correspondiente al estado1
E2 = ((E2 | (E1 & S0 )) & (~E3)); //Ecuación binaria correspondiente al estado2
E3 = ((E3 | (E2 & (S1 | S4) )) & (~E4)); //Ecuación binaria correspondiente al estado3
E4 = ((E4 | (E3 & S2)) & (~E1)); //Ecuación binaria correspondiente al estado4
// TRATAMIENTO POSTERIOR
if (E1 == HIGH) { Serial.println("Etapa1"); }
if (E2 == HIGH) {
digitalWrite(Y2, HIGH);
Serial.println("Etapa2"); }
else { digitalWrite(Y2, LOW); }
if (E3 == HIGH) { digitalWrite(Y3, HIGH);
Serial.println("Etapa3"); }
else { digitalWrite(Y3, LOW); }
if (E4 == HIGH) {
digitalWrite(Y4, HIGH);
Serial.println("Etapa4");
}
else { digitalWrite(Y4, LOW); }
}
CASO N°2
Solución GRAFCET.
Fig. 3 GRAFCET alternativo

7. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 7
COM
COM1
PIN 7
PIN 6
PIN 2
PIN 3
+24 V
S7
S6
Y2
Y3
A2 A1
A2 A1
4
3
PIN 9
PIN 8
S8
4
3
3 4
PIN 10
S10
S9
4
3
3 4
PIN 4
Y4
A2 A1
Fig. 4 Esquema de conexión de entradas /salidas para la “estructura alternativa" en Arduino
Programa equivalente en IDE del Arduino CASO N°2
//TRATAMIENTO PREVIO
//Decalaración de variables utilizadas para el programa
//La designación E corresponde a una "Etapa"
// La designación S corresponde a los pulsadores de entrada asociados a las transiciones
int E6; // Etapa 6
int E7;
int E8;
int E9;
int E10;
int S6 = 6; //Pulsador S6 conectado al pin 6 de Arduino
int S7 = 7;
int S8 = 8;
int S9 = 9;
int S10 = 10;
int Y2 = 2; //Salida Y2 conectada al pin 2 de Arduino
int Y3 = 3;
int Y4 = 4;
int T1; // Bit asociado al temporizador 1
// Variables asociadas a "temp1".
ENTRADAS
SALIDAS
0V
+24 V 0V

8. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 8
int activado1 = 0; // Al principio no ha sido activado.
long inicio1, final1, actual1;
void setup() {
//Apertura del visualizador serial
Serial.begin(9600);
//Declaración de puertos digitales
pinMode(6, INPUT);
pinMode(7, INPUT);
pinMode(8, INPUT);
pinMode(9, INPUT);
pinMode(10, INPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
//Algunos dispositivos traen una configuración "Sinking and Sourcing" por eso es necesario colocar los
puertos de salida en 0v.
digitalWrite(Y2, LOW);
digitalWrite(Y3, LOW);
digitalWrite(Y4, LOW);
//Declaración del estado inicial de las etapas
E6 = HIGH; //La Etapa 6 es una Etapa inicial, debe estar activa al inicio del programa
E7 = LOW;
E8 = LOW;
E9 = LOW;
E10 = LOW;
}
void loop() {
//Capturar valores de puertos digitales de entrada
S6 = digitalRead(6);
S7 = digitalRead(7);
S8 = digitalRead(8);
S9 = digitalRead(9);
S10 = digitalRead(10);
//TRATAMIENTO SECUENCIAL
E6 = ((E6 | (E9 & S8) | (E10 & S10)) & (~E7) & (~E8)); //Ecuación binaria correspondiente al estado 6
E7 = ((E7 | (E6 & S6 & S7 )) & (~E9)); //Ecuación binaria correspondiente al estado 7
E9 = ((E9 | ( E7 & T1 )) & (~E6)); //Ecuación binaria correspondiente al estado9
E8 = ((E8 | (E6 & S6 & S8)) & (~E10)); //Ecuación binaria correspondiente al estado 8
E10 = ((E10 | (E8 & S9)) & (~E6)); //Ecuación binaria correspondiente al estado 10
// TRATAMIENTO POSTERIOR
if (E6 == HIGH) { Serial.println("Etapa6"); }
if (E7 == HIGH) { digitalWrite(Y3, HIGH); Serial.println("Etapa7"); activetemp1(); }
else { digitalWrite(Y3, LOW); desactivetemp1(); }

9. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 9
if (E9 == HIGH) { digitalWrite(Y2, HIGH); Serial.println("Etapa9"); }
else { digitalWrite(Y2, LOW); }
if (E8 == HIGH) { digitalWrite(Y4, HIGH); Serial.println("Etapa8"); }
else { digitalWrite(Y4, LOW); }
if (E10 == HIGH) { Serial.println("Etapa10"); }
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//SUBRUTINA TEMPORIZADOR 1
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void activetemp1() {
if (E7 == HIGH && activado1 == 0) { // Si ha pulsado HIGH y no ha sido activado=0 antes...
activado1 = 1; // marca activado=1 y guarda el tiempo de inicio.
inicio1 = millis();
final1 = inicio1 + 5000; // Tiempo final es inicio más 5 segundos.
}
actual1 = millis(); // Consulta el tiempo actual.
if (activado1 == 1 && (actual1 > final1) ) { T1 = HIGH; }
else { T1 = LOW; }
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void desactivetemp1() {
activado1 = 0;//
inicio1 = 0;
final1 = 0;
actual1 = 0;
}
CASO N°3
Solución GRAFCET.
Fig. 5 GRAFCET estructura simultanea

10. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 10
COM
COM1
PIN 7
PIN 6
PIN 2
PIN 3
+24 V
S3
S11
Y6
Y7
A2 A1
A2 A1
4
3
PIN 9
PIN 8
S4
4
3
3 4
PIN 10
S6
S7
PIN 11
4
3
3 4
3 4
S0
Fig. 6 Esquema de conexión de entradas /salidas para la "estructura simultanea " en Arduino
Programa equivalente en IDE del Arduino del CASO N°3
//TRATAMIENTO PREVIO
//Decalaración de variables utilizadas para el programa
//La designación E corresponde a una "Etapa"
// La designación S corresponde a los pulsadores de entrada asociados a las transiciones
int E12 ; // Etapa 12
int E14 ;
int E15 ;
int E16 ;
int E17 ;
int E18 ;
int E19 ;
int S11 = 6; //Pulsador S11 conectado al pin 6 de Arduino
int S3 = 7;
int S4 = 8;
int S7 = 9;
int S6 = 10;
int S0 = 11;
int Y6 = 2; //Salida Y6 conectada al pin 2 de Arduino
int Y7 = 3;
ENTRADAS
SALIDAS
0V
+24 V 0V

11. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 11
void setup() {
Serial.begin(9600);
//Declaración de puertos digitales//
pinMode(S11, INPUT);
pinMode(S3, INPUT);
pinMode(S4, INPUT);
pinMode(S7, INPUT);
pinMode(S6, INPUT);
pinMode(S0, INPUT);
pinMode(Y6, OUTPUT);
pinMode(Y7, OUTPUT);
//Algunos dispositivos traen una configuración "Sinking and Sourcing" por eso es necesario colocar los
puertos de salida en 0v.
digitalWrite(Y6, LOW);
digitalWrite(Y7, LOW);
//Declaración de etapa inicial
E12 = HIGH;
E14 = LOW;
E15 = LOW;
E16 = LOW;
E17 = LOW;
E18 = LOW;
E19 = LOW;
}
void loop() {
//Capturar valores de puertos digitales de entrada
S11 = digitalRead(6);
S7 = digitalRead(9);
S6 = digitalRead(10);
S4 = digitalRead(8);
S3 = digitalRead(7);
S0 = digitalRead(11);
//Tratamiento secuencial
E12 = ((E12 | (E18 & E19&S0 )) & (~E14) & (~E15)); //Ecuación binaria correspondiente al etapa12
E14 = ((E14 | (E12&S11)) & (~E16)); //Ecuación binaria correspondiente al etapa14
E15 = ((E15 | (E12&S11)) & (~E17)); //Ecuación binaria correspondiente al etapa15
E16 = ((E16 | (E14 & S3)) & (~E18)); //Ecuación binaria correspondiente al etapa16
E17 = ((E17 | (E15 & S4)) & (~E19)); //Ecuación binaria correspondiente al etapa 17
E18 = ((E18 | (E16 & S7)) & (~E12)); //Ecuación binaria correspondiente al etapa 18
E19 = ((E19 | (E17 & S6)) & (~E12)); //Ecuación binaria correspondiente al etapa 19
// Tratamiento posterior
if (E12 == HIGH) {
Serial.println("Etapa12");
}
if (E14 == HIGH) {
digitalWrite(Y6, HIGH);
Serial.println("Etapa14");

12. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 12
}
else
{
digitalWrite(Y6, LOW);
}
if (E15 == HIGH) {
digitalWrite(Y7, HIGH);
Serial.println("Etapa15");
}
else
{
digitalWrite(Y7, LOW);
}
if (E16 == HIGH) {
Serial.println("Etapa16");
}
if (E18 == HIGH) {
Serial.println("Etapa18");
}
if (E17 == HIGH) {
Serial.println("Etapa17");
}
if (E19 == HIGH) { Serial.println("Etapa19"); }
}
CASO N°4 ESTRUCTURA REPETITIVA - USO DE CONTADOR ACTIVADO POR UNA ETAPA
Solución GRAFCET.
Fig. 7 GRAFCET estructura repetitiva

13. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 13
COM
COM1
Pin 6
Pin 2
S0
X1 X2
3 4 Y2
Fig. 8 Esquema de conexión de entradas /salidas para la "estructura repetitiva" en Arduino
Programa equivalente en IDE del Arduino
//TRATAMIENTO PREVIO
//Decalaración de variables utilizadas para el programa
//La designación E corresponde a una "Etapa"
// La designación S corresponde a los pulsadores de entrada asociados a las transiciones
int E1; int E2; int E3; int E4;
int S0 = 6; int Y2 = 2;
// Variables asociadas al Contador
int CONTADOR = 0; const int PSCONTADOR = 3; // Preselect del Contador o # de ciclos
int ESTADOPREVIO_E2 = 0; // previous state of the Step
int T1 ; // Bit asociado al temporizador 1
int T2 ; // Bit asociado al temporizador 2
// Variables asociadas a "temp1".
int activado1 = 0; // Al principio no ha sido activado.
long inicio1, final1, actual1;
// Variables asociadas a "temp2".
int activado2 = 0; // Al principio no ha sido activado.
long inicio2, final2, actual2;
void setup() {
//Apertura del visualizador serial
Serial.begin(9600);
//Declaración de puertos digitales
pinMode(6, INPUT);
pinMode(2, OUTPUT);
//Algunos dispositivos traen una configuración "Sinking and Sourcing"
//por eso es necesario colocar los puertos de salida en 0v.
ENTRADAS
SALIDAS
+24 V 0V
+24 V 0V

14. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 14
digitalWrite(Y2, LOW);
//Declaración del estado inicial de las etapas
E1 = HIGH; //La Etapa 1 es una Etapa inicial
E2 = LOW; E3 = LOW; E4 = LOW; // las etapas comunes
}
//TRATAMIENTO SECUENCIAL
void loop() {
//Capturar valores de puertos digitales de entrada
S0 = digitalRead(6);
// Ecuaciones binodales de ETAPAS
E1 = ((E1 | (E4 & (CONTADOR >= PSCONTADOR) )) & (~E2)); //Ecuación binaria correspondiente al
estado1
E2 = ((E2 | (E1 & S0 ) | (E4 & (CONTADOR < PSCONTADOR))) & (~E3)); //Ecuación binaria
correspondiente al estado2
E3 = ((E3 | (E2 & T1 )) & (~E4)); //Ecuación binaria correspondiente al estado3
E4 = ((E4 | (E3 & T2)) & (~E1) & (~E2)); //Ecuación binaria correspondiente al estado4
delay(200); // solo para ayuda de visualización
// TRATAMIENTO POSTERIOR
if (E1 == HIGH) {
Serial.println("Etapa1");
CONTADOR = 0; }
if (E2 == HIGH) {activetemp1(); }
else {desactivetemp1(); }
if (E2 == HIGH) {
Serial.println("Etapa2");
digitalWrite(Y2, HIGH);
Serial.print("CONTADOR : ");
Serial.println(CONTADOR); }
else {digitalWrite(Y2, LOW);}
if (E3 == HIGH) { Serial.println("Etapa3"); }
if (E3 == HIGH) {activetemp2();}
else {desactivetemp2();}
if (E4 == HIGH) {Serial.println("Etapa4");}
if (E2 != ESTADOPREVIO_E2) {
if (E2 == HIGH)
{ CONTADOR++;
Serial.print("Numero de Ciclos : ");
Serial.println(CONTADOR); }
ESTADOPREVIO_E2 = E2;
}
delay (100); // se usa para observar mejor el monitor serial

15. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 15
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//SUBRUTINA TEMPORIZADOR 1
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void activetemp1() {
if (E2 == HIGH && activado1 == 0) { // Si ha pulsado HIGH y no ha sido activado=0 antes...
activado1 = 1; // marca activado=1 y guarda el tiempo de inicio.
inicio1 = millis();
final1 = inicio1 + 5000;
}
actual1 = millis(); // Consulta el tiempo actual.
if (activado1 == 1 && (actual1 > final1) ) {
T1 = HIGH;
}
else { T1 = LOW; }
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void desactivetemp1() {
T1 = LOW;
activado1 = 0; inicio1 = 0;
final1 = 0; actual1 = 0;
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//SUBRUTINA TEMPORIZADOR 2
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void activetemp2() {
if (E3 == HIGH && activado2 == 0) { // Si ha pulsado HIGH y no ha sido activado=0 antes...
activado2 = 1; // marca activado=1 y guarda el tiempo de inicio.
inicio2 = millis();
final2 = inicio2 + 5000;
}
actual2 = millis(); // Consulta el tiempo actual.
if (activado2 == 1 && (actual2 > final2) ) {
T2 = HIGH;
}
else { T2 = LOW; }
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void desactivetemp2() {
T2 = LOW;
activado2 = 0; inicio2 = 0;
final2 = 0; actual2 = 0;
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Jóvenes, este material ha sido elaborado con mucho gusto.
Si te es útil Regálame un Like, comenta y suscríbete :) (っ◕‿◕)
Te invito al CANAL DE YOUTUBE MEKATRONICA
para conocer más

16. ESTRUCTURAS GRAFCET CON ARDUINO ITSAINO (USO DE ENTRADAS, SALIDAS, RELEES,
TEMPORIZADOR, CONTADOR , ETC.)
Guía Elaborada por Ing. Jovanny Duque 16
http://www.youtube.com/c/JovannyDuque?sub_c
onfirmation=1_
__________________________________
y Amigos/as en el BLOGG MEKATRONICA podrás encontrar
cantidad de recursos sobre SOLIDWORKS, HIDRÁULICA -
ELECTROHIDRÁULICA , NEUMÁTICA, ELECTRONEUMÁTICA,
CONTROL, PLC M221, PLC SIEMEMS S7 1200, PLC SIEMENS S7 300
, FLUID SIM FACTORY IO, entre otros
https://mecatronica-itsa.blogspot.com/