Primeros pasos en el uso de PLC Arduino
Empieze siguiendo estas guías rápidas
Sabrá cómo instalar las boards y comprenderá por qué esto es tan importante, también las opciones de switch y cierta información básica e importante para comenzar a usar los PLC Industrales basados en Arduino.
Programación
Primeros pasos sobre cómo instalar las placas y comenzar a programar el PLC industrial basado en Arduino
Configuración
Comprender las opciones de conmutación, la señal LED, etc.
Instalación
Verifique los puntos importantes para la instalación correcta y las necesidades de suministro de energía correctas del PLC
Eche un vistazo a nuestro "How to's" básico para comenzar a usar el PLC evitando las incidencias más comunes.
Instalación de las boards de Industrial Shields en Arduino IDE.
Requerimientos
Arduino and ESP32 based PLC's
|
|
|
Descripción
El uso de las boards de Industrial Shields es muy importante ya que proporcionan muchas herramientas útiles que simplifican la programación del PLC. Los puntos más importantes son 2:
-
Definición automática / asociación de variables / pinmode de un pin.
-
Boards automáticas de Industriales Shields (características del PLC).
La idea básica de las boards de Industrial Shields es que se trata de una "colección de bibliotecas" que se incluyen en el software Arduino IDE, solo si están seleccionadas (cuando no se selecciona una board de Arduino).
La definición automática / asociación variable / pinmode de un pin ayuda en la gestión del pinout. Nuestros pines (QX.X / IX.X / AX.X / RX.X) están referenciados a un pin de Arduino real. Dependiendo del modelo y del equipo, estos pins pueden ser diferentes. Si el sketch no se realiza con las boards no podrá expandirse para futuras versiones y para otros modelos / equipos.
La única condición para usar los pines de Industrial Shields es (una vez que ya haya seleccionado las boards, la familia y el modelo de Industrial Shields) utilizando una nomenclatura cerrada. Se debe cambiar el "." por el "_". Entonces, si desea usar el Q0.1, solo necesita colocarlo en el sketch como Q0_1.
Con el fin de poder programar nuestro equipo aún más fácilmente, es posible instalarlo en Arduino IDE. Una vez instalada, no será necesario saber qué placa Arduino incluye cada equipo, ni consultar la asignación entre los pines de la placa Arduino y las entradas y salidas de los PLC, ni siquiera será necesario utilizar nuestras bibliotecas: ahora toda esta información estará incluida en Arduino IDE. Cuando seleccione uno de nuestros PLC, los IN y los OUT ya estarán disponibles con sus nombres, además como bibliotecas que facilitarán el uso de diferentes puertos de comunicación (RS-232, RS-485, ...).
Los pasos a seguir para instalar nuestros equipos en Arduino IDE son:
1- Abra el Arduino IDE, versión 1.8.0 o superior. Si aún no lo tiene, puedes descargarlo aquí. https://www.arduino.cc/en/Main/Software .
2- Presione la opción "Preferencias" del menú "Archivo" y abra la ventana de preferencias.
3- En el cuadro de texto "Additional boards manager URLs", agregue la dirección:
http://apps.industrialshields.com/main/arduino/boards/package_industrialshields_index.json
4- Cierre la ventana de preferencias con el botón "Ok".
5- Haga clic en el menú “Herramientas”, abra el submenú “Boards” y haga clic en la opción “Administrador de boards” para abrir la ventana correspondiente.
6- Busque “industrialshields” en el filtro de búsqueda y seleccione la lista y haga clic en “Instalar”.
7- Cerrar el "Administrador de boards".
Una vez que haya realizado esos pasos, estará disponible para seleccionar cada PLC que desee trabajar en "Herramientas"> "Boards": ARDBOX, M-DUINO, ...
Ejemplos de uso
Una vez que las boards de Industrial Shields están instaladas en su Arduino IDE, puede encontrar diferentes ejemplos de uso para su controlador basado en Arduino.
Puede encontraro en:
“File” > “Examples” > "MDuino Family Examples
También es importante destacar que ahora no es necesario sobrescribir el w5100.h de la biblioteca de Ethernet para la familia M-DUINO.
See how to do it step by step in this video:
Cómo utilizar el mapeo de pines de las board de Industrial Shields
Antes de usar estos pines, es necesario descargar e instalar las boards de Industrial Shields. Si tiene algún problema, puede comenzar en la parte superior de la página.
Estas boards le proveen el mapeo de Industrial Shields PLC . ¿Cómo funciona?
Por ejemplo, con estas boards no es necesario averiguar qué pin Arduino pertenece al PLC Industrial Shields. Simplemente utilizando directamente este pin PLC, Arduino IDE organizará la asignación para usted. Para hacer referencia a los pins de Industrial Shields, debe escribirse así:
Digital Outputs: QX_X
Analog Outputs: AX_X
Relay Output: RX_X
Inputs (regardless if it’s analog or digital): IX_X
Next it is showed a sketch example:
// In this case is selected the M-DUINO 57R+ board (IS.MDuino.57R+),
//but the way to use the GPIOs is the same for every Industrial Shields PLC
void setup() { } //////////////////////////////////////////////////////////////////////////////////////// void loop() { // Toggle pins once a second (I = Input Pins, Q = Digital Outputs, A = Analog Outputs & R = Relay Outputs) digitalRead(I0_0);//Reading a Digital Input
analogRead(I0_8);//Reading an Analog Input
digitalWrite(Q0_0, HIGH);//Writing a HIGH on a Digital Output digitalWrite(Q0_1, HIGH);//Writing a HIGH on a Digital Output //... analogWrite(A0_0, 188);//Writing on an Analog Output analogWrite(A0_1, 255);//Writing on an Analog Output //... digitalWrite(R0_0, HIGH);//Writing a HIGH on a Relay Output digitalWrite(R0_1, HIGH);//Writing a HIGH on a Relay Output //... delay(1000); digitalWrite(Q0_0, LOW);//Writing a LOW on a Digital Output digitalWrite(Q0_1, LOW);//Writing a LOW on a Digital Output //... digitalWrite(R0_0, LOW);//Writing a LOW on a relay Output digitalWrite(R0_1, LOW);//Writing a LOW on a relay Output //... delay(1000); }
Cliente TCP en Automatismo basado en Arduino
Introducción
Lea cómo conectarse a un servidor TCP desde un PLC basado en Arduino. Para seguir adelante solo necesita un PLC M-Duino con conexión Ethernet y un servidor TCP disponible .
Requerimientos
Ethernet PLC >>
Industrial Shields boards >>
Descripción
Antes de comenzar con esta publicación, eche un vistazo a este ejemplo. Consiste en implementar un TCP Server en Raspberry Pi 3 con Node.JS >>
Una vez que el servidor se está ejecutando, M-Duino puede conectarse al servidor. En este ejemplo, se usa un M-Duino para conectarse con el servidor Node.js llamado server.js, el mismo que se usó en el enlace de ejemplo anterior.
Para configurar el M-Duino, esta publicación simplemente sigue el ejemplo de TCP del sitio web de Arduino con algunos cambios. Para poder conectarnos al servidor, debemos conocer la IP del servidor TCP y el puerto donde este servidor está escuchando.
Ejemplo
A continuación se muestra el código Arduino:
#include <Ethernet.h>
#include <SPI.h>
byte mac[] = { 0xBE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 1, 100 };
byte server[] = { 192, 168, 1, 105 }; // Touchberry Pi Server
int tcp_port = 5566;
EthernetClient client;
void setup()
{
Ethernet.begin(mac, ip);
Serial.begin(9600);
delay(1000);
Serial.println("Connecting...");
if (client.connect(server, tcp_port)) { // Connection to server.js
Serial.println("Connected to server.js");
client.println();
} else {
Serial.println("connection failed");
}
}
void loop()
{
if (client.available()) {
if(Serial.available()){
char s = Serial.read();
client.write(s); // Send what is reed on serial monitor
char c = client.read();
Serial.print(c); // Print on serial monitor the data from server
}
}
if (!client.connected()) {
Serial.println();
Serial.println("disconnecting.");
client.stop();
for(;;)
;
}
}
Para más información vea en el sitio web de Arduino las funciones TCP. Ethernet / Ethernet 2 library
Una vez que el sketch se está ejecutando en el M-Duino, a través del monitor en serie es posible enviar datos al servidor y estos datos se contestan e imprimen también en el monitor en serie. En este ejemplo se escribe "Hello server.js" en el monitor serie. A continuación se muestran dos capturas de pantalla con la respuesta de esta operación, una de server.js en la Raspberry y la segunda del monitor serie M-Duino:
