GRAFCET con ARDUINO - GRAFCET IMPLEMENTADO CON ARDUINO.

(1)

Metodología Desarrollada por Ing. Jovanny Duque et al pág. 1

GRAFCET IMPLEMENTADO CON ARDUINO

JOVANNY DUQUE MsC - Ing. Mecatrónica, Grupo GIIT

Institución Universitaria ITSA

GRAFCET CON ARDUINO Programa en Arduino sistemas secuenciales simulados en GRAFCET , con un método confiable 100%

https://youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC-Vmimt

De los trabajos de A. Ramos, se entiende al Binodo como un elemento de programación que solo puede tener dos estados posibles, S y 𝑆̅ (activado o desactivado). Donde 𝑀_𝑖 corresponde a las (V.D.A) variables de activación del binodo y 𝑃_𝑗 corresponde a las (V.D.D) variables de desactivación del binodo.

A partir de este modelo se desprende que el comportamiento de un BINODO dentro de la lógica Binodal que puede ser descrito por la expresión matemática:

𝑆

_(𝑡)

= [(𝑆 + ∑ 𝑀

_𝑖

𝑛

𝑖=1

) ∗ ∏

^𝑚

𝑃 ̅

_𝑗

𝑗=1

]

𝐸_(𝑖) = [(𝐸_(𝑖) ∗ ∏^𝑛 𝐸𝑇𝐴𝑃𝐴̅̅̅̅̅̅̅̅̅̅_𝑖+1

𝑖=1

+ ∑ 𝐸𝑇𝐴𝑃𝐴_𝑖−1

𝑛

𝑖=1

∗ 𝐶𝑂𝑁𝐷𝐼𝐶𝐼𝑂𝑁𝐸𝑆_𝑖) ∗]

Extrapolando lo anterior para sintetizar el método GRAFCET:

𝐸_(𝑖) = [(𝐸_(𝑖) + ∑ 𝐸𝑇𝐴𝑃𝐴_𝑖−1

𝑛

𝑖=1

∗ 𝐶𝑂𝑁𝐷𝐼𝐶𝐼𝑂𝑁𝐸𝑆_𝑖) ∗ ∏^𝑛 𝐸𝑇𝐴𝑃𝐴̅̅̅̅̅̅̅̅̅̅_𝑖+1

𝑖=1

]

(2)

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.

~ Corresponde a la función booleana NOT o de negación.

ENLACES A VIDEOS GRAFCET - ARDUINO

https://www.youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC-Vmimt

ESTRUCTURA LINEAL

𝐸₍₁₎= [(𝐸₍₁₎+ (𝐸₍₄₎∗ 𝑆3)) ∗ 𝐸̅₂] Note que para la etapa inicial 1 la sumatoria

hace referencia a la etapa anterior i-1, dado que es una etapa inicial dicha etapa anterior corresponderá a la etapa 4.

𝐸₍₂₎ = [(𝐸₍₂₎+ (𝐸₍₁₎∗ 𝑆0) ) ∗ 𝐸̅₃]

𝐸₍₃₎= [(𝐸₍₃₎+ (𝐸₍₂₎∗ (𝑆1 + 𝑆4))) ∗ 𝐸̅₄]

𝐸₍₄₎ = [(𝐸₍₄₎+ (𝐸₍₃₎∗ 𝑆2)) ∗ 𝐸̅₁] Note que para la etapa final 4 la sumatoria hace referencia a la etapa posterior i+1, dado que es una etapa final dicha etapa posterior corresponderá a la etapa 1.

/// GRAFCET LINEAL EN 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; // 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);

//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);

//TRATAMIENTO SECUENCIAL

E1 = ((E1 | (E4 & S3 )) & (~E2)); //Ecuación binaria correspondiente al estado1

(3)

Metodología Desarrollada por Ing. Jovanny Duque et al pág. 3 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 {

}

} else {

}

} else {

} }

ESTRUCTURA ALTERNATIVA

𝐸₍₆₎= [(𝐸₍₆₎+ (𝐸₍₉₎∗ 𝑆8) + (𝐸₍₁₀₎∗ 𝑆10)) ∗ 𝐸̅₇∗ 𝐸̅₈]

𝐸₍₇₎ = [(𝐸₍₇₎+ (𝐸₍₆₎∗ 𝑆6 ∗ 𝑆7)) ∗ 𝐸̅₉] 𝐸₍₉₎ = [(𝐸₍₉₎+ (𝐸₍₇₎∗ 𝑇1)) ∗ 𝐸̅₆]

𝐸₍₈₎ = [(𝐸₍₈₎+ (𝐸₍₆₎∗ 𝑆6 ∗ 𝑆8)) ∗ 𝐸̅₁₀] 𝐸₍₁₀₎ = [(𝐸₍₁₀₎+ (𝐸₍₈₎∗ 𝑆9)) ∗ 𝐸̅₆]

/// GRAFCET ESTRUCTURA ALTERNATIVA" OK EN ARDUINO

//TRATAMIENTO PREVIO

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 Y4 = 4;

int T1; // Bit asociado al temporizador 1

(4)

// Variables asociadas a "temp1".

int activado1 = 0; // Al principio no ha sido activado.

long inicio1, final1, actual1;

void setup() {

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.

//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() {

//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) {

}

activetemp1();

} else {

desactivetemp1();

}

} else {

}

} else {

}

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.

}

(5)

Metodología Desarrollada por Ing. Jovanny Duque et al pág. 5 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 SIMULTÁNEA

𝐸₍₁₂₎= [(𝐸₍₁₂₎+ (𝐸₁₈∗ 𝐸₁₉∗ 𝑆0)) ∗ 𝐸̅₁₄∗ 𝐸̅₁₅]

𝐸₍₁₄₎ = [(𝐸₍₁₄₎+ (𝐸₍₁₂₎∗ 𝑆11)) ∗ 𝐸̅₁₆] 𝐸₍₁₅₎ = [(𝐸₍₁₅₎+ (𝐸₍₁₂₎∗ 𝑆11)) ∗ 𝐸̅₁₇]

𝐸₍₁₆₎ = [(𝐸₍₁₆₎+ (𝐸₍₁₄₎∗ 𝑆3)) ∗ 𝐸̅₁₈] 𝐸₍₁₇₎ = [(𝐸₍₁₇₎+ (𝐸₍₁₅₎∗ 𝑆4)) ∗ 𝐸̅₁₉] 𝐸₍₁₈₎ = [(𝐸₍₁₈₎+ (𝐸₍₁₆₎∗ 𝑆7)) ∗ 𝐸̅₁₂]

𝐸₍₁₉₎ = [(𝐸₍₁₉₎+ (𝐸₍₁₇₎∗ 𝑆6) ∗ 𝐸̅₁₂]

///// GRAFCET "ESTRUCTURA SIMULTANEA"

EN ARDUINO

//Programa correspondiente a estructura simultanea

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;

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.

//Declaración de etapa inicial E12 = HIGH;

E14 = LOW;

E15 = LOW;

E16 = LOW;

E17 = LOW;

E18 = LOW;

E19 = LOW;

}

void loop() {

//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

(6)

// Tratamiento posterior if (E12 == HIGH) { Serial.println("Etapa12");

}

} else {

}

} else {

}

if (E19 == HIGH) { Serial.println("Etapa19"); } }

ESTRUCTURA REPETITIVA

USO DE CONTADOR ACTIVADO POR UNA ETAPA

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".

// Variables asociadas a "temp2".

void setup() {

pinMode(2, OUTPUT);

//Algunos dispositivos traen una configuración "Sinking and Sourcing"

//por eso es necesario colocar los puertos de salida en 0v.

(7)

Metodología Desarrollada por Ing. Jovanny Duque et al pág. 7 //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() {

// 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

CONTADOR = 0; }

if (E2 == HIGH) {activetemp1(); } else {desactivetemp1(); }

digitalWrite(Y2, HIGH);

Serial.print("CONTADOR : ");

Serial.println(CONTADOR); } else {digitalWrite(Y2, LOW);}

}

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 }

inicio1 = millis();

final1 = inicio1 + 5000;

}

actual1 = millis(); // Consulta el tiempo actual.

}

else { T1 = LOW; } }

T1 = LOW;

activado1 = 0; inicio1 = 0;

final1 = 0; actual1 = 0;

}

inicio2 = millis();

final2 = inicio2 + 5000;

}

actual2 = millis(); // Consulta el tiempo actual.

}

else { T2 = LOW; } }

T2 = LOW;

activado2 = 0; inicio2 = 0;

final2 = 0; actual2 = 0;

}

//- - - REFERENCIAS

[1] IEC 61131-3,Programmablecontrollers—Part 3:Programminglanguages,(3rded.), 2013.

[2] International Electrotechnical Commission. GRAFCET specification language for sequential function charts - IEC 60848:2013. Geneva, 2013-02.

[3] Schürenber. Max,, “Transformation of GRAFCET-Based Control Speciﬁcations Into an IEC 61131-3 Implementation,” M.

Eng. thesis, Hamburg University of Technology (TUHH), Hamburg, Germany, Jul. 2015.

[4] F. Schumacher, A. Fay, “Formal representation of GRAFCET to automatically generate control code” Control Engineering Practice, Vol 33, pp 84–93, Sep. 2014.

(8)

[5] M. Holguin, A. Orozco, A. Mejía , “Methodology for design of finite automatas in ladder language under the Standard IEC”

Scientia et Technica, Universidad Tecnológica de Pereira. ISSN 0122-1701 Lett., vol. 16, pp. 212-218, Dic. 2011.

[6] [Philippot, 2010] A. Philippot, A. Tajer, “From GRAFCET to Equivalent Graph for Synthesis Control of Discrete Events Systems”

[7] [Gi Bum Lee, 2004]. Automatic generation of ladder diagram control Petri Net

[8] Zapata, G & Carrasco, E. (2002). Estructuras generalizadas para controladores lógicos modeladas mediante redes de petri.

DYNA. 135. 65-74.

[9] David, Rene. (1995). Grafcet: A powerful tool for specification of logic controllers. Control Systems Technology, IEEE Transactions on. 3. 253 - 268. 10.1109/87.406973.

[10] Ramos, Antonio. Síntesis y análisis de los sistemas digitales secuenciales mediante la teoría binodal. En: Revista de informática y automática. 1978, vol. 11, N°. 35-36, p 16-25.

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

http://www.youtube.co m/c/JovannyDuque?sub

_confirmation=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

GRAFCET con ARDUINO - GRAFCET IMPLEMENTADO CON ARDUINO.

𝑆

= [(𝑆 + ∑ 𝑀

) ∗ ∏

𝑃 ̅

]

ESTRUCTURA LINEAL

ESTRUCTURA ALTERNATIVA

ESTRUCTURA SIMULTÁNEA

ESTRUCTURA REPETITIVA

http://www.youtube.co m/c/JovannyDuque?sub

_confirmation=1_

_________________________

https://mecatronica-

itsa.blogspot.com/