programación de arduino uno r3 arduino, arduino ladder, arduino uno r3 arduino 1 arduino tutorial, como programar arduino, proyectos arduino, arduino ladder, programación de arduino, arduino project, arduino uno arduino tutorial, como programar arduino, proyectos arduino, arduino plc, introdución a arduino, arduino desde cero,

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. Metodología Desarrollada por Ing. Jovanny Duque et al pág. 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
𝐸(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
//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);
S4 = digitalRead(10);
//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
{
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);
}
}
ESTRUCTURA
ALTERNATIVA
𝐸(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
//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

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

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
𝐸(12) = [(𝐸(12) + (𝐸18 ∗ 𝐸19 ∗ 𝑆0)) ∗ 𝐸
̅14 ∗ 𝐸
̅15]
𝐸(14) = [(𝐸(14) + (𝐸(12) ∗ 𝑆11)) ∗ 𝐸
̅16]
𝐸(15) = [(𝐸(15) + (𝐸(12) ∗ 𝑆11)) ∗ 𝐸
̅17]
𝐸(16) = [(𝐸(16) + (𝐸(14) ∗ 𝑆3)) ∗ 𝐸
̅18]
𝐸(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
//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;
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

6. Metodología Desarrollada por Ing. Jovanny Duque et al pág. 6
// 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
REPETITIVA
USO DE CONTADOR ACTIVADO POR UNA ETAPA
//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.
digitalWrite(Y2, LOW);

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() {
//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
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//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;
}
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
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 Specifications 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. Metodología Desarrollada por Ing. Jovanny Duque et al pág. 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
https://mecatronica-
itsa.blogspot.com/