IMPLEMENTACIÓN DE GRAFCET SOBRE ARDUINO APLICANDO LÓGICA BINODAL by INGENIERÍA J DUKE

IMPLEMENTACIÓN DE GRAFCET SOBRE ARDUINO APLICANDO LÓGICA BINODAL Ing. Jovanny Rafael Duque

jduque@itsa.edu.co 2021

IMPLEMENTACIÓN DE GRAFCET SOBRE ARDUINO APLICANDO LÓGICA BINODAL GRAFCET (Graphe Fonctionnel de Commande Etapes-Transitions) NORMA IEC 60848 GRAFCET La NORMA IEC 60848 describe el GRAFCET como un lenguaje de descripción de sistemas secuenciales, en términos de etapas y transiciones. https://youtube.com/playlist?list=PLHTERkK4EZJpH42sen4uqz-H_iVuYerY8

GRAFCET CON FLUIDSIM Usa el software Fluid Sim P para simular GRAFCET aplicados a sistemas electroneumáticos, desde lo más sencillo a lo más complejo. https://youtube.com/playlist?list=PLHTERkK4EZJoUmPtqY8kKCboLIrGN8tYc GRAFCET CON ARDUINO Programa en Arduino sistemas secuenciales simulados en GRAFCET , con un método confiable 100% https://youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC-Vmimt https://www.mecatrónica.com.co/ https://mecatronica-itsa.blogspot.com/ http://www.youtube.com/c/JovannyDuque?sub_confirmation=1_

GRAFCET (Graphe Fonctionnel de Commande Etapes-Transitions) ¿Que es? Es un potente herramienta gráfica para la especificación y programación para autómatas programables (PLC´s), evolucionado a partir de las redes de Petri, que permite representar los automatismos secuenciales de eventos discretos. Introducción Su creación fue necesaria, ante la necesidad de encontrar un modelo gráfico por medio del cual los diferentes actores de los procesos productivos pudieran entenderse además de unificar y racionalizar el lenguaje para describir los sistemas lógicos y en particular el componente secuencial de los mismos.

GRAFCET (Graphe Fonctionnel de Commande Etapes-Transitions)

Historia

• 1977 - AFCET • 1982 UTE NF C 03-190 •

2002, IEC-60848

• 2013 IEC 61131-3

GRAFCET Elementos del GRAFCET

Flanqueo de una transición

Receptividades asociadas a las transiciones

ACCIONES Acción Continua

Acción retardada

Acción limitada en el tiempo

Acción Condicionada

Acción memorizada

ESTRUCTURAS LÓGICAS FUNDAMENTALES

LINEAL

ALTERNATIVA

SIMULTANEA

GRAFCET IMPLEMENTADO CON ARDUINO La automatización de ciertos mecanismos puede volverse una tarea laboriosa y compleja. A. Ramos, propone una estrategia rápida e intuitiva usando la lógica binodal. Allí, se genera un gráfico representativo de la dinámica del sistema, similar al usado en el lenguaje GRAFCET, y se obtienen directamente ecuaciones lógicas que describen el comportamiento del sistema aplicando teoremas binodales.

𝑛

𝑆

𝑡

𝑆 + ෍ 𝑀𝑖 ∗ ෑ 𝑖=1

Binodo

𝑚 𝑗=1

𝑃ഥ𝑗

Ecuación Característica del Binodo

Donde 𝑀𝑖 corresponde a las (v.d.a) variables de activación del binodo corresponde a las (v.d.d) variables de desactivación del binodo.

y 𝑃𝑗

GRAFCET IMPLEMENTADO CON ARDUINO Extrapolando lo anterior para sintetizar el método GRAFCET:

𝑛

𝑆

𝑡

𝑆 + ෍ 𝑀𝑖

𝑚

∗

ෑ

𝑖=1

𝑗=1

𝑛

𝐸𝑖 =

𝐸 𝑖 + ෍ 𝐸𝑇𝐴𝑃𝐴𝑖−1 ∗ 𝑇𝑟𝑎𝑛𝑠𝑖−1 ∗ ෑ 𝑖=1

𝑃ഥ𝑗

𝑚 𝑖=1

𝐸𝑇𝐴𝑃𝐴𝑖+1

Las ecuaciones de estado obtenidas anteriormente pueden definirse como el algoritmo que describirá el proceso, este algoritmo se codifico en lenguaje C para implementarlo en ARDUINO , teniendo en cuenta tratamientos previos como la declaración de variables, declaración de puertos de entrada y salida digital y demás consideraciones. Las operaciones booleanas de suma, producto y negación deben hacerse usando la siguiente sintaxis: & Corresponde a la operación booleana AND o producto. | Corresponde a la operación booleana OR o suma. ~o! Corresponde a la función booleana NOT o de negación.

Caso 1 (Etapa 3 en una estructura lineal)

E3 = ( (E3 | (E2 & (S1 | S4)))

Figura 3. Etapa en estructura lineal

(~E4)

);

Caso 2 (Etapa 6 salida de una convergencia en <<O>>)

E6 = ((E6 | (E9 & S8) | (E10 & S10)) & (~E7) & (~E8));

Figura 4. Etapa de salida en estructura alternativa

Caso 3 (Etapa 12 salida de convergencia en <<Y>>)

E12 = ((E12 | (E18 & E19 & S0)) & (~E14) & (~E15));

Figura 5. Etapa de salida en estructura simultanea

GRAFCET IMPLEMENTADO CON ARDUINO HARDWARE

Conexionado del equipo

Esquema para la conexión de Pulsadores y Leds en el Arduino

METODOLOGÍA – GRAFCET - ARDUINO Se debe

gobernar el cilindro A según el diagrama Espacio- Fase mostrado en

la figura Nº B , tal que al dar la señal de inicio con e pulsador (CX3) , realice tres (3) ciclos temporizados (A+/T1/A-), al final de los cuales debe quedar detenido en su posición inicial, una vez terminado, solo se podrá reiniciar la secuencia , reseteando el contador

con el pulsador (RESET),

posteriormente llevarlo a la Etapa inicial con el accionamiento del (INICIO).

para

pulsador 1) Especificaciones del sistema: Documentación del proceso

METODOLOGÍA GRAFCET - ARDUINO

2) Simulación del proceso

VIDEO GRAFCET FLUID SIM SENCILLO Y COMPLETO https://yout u.be/FFGBXn qjY80

VIDEO GRAFCET NORMA IEC 60848 https://youtu. be/O4S3jBgl3 TE

ESTRUCTURA LINEAL //TRATAMIENTO PREVIO //Decalaración de variables int E1; int E2; int E3; int E4; int S0 = 6; int S1 = 7; int S2 = 8; int S3 = 9; int S4 = 10; int Y2 = 2; int Y3 = 3; int Y4 = 4;

//TRATAMIENTO SECUENCIAL void loop() { S0 = digitalRead(6); S1 = digitalRead(7); S2 = digitalRead(8); S3 = digitalRead(9); S4 = digitalRead(10); E1 = ((E1 | (E4 & S3 )) & (~E2));

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); //Colocar los puertos de salida en 0v. digitalWrite(Y2, LOW); digitalWrite(Y3, LOW); digitalWrite(Y4, LOW); //Declaración del estado de las etapas E1 = HIGH; // Etapa inicial E2 = LOW; E3 = LOW; E4 = LOW;

E2 = ((E2 | (E1 & S0 )) & (~E3));

E3 = ((E3 | (E2 & (S1 | S4) )) & (~E4)); E4 = ((E4 | (E3 & S2)) & (~E1)) // 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);} }

METODOLOGÍA

GRAFCET - ARDUINO

3) Determinación de cantidad de E/S, temporizadores, contadores, etc.

4) Selección del ARDUINO

5) Conexión de E/S - Direcciones asignadas -Tipos NO/NC -Tipos de contactos (Normal-Negado)

ESTRUCTURA LINEAL //TRATAMIENTO SECUENCIAL

E1 = ((E1 | (E4 & S3 )) & (~E2)); E2 = ((E2 | (E1 & S0 )) & (~E3)); E3 = ((E3 | (E2 & (S1 | S4) )) & (~E4)); E4 = ((E4 | (E3 & S2)) & (~E1))

ESTRUCTURA ALTERNATIVA //TRATAMIENTO PREVIO //Decalaración de variables int E6; int E7; int E8; int E9; int E10; int S6 = 6; int S7 = 7; int S8 = 8; int S9 = 9; int S10 = 10; int Y2 = 2; int Y3 = 3; int Y4 = 4; int T1 ;

// Variables asociadas a "temp1". 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); //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; E7 = LOW;E8 = LOW; E9 = LOW;E10 = LOW; }

ESTRUCTURA ALTERNATIVA //TRATAMIENTO SECUENCIAL

void loop() { //Capturar valores de puertos digitales de entrada S6 = digitalRead(6); S7 = digitalRead(7); S8 = digitalRead(8); S9 = digitalRead(9); S10 = digitalRead(10); //Ecuaciones binodales para cada etapa

E6 = ((E6 | (E9 & S8) | (E10 & S10)) & (~E7) & (~E8)); E7 = ((E7 | (E6 & S6 & S7 )) & (~E9)); E9 = ((E9 | ( E7 & T1 )) & (~E6)); E8 = ((E8 | (E6 & S6 & S8)) & (~E10)); E10 = ((E10 | (E8 & S9)) & (~E6));

ESTRUCTURA ALTERNATIVA //TRATAMIENTO POSTERIOR

if (E6 == HIGH) {Serial.println("Etapa6");} if (E7 == HIGH) {digitalWrite(Y3, HIGH); Serial.println("Etapa7"); activetemp1();} else {digitalWrite(Y3, LOW); desactivetemp1();} 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");} }

ESTRUCTURA ALTERNATIVA //TRATAMIENTO POSTERIOR

//SUBRUTINA TEMPORIZADOR 1 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void activetemp1() { if (E7 == HIGH && activado1 == 0) { activado1 = 1 inicio1 = millis(); final1 = inicio1 + 5000;} 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;} //- - - - - - - - - - - - - - - - - - - - - - - - - -

ESTRUCTURA ALTERNATIVA //Ecuaciones binodales para cada etapa

E7 = ((E7 | (E6 & S6 & S7 )) & (~E9)); E9 = ((E9 | ( E7 & T1 )) & (~E6)); E8 = ((E8 | (E6 & S6 & S8)) & (~E10)); E10 = ((E10 | (E8 & S9)) & (~E6));

E6 = ((E6 | (E9 & S8) | (E10 & S10)) & (~E7) & (~E8));

ESTRUCTURA

SIMULTÁNEA

//TRATAMIENTO PREVIO //Decalaración de variables void setup() { int E12 ;int E14 ;int E15 ;int E16 ; int E17 ;int E18 ;int E19 ; Serial.begin(9600); int S11 = 6;int S3 = 7;int S4 = 8;int S7 = 9; //Declaración de puertos digitales// int S6 = 10;int S0 = 11; pinMode(S11, INPUT); pinMode(S3, INPUT); int Y6 = 2; int Y7 = 3;

pinMode(S4, INPUT); pinMode(S7, INPUT); pinMode(S6, INPUT); pinMode(S0, INPUT); pinMode(Y6, OUTPUT); pinMode(Y7, OUTPUT); //Colocar los puertos de salida en 0v. digitalWrite(Y6, LOW); digitalWrite(Y7, LOW); //Declaración del estado inicial de las etapas E12 = HIGH; E14 = LOW; E15 = LOW; E16 = LOW; E17 = LOW; E18 = LOW; E19 = LOW;

}

ESTRUCTURA void loop() { //TRATAMIENTO SECUENCIAL //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);

SIMULTÁNEA // Ecuaciones Binodales E12 = ((E12 | (E18 & E19&S0 )) & (~E14) & (~E15)); E14 = ((E14 | (E12&S11)) & (~E16)); E15 = ((E15 | (E12&S11)) & (~E17)); E16 = ((E16 | (E14 & S3)) & (~E18)); E17 = ((E17 | (E15 & S4)) & (~E19)); E18 = ((E18 | (E16 & S7)) & (~E12)); E19 = ((E19 | (E17 & S6)) & (~E12)); // TRATAMIENTO POSTERIOR if (E12 == HIGH) {Serial.println("Etapa12");} if (E14 == HIGH) {digitalWrite(Y6, HIGH); Serial.println("Etapa14");} 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");} }

ESTRUCTURA

SIMULTÁNEA

E12 = ((E12 | (E18 & E19&S0 )) & (~E14) & (~E15));

USO DEL CONTADOR //TRATAMIENTO PREVIO

//Decalaración de variables 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 // Variables asociadas al Flanco de la Etapa 2 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;

USO DEL CONTADOR //TRATAMIENTO PREVIO

void setup() { //Apertura del visualizador serial Serial.begin(9600); //Declaración de puertos digitales pinMode(6, INPUT); pinMode(2, OUTPUT); // Poner los puertos de salida en 0v. 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 }

USO DEL CONTADOR //TRATAMIENTO SECUENCIAL

void loop() { //Capturar valores de puertos digitales de entrada S0 = digitalRead(6);

// Ecuaciones binodales de ETAPAS E1 = ((E1 | (E4 & (CONTADOR >= PSCONTADOR) )) & (~E2)); E2 = ((E2 | (E1 & S0 ) | (E4 & (CONTADOR < PSCONTADOR))) & (~E3));

E3 = ((E3 | (E2 & T1 )) & (~E4)); E4 = ((E4 | (E3 & T2)) & (~E1) & (~E2)); delay(100); // solo para ayuda de visualización en el monitor serie

USO DEL CONTADOR //TRATAMIENTO SECUENCIAL // Ecuaciones binodales de ETAPAS E1 = ((E1 | (E4 & (CONTADOR >= PSCONTADOR) )) & (~E2)); E2 = ((E2 | (E1 & S0 ) | (E4 & (CONTADOR < PSCONTADOR))) & (~E3));

E3 = ((E3 | (E2 & T1 )) & (~E4)); E4 = ((E4 | (E3 & T2)) & (~E1) & (~E2)); delay(100); // solo para ayuda de visualización en el monitor serie

USO DEL CONTADOR

//TRATAMIENTO POSTERIOR if (E1 == HIGH) { Serial.println("Etapa1"); CONTADOR = 0; } if (E2 != ESTADOPREVIO_E2) { if (E2 == HIGH) { CONTADOR++; Serial.print("Numero de Ciclos : "); Serial.println(CONTADOR); } ESTADOPREVIO_E2 = E2; } 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"); } delay (100); // se usa para observar mejor el monitor serial } // Fin del Void Loop

USO DEL CONTADOR //SUBRUTINA TEMPORIZADOR 1 void activetemp1() { if (E2 == HIGH && activado1 == 0) { activado1 = 1; inicio1 = millis(); final1 = inicio1 + 5000; } actual1 = millis(); 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 IDEM

USO DEL CONTADOR //TRATAMIENTO POSTERIOR //SUBRUTINA TEMPORIZADOR 2 void activetemp2() { if (E3== HIGH && activado2 == 0) { activado2 = 1; inicio2 = millis(); final2 = inicio2 + 5000; } actual2 = millis(); if (activado2 == 1 && (actual2 > final2) ) { T2 = HIGH; } else { T2 = LOW; } } //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ------void desactivetemp2() { T2 = LOW; activado2 = 0; inicio2 = 0; final2 = 0; actual2 = 0; }

GRAFCET GENÉRICO

ESTUDIANTES DE INGENIERÍA MECATRÓNICA PROYECTO APLICADO REMACHADORA CON MULTIPLES MODOS DE OPERACIÓN

PROYECTO APLICADO ESTACIÓN MECATRÓNICA CLASIFICADORA DE PIEZAS

GRAFINO

GRAFCET EN LADDER