Universidad tecnológica de
coahUila
robótica
noe gómez
josUe efrain de la rosa
padilla
saberes Unidad 5
4mtfleXa
SABER 1 .- Identificar el entorno del software de programación
dedicado la I4.0.
SABER 2.- Describir el funcionamiento y estructura de las
subrutinas en la I4.0
Las subrutinas son secuencias de instrucciones que se invocan desde un programa para
ejecutar una tarea. Una vez completadas regresan el control al lugar de donde fueron llamadas
y pueden ser definidas por el programador o proporcionadas por el lenguaje de programación.
La diferencia principal entre una función y un procedimiento es que las funciones regresan un
valor como resultado de su ejecución mientras que los procedimientos no lo hacen. Ambos se
componen de un cuerpo donde se encuentran las instrucciones que se ejecutarán y de una
cabecera donde se especifica su nombre, sus parámetros y su tipo de retorno (si se trata de
una función). Su propósito principal es encapsular secciones de código que se puede utilizar
múltiples veces, reduciendo el tamaño de los programas, mejorando su legibilidad y facilitando
su mantenimiento. A la cabecera de las subrutinas así como a su cuerpo se les llama
«declaración» mientras que la instrucción en el programa principal usada para iniciar su
ejecución recibe el nombre de «invocación».
Declaración
La declaración de una función generalmente tiene la siguiente estructura:
[Tipo de datos del resultado] subrutina [nombre de la función] ( [lista de parámetros] )
[Instrucciones a ejecutar como parte del cuerpo de la función.]
regresar [Dato a regresar como resultado]
fin_subrutina
El tipo de datos del resultado es uno de los indicadores de los tipos de datos primitivos
soportados por el lenguaje de programación (entero, real, carácter, etc.), el nombre de
la subrutina es cualquier nombre válido según las reglas del lenguaje y la
palabra regresar al final de la subrutina sirve para especificar el dato que se debe
regresar como resultado de la función. El dato regresado debe ser del tipo especificado
en el tipo de retorno de la función o de lo contrario el compilador reportará un error.
La estructura de los procedimientos es igual a la estructura de las funciones. En su
declaración simplemente se omiten el tipo de datos del resultado y la
instrucción regresar al final del cuerpo de la subrutina.
subrutina [nombre del procedimiento] ( [lista de parámetros] )
[Instrucciones a ejecutar como parte del cuerpo del procedimiento.]
fin_subrutina
Parámetros
Para poder realizar las tareas deseadas, las subrutinas deben recibir
información del programa principal. Esa información se transfiere usando
parámetros. Estos consisten de una lista de 0 o más variables declaradas en la
cabecera, indicando el tipo de dato transferido y un nombre para poder
usarlo. Los elementos de la lista usualmente se separan con algún tipo de
indicador como la coma ( , ). Los parámetros se consideran variables locales
porque solo existen durante la ejecución del subprograma y solo el código en
el cuerpo de este puede hacer uso de ellos.
En el siguiente ejemplo se declara una función llamada área_triángulo que
recibe dos parámetros, la base y la altura de un triángulo y regresa un número
real con el área correspondiente:
// Función para calcular el área de un triángulo.
real subrutina área_triángulo (real base, real altura)
regresar (base * altura) / 2
fin_subrutina
Cuando un programa invoca una subrutina, normalmente le entrega copias de
los valores de los datos que le pasa en los parámetros. Esto significa que las
subrutinas pueden alterar los valores de los parámetros sin afectar los valores
en las variables usadas al invocarlos. Este concepto se llama «paso de
parámetros por valor» y es el método usado con mayor frecuencia al trabajar
con parámetros de tipos de datos primitivos. Otra forma de pasar parámetros
consiste en proporcionar un apuntador a la variable que contiene el dato en vez
de pasar una copia. En este caso el subprograma debe usar el apuntador para
llegar al dato y los cambios que le haga serán visibles al resto del programa.
Este método se conoce como «paso de parámetros por referencia» y se usa
frecuentemente para trabajar con tipos de datos estructurados.
Invocación
Una vez que una subrutina ha sido declarada, es posible usarla, ya sea en el
programa principal o dentro de otras subrutinas. Si la subrutina es una función,
se puede usar en cualquier lugar donde se puede usar una expresión del tipo
de datos del resultado de la función. Si es un procedimiento, se puede usar en
los lugares donde se pueden usar los otros tipos de instrucciones del lenguaje
de programación, ya que representan un salto en el orden de ejecución de las
instrucciones y el posterior regreso al punto de llamada.
Para invocar una subrutina se debe especificar su nombre y una lista de valores
para los parámetros. Los valores de los parámetros pueden ser constantes,
variables, expresiones o el resultado de la invocación de otras funciones.
Cuando se invoca la subrutina, el programa obtiene los valores de las variables,
calcula los valores de las expresiones o llama a las funciones indicadas y
obtiene su valor de retorno y asigna esos valores a las variables locales que
crea con los nombres especificados en los parámetros de la declaración de la
subrutina.
En el siguiente ejemplo se invoca a una función predefinida llamada ln que
recibe un número real como su parámetro y calcula su logaritmo natural. El
valor de retorno de la función se asigna a una variable.
real resultado
resultado := ln (300.0)
En este otro ejemplo, para calcular la hipotenusa de un triángulo rectángulo, se
invoca una función preexistente que recibe un número real y regresa la raíz
cuadrada de ese número. El número real proporcionado como parámetro es el
resultado de una expresión que regresa la suma de los cuadrados de los
catetos del triángulo.
real cateto_a := 3.0
real cateto_b := 4.0
real hipotenusa := raíz_cuadrada (cateto_a ** 2 + cateto_b ** 2)
Muchos lenguajes de programación no proporcionan operadores para calcular
potencias pero si proporcionan funciones predefinidas para realizar la
operación. En el siguiente ejemplo se realiza el mismo cálculo del ejemplo
anterior pero se usa una función para elevar los catetos al cuadrado. En este
caso el lenguaje de programación primero ejecuta la función potencia en dos
ocasiones diferentes para obtener los valores que regresa en cada caso y llama
a la función raíz_cuadrada con el resultado de la suma de ambos.
real cateto_a := 3.0
real cateto_b := 4.0
real hipotenusa := raíz_cuadrada ( potencia(cateto_a, 2) + potencia(cateto_b,
2) )
Variables locales
Generalmente el cuerpo de las subrutinas de un programa consiste de un
bloque de código del mismo tipo de los usados en las estructuras de control de
flujo. Esto permite ejecutar múltiples instrucciones en el cuerpo de la función y
declarar variables locales para almacenar información de trabajo y resultados
parciales antes de regresar el resultado al programa principal.
La función en el siguiente ejemplo calcula el área de un triángulo usando
la fórmula de Herón. Como esa fórmula debe usar un valor parcial llamado
«semiperímetro del triángulo» múltiples veces, se usa una variable local para
calcularlo una sola vez.
// Función para calcular el área de un
// triángulo usando la fórmula de Herón.
real subrutina área_triángulo (real lado_a, real lado_b, real lado_c)
// Variable local para almacenar el semiperímetro
real s
// Cálculo del semiperímetro
s := (lado_a + lado_b + lado_c) / 2
// Cálculo del área usando el semiperímetro
// y una función predefinida para calcular
// la raíz cuadrada.
regresar raíz_cuadrada ( s * (s - lado_a) * (s - lado_b) * (s - lado_c) )
fin_subrutina
Uso de variables globales
Además de los parámetros y las variables declaradas localmente, las
subrutinas pueden usar y modificar las variables globales de un programa. Las
variables globales le permite a múltiples subrutinas compartir información sin
tener que pasarla como parámetros. Los cambios que realizan las subrutinas a
los valores de las variables globales se llaman «efectos colaterales» y
normalmente se consideran una mala práctica de programación ya que
dificultan la compresión y mantenibilidad de los programas.
Bibliotecas de funciones
La mayoría de los ambientes de desarrollo proporciona mecanismos para
definir múltiples funciones en un archivo y luego cargar ese archivo en un
programa que usará las funciones. Estas colecciones frecuentemente se
llaman bibliotecas de subrutinas y los lenguajes de programación proporcionan
instrucciones especiales para incorporarlas en el programa principal. En el
siguiente ejemplo se incorpora una biblioteca de subrutinas
llamada áreas_polígonos.bib en el programa principal y luego se usa la
función área_hexágono_regular , definida dentro de esa biblioteca, para calcular
el área de una figura geométrica de ese tipo.
// Cargando biblioteca de funciones para usarlas en el programa.
cargar ("áreas_polígonos.bib")
real lado := 5.0
real apotema := 12.0
real área
área := área_hexágono_regular (lado, apotema)
Las subrutinas y su agrupación en bibliotecas son unos de los principales
mecanismos que proporcionan los lenguajes de programación para dividir los
programas grandes en unidades más manejables, llamadas módulos. Los
módulos le facilitan a los programadores el comprender y modificar los
programas así como comprobar que son correctos y funcionan como es
esperado. También se usan en los lenguajes de programación para
proporcionarle a los programadores un conjunto de funciones que realizan
tareas comunes como el cálculo de funciones matemáticas complejas o el
manejo de la entrada y salida de información.
SABER 3.- Describir el funcionamiento y sintaxis de los
comandos relacionados con entradas y salidas provenientes de
un PLC I4.0
Este módulo se ocupa exclusivamente de la CLI o interfaz de línea de comandos,
en lugar de la GUI o interfaz gráfica de usuario con la que quizás esté más
familiarizado. El terminal CLI es una poderosa herramienta y a menudo es el método
principal utilizado para administrar dispositivos pequeños de bajo consumo,
servidores de computación de gran capacidad en la nube, y mucho más. Una
comprensión básica del terminal es esencial para diagnosticar y reparar la mayoría
de los sistemas basados en Linux. Puesto que Linux se ha vuelto tan omnipresente,
incluso aquellos que planean trabajar con sistemas que no utilizan el núcleo Linux
pueden beneficiarse de tener una comprensión básica del terminal.
¿Qué es un comando? Un comando es un programa de software que, cuando se
ejecuta en la CLI (interfaz de línea de comandos), realiza una acción en el
ordenador. Cuando usted escribe un comando, el sistema operativo ejecuta un
proceso para leer su entrada, manipular datos y producir resultados. Un comando
ejecuta un proceso en el sistema operativo, que luego hace que el ordenador realice
una tarea determinada.
Para ejecutar un comando, el primer paso es escribir el nombre del comando. Haga
clic en el terminal de la derecha. Escriba ls (letras minúsculas) y pulse Enter.
Obtendrá un resultado parecido al del siguiente ejemplo:
cox:~# ls
bin dev home boot opt root srv var
Generalmente, el nombre del comando se basa en la tarea que hace o en lo que el
programador que creó el comando cree que mejor describe la función del comando.
Por ejemplo, el comando ls muestra una lista de información sobre archivos. Asociar
el nombre del comando con algo mnemotécnico sobre lo que hace puede ayudarle
a recordar los comandos más fácilmente.
A tener en cuenta
Generalmente, los comandos distinguen entre mayúsculas y minúsculas. Por
ejemplo LS es incorrecto y generará un mensaje de error, pero ls es correcto y se
ejecutará normalmente.
cox:~# LS
-bash: LS: command no found
La mayoría de los comandos siguen un patrón de sintaxis simple:
comando [opciones…] [argumentos…]
En otras palabras, escriba un comando, seguido de
las opciones y/o argumentos antes de presionar la tecla Enter. Generalmente, las
opciones (options) alteran el comportamiento del comando y los argumentos
(arguments) son elementos o valores sobre los que debe actuar el comando.
Aunque hay algunos comandos en Linux que no son completamente consistentes
con estas normas de sintaxis, la mayoría de los comandos usan esta sintaxis o
alguna similar.
En el ejemplo anterior, el comando ls se ejecutó sin opciones ni argumentos.
Cuando este es el caso, su comportamiento predeterminado es el de devolver una
lista de los archivos contenidos en el directorio actual.
cox:~# ls
bin dev home boot opt root srv var
Argumentos
comando [opciones…] [argumentos…]
Un argumento (argument) se puede usar para especificar algo sobre lo que el
comando debe actuar. Si al comando ls se le da el nombre de un directorio como
argumento, obtendremos como resultado una lista del contenido de ese directorio.
En el siguiente ejemplo, el directorio home se utilizará como argumento:
cox:~# ls home
El resultado es una lista de los archivos incluidos en el directorio home
Opciones
comando [opciones…] [argumentos…]
Las opciones (options) se pueden utilizar para modificar el comportamiento de un
comando. En la página anterior, el comando ls se utilizó para enumerar el contenido
de un directorio. En el ejemplo siguiente, la opción -l se agrega al comando ls para
obtener un resultado de “pantalla larga”, y proporcionar más información sobre cada
uno de los archivos enumerados:
cox:~# ls home -l
total 44
Que sucede...
Tenga en cuenta que, en el comando anterior, -l es la letra “L” minúscula.
A menudo, el carácter elegido para el comando es mnemotécnico de su propósito
en inglés. Por ejemplo, la letra l para indicar largo (long) o r para invertir (reverse en
inglés). De forma predeterminada, el comando ls imprime los resultados en orden
alfabético, al agregar la opción -r se imprimirán los resultados en orden alfabético
inverso.
cox:~# ls home -l -r
total 44
Que sucede...
Se pueden usar varias opciones a la vez, ya sea como opciones separadas como
en -l -r o combinadas como -lr . El resultado de los siguientes ejemplos sería el
mismo:
ls -l -r
ls -rl
ls -lr
Como se ha explicado anteriormente, -l proporciona un formato de listado largo y -
r invierte el listado. El resultado de usar ambas opciones será un listado largo en
orden alfabético inverso.
Ejecute y comente que sucede.
Los comandos pueden utilizar muchas combinaciones de opciones y argumentos.
Las posibilidades para cada comando serán únicas.
