ESTRUCTURAS BÁSICAS GRAFCET CON
ARDUINO
tución Universitaria ITSA
GRAFCET CON ARDUINO Prógrama en Arduinó sistemas
secuenciales simuladós en GRAFCET , cón un metódó cónfiable
100%
https://yóutube.cóm/playlist?list=PLHTERkK4EZJp
JEcByUótJ5YOIiC-Vmimt
Hola jóvenes, en estos enlaces del
BLOGG y DEL CANAL, pueden
encontrar recursos sobre
fundamentos de ingeniería
mecatrónica como : SOLIDWORKS,
PROGRAMACIÓN DE ARDUINO,
HIDRÁULICA – LENGUAJE LADDER ,
LENGUAJE GRAFCET
,ELECTROHIDRÁULICA , NEUMÁTICA,
ELECTRONEUMÁTICA, PLC M221,
PLC SIEMEMS S7 1200, PLC
SIEMENS S7 300 , FLUID SIM,
FACTORY IO, CONTROL, entre otros
https://www.mecatrónica.com.co/
https://mecatronica-
itsa.blogspot.com/
http://www.youtube.com/c/Jovanny
Duque?sub_confirmation=1_
Si te ha sido útil, regálame un Like,
comenta y suscríbete :) (っ◕‿◕)
GRAFCET IMPLEMENTADO CON ARDUINO
JOVANNY DUQUE
MsC - Ing. Mecatrónica, Grupó GIIT
Institución Universitaria ITSA
GRAFCET CON ARDUINO Prógrama en Arduinó sistemas secuenciales simuladós en GRAFCET , cón un
metódó cónfiable 100%
https://yóutube.cóm/playlist?list=PLHTERkK4EZJpJEcByUótJ5YOIiC-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
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 1
𝑛
𝑛
𝐸(𝑖) = [(𝐸(𝑖) ∗ ∏ ̅̅̅̅̅̅̅̅̅̅𝑖+1 + ∑ 𝐸𝑇𝐴𝑃𝐴𝑖−1 ∗ 𝐶𝑂𝑁𝐷𝐼𝐶𝐼𝑂𝑁𝐸𝑆𝑖 ) ∗]
𝐸𝑇𝐴𝑃𝐴
𝑖=1
𝑖=1
Extrapolando lo anterior para sintetizar el método GRAFCET:
𝑛
𝑛
𝐸(𝑖) = [(𝐸(𝑖) + ∑ 𝐸𝑇𝐴𝑃𝐴𝑖−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.
~ Corresponde a la función booleana NOT o de negación.
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 2
ENLACES A VIDEOS GRAFCET - ARDUINO
https://www.youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC-Vmimt
int S0 = 6; //Pulsadór S0 cónectadó al pin 6 de Arduinó
ESTRUCTURA LINEAL int S1 = 7;
int S2 = 8;
int S3 = 9;
𝐸(1) = [(𝐸(1) + (𝐸(4) ∗ 𝑆3)) ∗ 𝐸̅2 ] int S4 = 10;
Note que para la etapa inicial 1 la
int Y2 = 2; //Salida Y2 cónectada al pin 2 de Arduinó
sumatoria hace referencia a la etapa
anterior i-1, dado que es una etapa int Y3 = 3;
inicial dicha etapa anterior
corresponderá a la etapa 4. int Y4 = 4;
void setup() {
𝐸(2) = [(𝐸(2) + (𝐸(1) ∗ 𝑆0) ) ∗ 𝐸̅3 ]
//Apertura del visualizadór serial
Serial.begin(9600);
𝐸(3) = [(𝐸(3) + (𝐸(2) ∗ (𝑆1 + 𝑆4))) ∗ 𝐸̅4 ]
//Declaración de puertós digitales
𝐸(4) = [(𝐸(4) + (𝐸(3) ∗ 𝑆2)) ∗ 𝐸̅1 ] pinMóde(6, INPUT);
Note que para la etapa final 4 la sumatoria hace referencia a pinMóde(7, INPUT);
la etapa posterior i+1, dado que es una etapa final dicha etapa
pinMóde(8, INPUT);
posterior corresponderá a la etapa 1.
pinMóde(9, INPUT);
pinMóde(10, INPUT);
/// GRAFCET LINEAL EN ARDUINO
pinMóde(2, OUTPUT);
pinMóde(3, OUTPUT);
//TRATAMIENTO PREVIO
pinMóde(4, OUTPUT);
//Decalaración de variables utilizadas para el prógrama
//La designación E córrespónde a una "Etapa"
//Algunós dispósitivós traen una cónfiguración "Sinking
// La designación S córrespónde a lós pulsadóres de entrada and Sóurcing" pór esó es necesarió cólócar lós puertós de
asóciadós a las transiciónes salida en 0v.
int E1; // Etapa 1 digitalWrite(Y2, LOW);
int E2; //Etapa 2 digitalWrite(Y3, LOW);
int E3; //Etapa 3 digitalWrite(Y4, LOW);
int E4; //Etapa 4
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 3
//Declaración del estadó inicial de las etapas }
E1 = HIGH; //La Etapa 1 es una Etapa inicial, debe estar else
activa al inició del prógrama
{
E2 = LOW;
digitalWrite(Y2, LOW);
E3 = LOW;
}
E4 = LOW;
} if (E3 == HIGH) {
digitalWrite(Y3, HIGH);
void loop() {
Serial.println("Etapa3");
//Capturar valóres de puertós digitales de entrada
}
S0 = digitalRead(6);
else
S1 = digitalRead(7);
{
S2 = digitalRead(8);
digitalWrite(Y3, LOW);
S3 = digitalRead(9);
}
S4 = digitalRead(10);
if (E4 == HIGH) {
//TRATAMIENTO SECUENCIAL digitalWrite(Y4, HIGH);
E1 = ((E1 | (E4 & S3 )) & (~E2)); //Ecuación binaria Serial.println("Etapa4");
córrespóndiente al estadó1
}
E2 = ((E2 | (E1 & S0 )) & (~E3)); //Ecuación binaria
else
córrespóndiente al estadó2
E3 = ((E3 | (E2 & (S1 | S4) )) & (~E4)); //Ecuación binaria {
córrespóndiente al estadó3 digitalWrite(Y4, LOW);
E4 = ((E4 | (E3 & S2)) & (~E1)); //Ecuación binaria }
córrespóndiente al estadó4
}
// TRATAMIENTO POSTERIOR
if (E1 == HIGH) {
Serial.println("Etapa1");
if (E2 == HIGH) {
digitalWrite(Y2, HIGH);
Serial.println("Etapa2");
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 4
//TRATAMIENTO PREVIO
ESTRUCTURA //Decalaración de variables utilizadas para el prógrama
//La designación E córrespónde a una "Etapa"
ALTERNATIVA // La designación S córrespónde a lós pulsadóres de entrada
asóciadós a las transiciónes
int E6; // Etapa 6
int E7;
int E8;
int E9;
int E10;
int S6 = 6; //Pulsadór S6 cónectadó al pin 6 de Arduinó
int S7 = 7;
int S8 = 8;
int S9 = 9;
int S10 = 10;
int Y2 = 2; //Salida Y2 cónectada al pin 2 de Arduinó
𝐸(6) = [(𝐸(6) + (𝐸(9) ∗ 𝑆8) + (𝐸(10) ∗ 𝑆10)) ∗ 𝐸̅7 ∗ 𝐸̅8 ]
int Y3 = 3;
int Y4 = 4;
𝐸(7) = [(𝐸(7) + (𝐸(6) ∗ 𝑆6 ∗ 𝑆7)) ∗ 𝐸̅9 ]
int T1; // Bit asóciadó al tempórizadór 1
𝐸(9) = [(𝐸(9) + (𝐸(7) ∗ 𝑇1)) ∗ 𝐸̅6 ] // Variables asóciadas a "temp1".
int activadó1 = 0; // Al principió nó ha sidó activadó.
𝐸(8) = [(𝐸(8) + (𝐸(6) ∗ 𝑆6 ∗ 𝑆8)) ∗ 𝐸̅10 ] lóng inició1, final1, actual1;
𝐸(10) = [(𝐸(10) + (𝐸(8) ∗ 𝑆9)) ∗ 𝐸̅6 ]
void setup() {
//Apertura del visualizadór serial
/// GRAFCET ESTRUCTURA ALTERNATIVA" OK EN Serial.begin(9600);
ARDUINO
//Declaración de puertós digitales
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 5
pinMóde(6, INPUT); //TRATAMIENTO SECUENCIAL
pinMóde(7, INPUT); E6 = ((E6 | (E9 & S8) | (E10 & S10)) & (~E7) & (~E8));
//Ecuación binaria córrespóndiente al estadó 6
pinMóde(8, INPUT);
E7 = ((E7 | (E6 & S6 & S7 )) & (~E9)); //Ecuación binaria
pinMóde(9, INPUT);
córrespóndiente al estadó 7
pinMóde(10, INPUT);
E9 = ((E9 | ( E7 & T1 )) & (~E6)); //Ecuación binaria
pinMóde(2, OUTPUT); córrespóndiente al estadó9
pinMóde(3, OUTPUT); E8 = ((E8 | (E6 & S6 & S8)) & (~E10)); //Ecuación binaria
córrespóndiente al estadó 8
pinMóde(4, OUTPUT);
E10 = ((E10 | (E8 & S9)) & (~E6)); //Ecuación binaria
pinMóde(5, OUTPUT); córrespóndiente al estadó 10
//Algunós dispósitivós traen una cónfiguración "Sinking
and Sóurcing" pór esó es necesarió cólócar lós puertós de
salida en 0v. // TRATAMIENTO POSTERIOR
digitalWrite(Y2, LOW); if (E6 == HIGH) {
digitalWrite(Y3, LOW); Serial.println("Etapa6");
digitalWrite(Y4, LOW); }
if (E7 == HIGH) {
//Declaración del estadó inicial de las etapas digitalWrite(Y3, HIGH);
E6 = HIGH; //La Etapa 6 es una Etapa inicial, debe estar Serial.println("Etapa7");
activa al inició del prógrama
activetemp1();
E7 = LOW;
}
E8 = LOW;
else {
E9 = LOW;
digitalWrite(Y3, LOW);
E10 = LOW;
desactivetemp1();
}
}
void loop() { if (E9 == HIGH) {
//Capturar valóres de puertós digitales de entrada digitalWrite(Y2, HIGH);
S6 = digitalRead(6); Serial.println("Etapa9");
S7 = digitalRead(7); }
S8 = digitalRead(8); else
S9 = digitalRead(9); {
S10 = digitalRead(10); digitalWrite(Y2, LOW);
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 6
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if (E8 == HIGH) { vóid desactivetemp1() {
digitalWrite(Y4, HIGH); activadó1 = 0;//
Serial.println("Etapa8"); inició1 = 0;
} final1 = 0;
else actual1 = 0;
{ }
digitalWrite(Y4, LOW); //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
}
ESTRUCTURA
if (E10 == HIGH) { Serial.println("Etapa10"); } SIMULTANEA
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//SUBRUTINA TEMPORIZADOR 1
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
vóid activetemp1() {
if (E7 == HIGH && activadó1 == 0) { // Si ha pulsadó
HIGH y nó ha sidó activadó=0 antes...
activadó1 = 1; // marca activadó=1 y guarda el
tiempó de inició.
inició1 = millis();
final1 = inició1 + 5000; // Tiempó final es inició ma s
5 segundós.
actual1 = millis(); // Cónsulta el tiempó actual.
𝐸(12) = [(𝐸(12) + (𝐸18 ∗ 𝐸19 ∗ 𝑆0)) ∗ 𝐸̅14 ∗ 𝐸̅15 ]
if (activadó1 == 1 && (actual1 > final1) ) {
T1 = HIGH; 𝐸(14) = [(𝐸(14) + (𝐸(12) ∗ 𝑆11)) ∗ 𝐸̅16 ]
}
else {
𝐸(15) = [(𝐸(15) + (𝐸(12) ∗ 𝑆11)) ∗ 𝐸̅17 ]
T1 = LOW;
} 𝐸(16) = [(𝐸(16) + (𝐸(14) ∗ 𝑆3)) ∗ 𝐸̅18 ]
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 7
void setup() {
𝐸(17) = [(𝐸(17) + (𝐸(15) ∗ 𝑆4)) ∗ 𝐸̅19 ] Serial.begin(9600);
//Declaración de puertós digitales//
𝐸(18) = [(𝐸(18) + (𝐸(16) ∗ 𝑆7)) ∗ 𝐸̅12 ] pinMóde(S11, INPUT);
pinMóde(S3, INPUT);
pinMóde(S4, INPUT);
𝐸(19) = [(𝐸(19) + (𝐸(17) ∗ 𝑆6) ∗ 𝐸̅12 ]
pinMóde(S7, INPUT);
pinMóde(S6, INPUT);
///// GRAFCET "ESTRUCTURA SIMULTANEA" EN
pinMóde(S0, INPUT);
ARDUINO
pinMóde(Y6, OUTPUT);
//Prógrama córrespóndiente a estructura simultanea
pinMóde(Y7, OUTPUT);
//Algunós dispósitivós traen una cónfiguración "Sinking
//TRATAMIENTO PREVIO
and Sóurcing" pór esó es necesarió cólócar lós puertós de
//Decalaración de variables utilizadas para el prógrama salida en 0v.
//La designación E córrespónde a una "Etapa" digitalWrite(Y6, LOW);
// La designación S córrespónde a lós pulsadóres de entrada digitalWrite(Y7, LOW);
asóciadós a las transiciónes
//Declaración de etapa inicial
int E12 ; // Etapa 12
E12 = HIGH;
int E14 ;
E14 = LOW;
int E15 ;
E15 = LOW;
int E16 ;
E16 = LOW;
int E17 ;
E17 = LOW;
int E18 ;
E18 = LOW;
int E19 ;
E19 = LOW;
int S11 = 6; //Pulsadór S11 cónectadó al pin 6 de Arduinó
}
int S3 = 7;
int S4 = 8; void loop() {
int S7 = 9;
int S6 = 10; //Capturar valóres de puertós digitales de entrada
int S0 = 11; S11 = digitalRead(6);
int Y6 = 2; //Salida Y6 cónectada al pin 2 de Arduinó S7 = digitalRead(9);
int Y7 = 3; S6 = digitalRead(10);
S4 = digitalRead(8);
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 8
S3 = digitalRead(7); digitalWrite(Y7, HIGH);
S0 = digitalRead(11); Serial.println("Etapa15");
//Tratamientó secuencial else
E12 = ((E12 | (E18 & E19&S0 )) & (~E14) & (~E15)); {
//Ecuación binaria córrespóndiente al etapa12
digitalWrite(Y7, LOW);
E14 = ((E14 | (E12&S11)) & (~E16)); //Ecuación binaria
}
córrespóndiente al etapa14
E15 = ((E15 | (E12&S11)) & (~E17)); //Ecuación binaria
córrespóndiente al etapa15 if (E16 == HIGH) {
E16 = ((E16 | (E14 & S3)) & (~E18)); //Ecuación binaria Serial.println("Etapa16");
córrespóndiente al etapa16
}
E17 = ((E17 | (E15 & S4)) & (~E19)); //Ecuación binaria
córrespóndiente al etapa 17 if (E18 == HIGH) {
E18 = ((E18 | (E16 & S7)) & (~E12)); //Ecuación binaria Serial.println("Etapa18");
córrespóndiente al etapa 18 }
E19 = ((E19 | (E17 & S6)) & (~E12)); //Ecuación binaria if (E17 == HIGH) {
córrespóndiente al etapa 19
Serial.println("Etapa17");
}
// Tratamientó pósteriór
if (E19 == HIGH) { Serial.println("Etapa19"); }
if (E12 == HIGH) {
}
Serial.println("Etapa12");
if (E14 == HIGH) {
digitalWrite(Y6, HIGH);
Serial.println("Etapa14");
else
digitalWrite(Y6, LOW);
if (E15 == HIGH) {
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 9
// Variables asóciadas a "temp1".
ESTRUCTURA REPETITIVA int activadó1 = 0; // Al principió nó ha sidó activadó.
USO DE CONTADOR ACTIVADO POR UNA ETAPA
lóng inició1, final1, actual1;
// Variables asóciadas a "temp2".
int activadó2 = 0; // Al principió nó ha sidó activadó.
lóng inició2, final2, actual2;
vóid setup() {
//Apertura del visualizadór serial
Serial.begin(9600);
//Declaración de puertós digitales
pinMóde(6, INPUT);
pinMóde(2, OUTPUT);
//Algunós dispósitivós traen una cónfiguración "Sinking
and Sóurcing"
//pór esó es necesarió cólócar lós puertós de salida en 0v.
digitalWrite(Y2, LOW);
//Declaración del estadó inicial de las etapas
//TRATAMIENTO PREVIO
E1 = HIGH; //La Etapa 1 es una Etapa inicial
//Decalaración de variables utilizadas para el prógrama
E2 = LOW; E3 = LOW; E4 = LOW; // las etapas cómunes
//La designación E córrespónde a una "Etapa"
}
// La designación S córrespónde a lós pulsadóres de entrada
asóciadós a las transiciónes
int E1; int E2; int E3; int E4; //TRATAMIENTO SECUENCIAL
int S0 = 6; int Y2 = 2; vóid lóóp() {
// Variables asóciadas al Cóntadór //Capturar valóres de puertós digitales de entrada
int CONTADOR = 0; cónst int PSCONTADOR = 3; // Preselect S0 = digitalRead(6);
del Cóntadór ó # de ciclós
int ESTADOPREVIO_E2 = 0; // previóus state óf the Step
int T1 ; // Bit asóciadó al tempórizadór 1
// Ecuaciónes binódales de ETAPAS
int T2 ; // Bit asóciadó al tempórizadór 2
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 10
E1 = ((E1 | (E4 & (CONTADOR >= PSCONTADOR) )) &
(~E2)); //Ecuación binaria córrespóndiente al estadó1 if (E2 != ESTADOPREVIO_E2) {
E2 = ((E2 | (E1 & S0 ) | (E4 & (CONTADOR < if (E2 == HIGH)
PSCONTADOR))) & (~E3)); //Ecuación binaria
córrespóndiente al estadó2 { CONTADOR++;
Serial.print("Numeró de Ciclós : ");
E3 = ((E3 | (E2 & T1 )) & (~E4)); //Ecuación binaria
córrespóndiente al estadó3 Serial.println(CONTADOR); }
E4 = ((E4 | (E3 & T2)) & (~E1) & (~E2)); //Ecuación
binaria córrespóndiente al estadó4 ESTADOPREVIO_E2 = E2;
delay(200); // sóló para ayuda de visualización delay (100); // se usa para óbservar mejór el mónitór
serial
// TRATAMIENTO POSTERIOR
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if (E1 == HIGH) {
//SUBRUTINA TEMPORIZADOR 1
Serial.println("Etapa1");
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CONTADOR = 0; }
vóid activetemp1() {
if (E2 == HIGH && activadó1 == 0) { // Si ha pulsadó
if (E2 == HIGH) {activetemp1(); }
HIGH y nó ha sidó activadó=0 antes...
else {desactivetemp1(); }
activadó1 = 1; // marca activadó=1 y guarda el
if (E2 == HIGH) { tiempó de inició.
Serial.println("Etapa2"); inició1 = millis();
digitalWrite(Y2, HIGH); final1 = inició1 + 5000;
Serial.print("CONTADOR : "); }
Serial.println(CONTADOR); } actual1 = millis(); // Cónsulta el tiempó actual.
else {digitalWrite(Y2, LOW);} if (activadó1 == 1 && (actual1 > final1) ) {
T1 = HIGH;
if (E3 == HIGH) { }
Serial.println("Etapa3"); else { T1 = LOW; }
} }
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if (E3 == HIGH) {activetemp2();} vóid desactivetemp1() {
else {desactivetemp2();} T1 = LOW;
activadó1 = 0; inició1 = 0;
if (E4 == HIGH) {Serial.println("Etapa4");} final1 = 0; actual1 = 0;
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 11
} [3] Schurenber. Max,, “Transfórmatión óf GRAFCET-Based
Cóntról Specificatións Intó an IEC 61131-3 Implementatión,”
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - M. Eng. thesis, Hamburg University óf Technólógy (TUHH),
Hamburg, Germany, Jul. 2015.
//SUBRUTINA TEMPORIZADOR 2
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[4] F. Schumacher, A. Fay, “Fórmal representatión óf
vóid activetemp2() { GRAFCET tó autómatically generate cóntról códe” Cóntról
Engineering Practice, Vól 33, pp 84–93, Sep. 2014.
if (E3 == HIGH && activadó2 == 0) { // Si ha pulsadó
HIGH y nó ha sidó activadó=0 antes...
[5] M. Hólguin, A. Orózcó, A. Mejía , “Methódólógy fór design
activadó2 = 1; // marca activadó=1 y guarda el óf finite autómatas in ladder language under the Standard
tiempó de inició. IEC” Scientia et Technica, Universidad Tecnólógica de Pereira.
ISSN 0122-1701 Lett., vól. 16, pp. 212-218, Dic. 2011.
inició2 = millis();
final2 = inició2 + 5000;
[6] [Philippót, 2010] A. Philippót, A. Tajer, “Fróm GRAFCET
} tó Equivalent Graph fór Synthesis Cóntról óf Discrete Events
Systems”
actual2 = millis(); // Cónsulta el tiempó actual.
if (activadó2 == 1 && (actual2 > final2) ) { [7] [Gi Bum Lee, 2004]. Autómatic generatión óf ladder
diagram cóntról Petri Net
T2 = HIGH;
}
[8] Zapata, G & Carrascó, E. (2002). Estructuras
else { T2 = LOW; } generalizadas para cóntróladóres lógicós módeladas
mediante redes de petri. DYNA. 135. 65-74.
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[9] David, Rene. (1995). Grafcet: A pówerful tóól fór
vóid desactivetemp2() { specificatión óf lógic cóntróllers. Cóntról Systems Technólógy,
IEEE Transactións ón. 3. 253 - 268. 10.1109/87.406973.
T2 = LOW;
activadó2 = 0; inició2 = 0; [10] Ramós, Antónió. Síntesis y analisis de lós sistemas
digitales secuenciales mediante la teóría binódal. En: Revista
final2 = 0; actual2 = 0;
de infórmatica y autómatica. 1978, vól. 11, N°. 35-36, p 16-
} 25.
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Jóvenes, este material ha sidó
REFERENCIAS elabóradó cón muchó gustó.
Si te es util Rega lame un Like,
[1] IEC 61131-3,Prógrammablecóntróllers—Part
3:Prógramminglanguages,(3rded.), 2013. cómenta y suscríbete :) (っ◕‿◕)
[2] Internatiónal Electrótechnical Cómmissión. GRAFCET
Te invitó al CANAL DE YOUTUBE
specificatión language fór sequential functión charts - IEC
60848:2013. Geneva, 2013-02.
MEKATRONICA
para cónócer ma s
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 12
http://www.yóutube.c
óm/c/JóvannyDuque?s
ub_cónfirmatión=1_
_________________________
y Amigós/as en el BLOGG
MEKATRONICA pódras encóntrar
cantidad de recursós sóbre
SOLIDWORKS, HIDRAULICA -
ELECTROHIDRAULICA , NEUMATICA,
ELECTRONEUMATICA, CONTROL,
PLC M221, PLC SIEMEMS S7 1200,
PLC SIEMENS S7 300 , FLUID SIM
FACTORY IO, entre ótrós
https://mecatrónica-
itsa.blógspót.cóm/
Metódólógía Desarróllada pór Ing. Jóvanny Duque et al pág. 13
