GRAFCET IMPLEMENTADO CON ARDUINO https://youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC -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://mecatronicaitsa.blogspot.com/ http://www.youtube.com/c/JovannyDu que?sub_confirmation=1_ Si te ha sido útil, regálame un Like, comenta y suscríbete :) (っ◕‿◕)
SISTEMAS DE AUTOMATIZACIÓN SECUENCIALES IMPLEMENTADOS EN GRAFCET SOBRE ARDUINO
ARDUINO Acceso a PDF
https://play.google.com/books/s/370286768613/ebooks https://mega.nz/folder/a9thTIjA#bSAwbpbG3Z34DW3jJ_bMQg
ARDUINO Aprende a programar Arduino desde una solucio n LADDER o GRAFCET con metodologí as confiables https://youtube.com/playlist?list=PLHTERkK4EZJr7zDQNKjjEyxhErjllCCUy
GRAFCET CON ARDUINO Programa en Arduino sistemas secuenciales simulados en GRAFCET , con un metodo confiable 100% https://youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC-Vmimt
Metodología Desarrollada por Ing. Jovanny Duque et al pág. 1
GRAFCET IMPLEMENTADO CON ARDUINO JOVANNY DUQUE MsC - Ing. Mecatronica, Grupo GIIT Institucion Universitaria ITSA
GRAFCET CON ARDUINO Programa en Arduino sistemas secuenciales simulados en GRAFCET , con un metodo 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
Metodología Desarrollada por Ing. Jovanny Duque et al pág. 2
𝑗=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.
ENLACES A VIDEOS GRAFCET - ARDUINO https://www.youtube.com/playlist?list=PLHTERkK4EZJpJEcByUotJ5YOIiC-Vmimt
Metodología Desarrollada por Ing. Jovanny Duque et al pág. 3
ESTRUCTURA LINEAL
𝐸(1) = [(𝐸(1) + (𝐸(4) ∗ 𝑆3)) ∗ 𝐸̅2 ]
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.
𝐸(2) = [(𝐸(2) + (𝐸(1) ∗ 𝑆0) ) ∗ 𝐸̅3 ]
𝐸(3) = [(𝐸(3) + (𝐸(2) ∗ (𝑆1 + 𝑆4))) ∗ 𝐸̅4 ]
𝐸(4) = [(𝐸(4) + (𝐸(3) ∗ 𝑆2)) ∗ 𝐸̅1 ] 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 //Decalaracion de variables utilizadas para el programa //La designacion E corresponde a una "Etapa" // La designacion 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); //Declaracion 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 configuracion "Sinking and Sourcing" por eso es necesario colocar los puertos de salida en 0v. digitalWrite(Y2, LOW); digitalWrite(Y3, LOW); digitalWrite(Y4, LOW);
//Declaracion 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);
5
S1 = digitalRead(7); S2 = digitalRead(8); S3 = digitalRead(9); S4 = digitalRead(10);
//TRATAMIENTO SECUENCIAL E1 = ((E1 | (E4 & S3 )) & (~E2)); //Ecuacion binaria correspondiente al estado1 E2 = ((E2 | (E1 & S0 )) & (~E3)); //Ecuacion binaria correspondiente al estado2 E3 = ((E3 | (E2 & (S1 | S4) )) & (~E4)); //Ecuacion binaria correspondiente al estado3 E4 = ((E4 | (E3 & S2)) & (~E1)); //Ecuacion 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 {
6
digitalWrite(Y3, LOW); } if (E4 == HIGH) { digitalWrite(Y4, HIGH); Serial.println("Etapa4"); } else { digitalWrite(Y4, LOW); } }
ESTRUCTURA ALTERNATIVA
7
𝐸(6) = [(𝐸(6) + (𝐸(9) ∗ 𝑆8) + (𝐸(10) ∗ 𝑆10)) ∗ 𝐸̅7 ∗ 𝐸̅8 ]
𝐸(7) = [(𝐸(7) + (𝐸(6) ∗ 𝑆6 ∗ 𝑆7)) ∗ 𝐸̅9 ]
𝐸(9) = [(𝐸(9) + (𝐸(7) ∗ 𝑇1)) ∗ 𝐸̅6 ]
𝐸(8) = [(𝐸(8) + (𝐸(6) ∗ 𝑆6 ∗ 𝑆8)) ∗ 𝐸̅10 ]
𝐸(10) = [(𝐸(10) + (𝐸(8) ∗ 𝑆9)) ∗ 𝐸̅6 ]
/// GRAFCET ESTRUCTURA ALTERNATIVA" OK EN ARDUINO
//TRATAMIENTO PREVIO //Decalaracion de variables utilizadas para el programa //La designacion E corresponde a una "Etapa" // La designacion 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;
8
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". int activado1 = 0; // Al principio no ha sido activado. long inicio1, final1, actual1;
void setup() { //Apertura del visualizador serial Serial.begin(9600);
//Declaracion 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 configuracion "Sinking and Sourcing" por eso es necesario colocar los puertos de salida en 0v. digitalWrite(Y2, LOW); digitalWrite(Y3, LOW); digitalWrite(Y4, LOW);
//Declaracion del estado inicial de las etapas E6 = HIGH; //La Etapa 6 es una Etapa inicial, debe estar activa al inicio del programa
9
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)); //Ecuacion binaria correspondiente al estado 6 E7 = ((E7 | (E6 & S6 & S7 )) & (~E9)); //Ecuacion binaria correspondiente al estado 7 E9 = ((E9 | ( E7 & T1 )) & (~E6)); //Ecuacion binaria correspondiente al estado9 E8 = ((E8 | (E6 & S6 & S8)) & (~E10)); //Ecuacion binaria correspondiente al estado 8 E10 = ((E10 | (E8 & S9)) & (~E6)); //Ecuacion binaria correspondiente al estado 10
// TRATAMIENTO POSTERIOR if (E6 == HIGH) { Serial.println("Etapa6"); } if (E7 == HIGH) { digitalWrite(Y3, HIGH); Serial.println("Etapa7"); activetemp1(); } else {
10
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"); } } //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //SUBRUTINA TEMPORIZADOR 1 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void activetemp1() { if (E7 == HIGH && activado1 == 0) { activado1 = 1;
// Si ha pulsado HIGH y no ha sido activado=0 antes...
// marca activado=1 y guarda el tiempo de inicio.
inicio1 = millis();
11
final1 = inicio1 + 5000;
// Tiempo final es inicio mas 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; } //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ESTRUCTURA SIMULTANEA
𝐸(12) = [(𝐸(12) + (𝐸18 ∗ 𝐸19 ∗ 𝑆0)) ∗ 𝐸̅14 ∗ 𝐸̅15 ]
𝐸(14) = [(𝐸(14) + (𝐸(12) ∗ 𝑆11)) ∗ 𝐸̅16 ]
𝐸(15) = [(𝐸(15) + (𝐸(12) ∗ 𝑆11)) ∗ 𝐸̅17 ]
𝐸(16) = [(𝐸(16) + (𝐸(14) ∗ 𝑆3)) ∗ 𝐸̅18 ]
12
𝐸(17) = [(𝐸(17) + (𝐸(15) ∗ 𝑆4)) ∗ 𝐸̅19 ]
𝐸(18) = [(𝐸(18) + (𝐸(16) ∗ 𝑆7)) ∗ 𝐸̅12 ]
𝐸(19) = [(𝐸(19) + (𝐸(17) ∗ 𝑆6) ∗ 𝐸̅12 ]
///// GRAFCET "ESTRUCTURA SIMULTANEA" EN ARDUINO //Programa correspondiente a estructura simultanea
//TRATAMIENTO PREVIO //Decalaracion de variables utilizadas para el programa //La designacion E corresponde a una "Etapa" // La designacion 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;
13
void setup() { Serial.begin(9600); //Declaracion 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 configuracion "Sinking and Sourcing" por eso es necesario colocar los puertos de salida en 0v. digitalWrite(Y6, LOW); digitalWrite(Y7, LOW); //Declaracion 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);
14
S3 = digitalRead(7); S0 = digitalRead(11);
//Tratamiento secuencial E12 = ((E12 | (E18 & E19&S0 )) & (~E14) & (~E15)); //Ecuacion binaria correspondiente al etapa12 E14 = ((E14 | (E12&S11)) & (~E16)); //Ecuacion binaria correspondiente al etapa14 E15 = ((E15 | (E12&S11)) & (~E17)); //Ecuacion binaria correspondiente al etapa15 E16 = ((E16 | (E14 & S3)) & (~E18)); //Ecuacion binaria correspondiente al etapa16 E17 = ((E17 | (E15 & S4)) & (~E19)); //Ecuacion binaria correspondiente al etapa 17 E18 = ((E18 | (E16 & S7)) & (~E12)); //Ecuacion binaria correspondiente al etapa 18 E19 = ((E19 | (E17 & S6)) & (~E12)); //Ecuacion binaria correspondiente al etapa 19
// 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
15
{ 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 REPETITIVA USO DE CONTADOR ACTIVADO POR UNA ETAPA
16
//TRATAMIENTO PREVIO //Decalaracion de variables utilizadas para el programa //La designacion E corresponde a una "Etapa" // La designacion 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);
//Declaracion de puertos digitales pinMode(6, INPUT); pinMode(2, OUTPUT);
//Algunos dispositivos traen una configuracion "Sinking and Sourcing" //por eso es necesario colocar los puertos de salida en 0v. digitalWrite(Y2, LOW);
17
//Declaracion 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)); //Ecuacion binaria correspondiente al estado1 E2 = ((E2 | (E1 & S0 ) | (E4 & (CONTADOR < PSCONTADOR))) & (~E3)); //Ecuacion binaria correspondiente al estado2 E3 = ((E3 | (E2 & T1 )) & (~E4)); //Ecuacion binaria correspondiente al estado3 E4 = ((E4 | (E3 & T2)) & (~E1) & (~E2)); //Ecuacion binaria correspondiente al estado4
delay(200); // solo para ayuda de visualizacion // 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); }
18
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 } //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //SUBRUTINA TEMPORIZADOR 1 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void activetemp1() { if (E2 == HIGH && activado1 == 0) { activado1 = 1;
// Si ha pulsado HIGH y no ha sido activado=0 antes...
// 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) ) {
19
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) { activado2 = 1;
// Si ha pulsado HIGH y no ha sido activado=0 antes...
// 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; }
20
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Jovenes, este material ha sido elaborado con mucho gusto. Si te es util Rega lame un Like, comenta y suscríbete :) (っ◕‿◕) Te invito al CANAL DE YOUTUBE MEKATRONICA para conocer ma s
http://www.youtube.com/c/JovannyDuque?sub _confirmation=1_ Amigos/as en el BLOGG MEKATRONICA J DUKE podras encontrar cantidad de recursos sobre SOLIDWORKS, HIDRAULICA ELECTROHIDRAULICA , NEUMATICA, ELECTRONEUMATICA, CONTROL, PLC M221, PLC SIEMEMS S7 1200, PLC SIEMENS S7 300 , FLUID SIM FACTORY IO, entre otros
https://mecatronica-itsa.blogspot.com/ 21
