Como puedo recibir un registro en el plc cuando el programa está en el robot en modo run pero no tiene ninguna orden de trabajo.
Existen acciones de programa en instalación - config E/S que permiten asociar estas salidas con acciones como:
Bajo cuando no está funcionando
alto cuando no está funcionando
Bajo en parada no programada
etc…
Pero estas no funcionan cuando el programa está esperando que le mandemos una orden de trabajo
Se puede apuntar a un línea de programa del código? El programa cuando está en espera se queda en la línea Sinc() hasta que recibe una orden, si pudiera monitorizar esa línea sabría que el programa esta en espera con lo cual el robot está esperando una orden, lo que es lo mismo no esta busy. Como idea
Alguna sugerencia
Gracias equipo
¿Seguro que no puedes usar ninguna de estas opciones?
Las dos primeras son de cuando un programa se está ejecutando (‘running’) en el robot.
¿A qué te refieres concretamente con “recibir una orden de trabajo”? Intuyo que es un programa en ejecución con varias opciones o tareas a ejecutar, ¿y que el robot está esperando del PLC que envíe una señal?
Yo lo haría a través de 2 registros en MODBUS o PROFINET, donde el PLC escribe el nº de trabajo y el robot usa otro registro para indicar que está ocupado, algo tipo:
·# Programa del Robot
Wait for PLC_trabajo != 0
Trabajo_activo = 1 # ahora el robot pasa a estar ocupado
Switch PLC_trabajo:
case 1: realizar_tarea_1()
case 2: realizar_tarea_2()
case 3: realizar_tarea_3()
end
Trabajo_activo = 0 # ahora el robot pasa a estar a la espera
Y en el lado del PLC (sé que los PLCs no tienen C/C++, pero para que te hagas una idea):
// variables
unsigned int PLC_trabajo_address = 200;
unsigned int Trabajo_activo_address= 201;
// esperar a que el robot esté disponible
boolean Trabajo_activo = false;
do {
Trabajo_activo = read_modbus_register(Trabajo_activo_address) == 1;
} while (Trabajo_activo);
// mandar un trabajo a realizar y esperar a que lo empiece
unsigned int = nr_tarea = 1;
do {
write_modbus_register(PLC_trabajo_address , nr_tarea);
Trabajo_activo = read_modbus_register(Trabajo_activo_address) == 1;
} while (!Trabajo_activo);
// cuando empiece a realizar, volver a poner la tarea a 0
nr_tarea = 0;
write_modbus_register(PLC_trabajo_address , nr_tarea);
Espero que mi solución te sirva. Pero si lo he entendido correctamente, en general creo que este concepto no es bueno a largo plazo, y por los siguientes motivos:
- Tienes 1 solo programa para todo. Cada vez que tengas que modificar / actualizar algo tienes que revisar todo el programa entero.
- Si quieres reusar algunas tareas en otro robot, tendrías que instalar en ese otro robot TODAS las URCaps y complementos extras porque si te falta algo de 1 sola tarea, el programa no compila y no lo puedes ejecutar.
- Cada vez que reusas tareas en otro robot que ya tiene otras tareas aparte, tendrías que revisar que ninguno de los números de los trabajos/tareas no se repitan.
- En este foro ha habido notificaciones de otros usuarios con programas demasiado largos que el controlador no puede manejar y los programas terminan en “crash” y sin poder recuperarlos.
- Lo que yo haría sería varios programas pequeños, 1 para cada trabajo, y en vez de mandar un nr de trabajo, usar el Dashboard Server con el comand “load x_program” y “Play” para ejecutarlo. Algunos PLCs, como los de Siemens, vienen ya con librerías para mandar mensajes por TCP y hay varios ejemplos en este foro usando estas librerías para usar el Dashboard Server con este fin.
Buenos días, gracias por la respuesta
Lo primero que probé fue esto
Y no reaccionaba cuando el robot está esperando una trabajo ya que el programa si que está running pero no tiene ninguna orden de trabajo con lo cual no cambia, ese fue mi razonamiento.
Esta idea esta bien, pero la tendría que escribir más de 100 veces, pensé que igual existe alguna función más directa.
Trabajo_activo = 1 # ahora el robot pasa a estar ocupado
Switch PLC_trabajo:
case 1: realizar_tarea_1()
case 2: realizar_tarea_2()
case 3: realizar_tarea_3()
end
Trabajo_activo = 0 # ahora el robot pasa a estar a la espera
El planteamiento inicial del programa para el robot es que haga trayectorias según el número de trabajo que recibe del PLC, es cierto que será bastante largo el programa, no se si tanto como para que no lo pueda procesar. Hay algún dato del límite de código para el procesador del robot, teniendo como mínimo un thread.
Tendré que investigar lo que me comentas sobre dashboard server.
Muchas Gracias
Sí, hay un límite de memoria que puede tener un programa. No recuerdo cuánto era, pero sé que alguien de UR lo mencionó en otro post.
Si lo que quieres es generar una trayectoria, una alternativa al switch tan largo sería:
# inicio del programa
def generar_trayectoria(nr_puntos):
i_punto = 0
trayectoria = []
while (i_punto < nr_puntos):
punto_trayectoria = [inserte_aqui_el_punto_deseado]
# acumular punto en trayectoria
trayectoria = [trayectoria; punto_trayectoria]
i_punto = i_punto + 1
end
return trayectoria
end
# Programa del Robot
global MAX_TRABAJO = 255
global MIN_TRABAJO = 1
global estado = ""
estado = "EN ESPERA"
Wait for PLC_trabajo != 0
Trabajo_activo = 1 # ahora el robot pasa a estar ocupado
if (PLC_trabajo<=MAX_TRABAJO) and (PLC_trabajo>=MIN_TRABAJO):
estado = "EN PROCESO"
generar_trayectoria(PLC_trabajo)
# hacer algo aquí con la trayectoria
else:
estado = "NR TRABAJO NO VALIDO"
sleep(10)
end
Trabajo_activo = 0 # ahora el robot pasa a estar a la espera
No estoy segura de que haya escrito la sintaxis de la función bien, especialmente en la parte en la que se acumulan los puntos. Nunca he escrito una acumulación de puntos en URScript, simplemente me he basado en cómo se hace en Matlab. Si te da error, prueba a acumular los puntos en una variable tipo lista como se hace en Python.