Universidad Galileo
Licenciatura en Administración de Empresas con Énfasis en Telecomunicaciones
Catedrático Ing. Pablo González
LENGUAJE ARDUINO
Mario Arturo Alvarado Franco
07122022
Dia sábado sección S
Guatemala, 01 de agosto de 2022
Mi primer sketch Arduino
Arduino es una placa de computadora de código abierto que tiene mucho potencial en el campo de
la electrónica y la programación de computadoras. Es una placa de microcontrolador que se puede
conectar fácilmente a su computadora a través de una interfaz USB. Le permite construir varios
proyectos como juguetes RC, drones, robots, sistemas de seguridad para el hogar y mucho más.
Además, el hardware de Arduino consta de una unidad de microcontrolador (MCU), memoria
interna, entradas y salidas analógicas, temporizadores, interfaz Ethernet, etc. Cualquiera puede
hacer uso de las placas de Arduino escribiendo código para ellas usando un lenguaje especial
llamado "dialecto propio de Arduino". de código”.
Ejemplo:
Estructura general de un sketch
Programas ("bocetos") diseñados para ejecutarse en Arduino consta siempre de tres partes:
Sección de declaración de variables globales: directamente en el comienzo del boceto.
Sección denominada "configuración vacía ()" o “void setup()”: separada por llaves de apertura y
cierre.
Sección denominada "bucle vacío ()" o “void loop()”: separada por llaves de apertura y cierre.
La primera parte del boceto (sin ningún tipo de símbolos delimitador de inicio o final) reservado
para la escritura, como su nombre significa que necesitamos una declaración diferente de la
variable.
Dentro de las otras dos secciones (es decir, dentro de sus corchetes) tenemos que escribir en la
pizarra las instrucciones que queremos ejecutar, Considere los siguientes puntos:
Ejecute la instrucción escrita en la sección "void setup ()" solo una vez, al encender (o resetear) la
placa Arduino.
Se ejecuta la sentencia escrita en la sección "void loop()" justo después de esas infinitas veces en la
sección "void setup()", hasta que la placa se apaga (o se reinicia). es decir, el contenido de "void
loop()" se ejecuta desde la primera instrucción hasta la última, luego regresa a ejecutar desde la
primera instrucción hasta la última, luego ejecuta desde la primera instrucción hasta la última, y así
sucesivamente.
Mayúsculas, tabulaciones, puntos y comas
Es conveniente aclarar algunos pequeños detalles a tener en cuenta, es hora de escribir nuestros
bocetos para evitar muchos problemas. Por ejemplo, es necesario saber que el lenguaje Arduino es
"sensible a mayúsculas y minúsculas". En otras palabras, las letras mayúsculas y minúsculas son
completamente diferente en Arduino. "HoLa" y "hOLa" son dos palabras para el lenguaje Arduino
diferentes.
Esto tiene una implicación muy importante: está escrito de otra manera. Por ejemplo,
"Serial.begin(9600);" y "serial.begin(9600);". En el primer caso la instrucción se escribirá
correctamente, pero en el segundo esta escrito incorrectamente ya que el IDE se quejará al compilar
el código porque "serial" (con "s" minúscula) no es correcto. Así que hay que tener mucho cuidado
de respetar esa distinción.
Las tabulaciones por otro lado, simplemente son una forma de escribir código de forma ordenada,
clara y cómoda para el usuario programador, haciéndole más fácil leer el código ya escrito y
mantener cierta estructura al escribir.
Otra cosa a tener en cuenta es que todas las instrucciones (también declaraciones de variable)
termina con un punto y coma. Esta bandera siempre debe agregarse para que no haya errores de
compilación porque el compilador necesita ubicarlo para detectar el final de cada instrucción escrita
en el boceto. Si te olvidas, te mostrará el texto de error que puede o no ser obvio ("falta el punto y
coma").
Si el texto del error es muy vago o ilógico, lo mejor es comprobar si la causa es el punto y coma que
falta en la línea.
Variables
Una variable es un elemento en nuestro boceto que actúa como un elemento pequeño. El "pequeño
cajón" (identificado por el nombre que elegimos) contiene un cierto contenido. El contenido (el
llamado valor variable) se puede modificar en cualquier momento durante la ejecución del boceto:
de ahí el nombre “Variables". La importancia de las variables es enorme, como todos los bocetos.
Los utilizan para preservar el valor que necesitan para funcionar.
Declaración e inicialización de una variable
antes de que comencemos a usar cualquier variable en el boceto; no
Sin embargo, debemos crearlo primero. Crear una variable a menudo se denomina "declarar una
variable". En el lenguaje Arduino, cuando se declara una variable, también es fundamental
especificar su tipo. El tipo de variable se elige según el tipo de datos (entero, decimal, cadena, etc.)
que queremos almacenar en esa variable. Es decir: cada variable solo puede almacenar un
determinado tipo de valor, por lo que tenemos que decidir en su declaración qué tipo de variable
nos interesa más en función del tipo de datos que pretendemos almacenar.
Asignar un valor a una variable de un tipo diferente al esperado hace que el boceto falle.
asignación de valores a una variable
¿Qué sucede si se declara una variable pero no se inicializa? Tendrá un valor predeterminado
(normalmente no nos interesa) hasta que se le asigne un valor diferente en algún momento de la
ejecución de nuestro boceto. La sintaxis general para asignar un nuevo valor a una variable (porque
no se ha inicializado o específicamente porque desea sobrescribir el valor anterior con el nuevo
valor) es:
nombre de la variable = nuevo valor;
Ámbito de una variable
Otro concepto importante relacionado con las variables es el alcance de la variable. En este sentido,
las variables pueden ser "globales" o "locales". Que provenga de un ámbito u otro depende de
dónde declaremos la variable en el boceto.
Para una variable global, debe declararse al principio de nuestro boceto, es decir, entre "void
setup()" y "void loop()”. De hecho, al hablar de la estructura de un boceto, ya hemos mencionado la
existencia de esta declaración de variable global. Las variables globales son variables que se pueden
usar y manipular en cualquier parte del boceto. instrucciones, independientemente de donde estén
escritas ("void setup()", "void loop()" o cualquier otra que exista) pueden ser consultadas y
modificadas el valor de estas variables.
Para una variable local, debe declararse en una sección de nuestro boceto (es decir, dentro de "void
setup()" o "void loop()" o cualquier otra cosa que pueda haber allí). Una variable local es una variable
que solo se puede usar y manipular mediante instrucciones escritas en la misma sección en la que
se declara. Este tipo de variable es útil para bocetos largos y complejos para garantizar que solo una
parte tenga acceso a sus propias variables, ya que esto evita posibles errores si una parte modifica
inadvertidamente las variables utilizadas por otra.
Tipos posibles de una variable
Tipo "Booleano": Una variable de este tipo solo puede tener dos valores:
Cierto o falso, también pueden ser 1 o 0. Se utilizan para almacenar el estado entre estos dos estados
posibles, lo que permite que el boceto reaccione en función de si se detecta uno u otro en él.
boolean mivariable=true; o bien boolean mivariable=1
Tipo "char": El valor que puede tener una variable de este tipo es siempre un solo carácter (letras,
números, puntuación...). Si queremos almacenar una cadena de caracteres (es decir, palabras o
frases), el tipo "char" no nos funciona.
char mivariable='A';
Tipo "byte": Los valores que pueden tener las variables de este tipo son siempre números enteros
entre 0 y 255. Al igual que una variable de tipo "char", una variable de tipo "byte" utiliza un byte (8
bits) para almacenar su valor, por lo que el mismo número de combinaciones posibles de dígitos
diferentes (256), pero a diferencia de estas, una variable de "byte" no puede ser negativa.
Tipo "int": Las variables de este tipo pueden tener valores que sean enteros entre -32768 y 32767
gracias a que utilizan memoria de 2 bytes (16 bits) para ser almacenadas. Este es el caso de todas
las placas Arduino excepto la Due: en este modelo de placa, el tipo "int" utiliza 4 bytes, por lo que
su valor puede estar en un rango más amplio, especialmente en -2.147.483.648 y 2.147.483.647.
Tipo "word": Las variables de tipo "palabra" en la placa Arduino Due ocupan 4 bytes para almacenar
su valor. Por lo tanto, tienen el mismo número de diferentes combinaciones posibles de números
que la variable "int", pero a diferencia de estos, el valor de la variable "palabra" no puede ser
negativo. En las placas basadas en microcontrolador tipo AVR ocurre lo mismo: variables de tipo
"int" y "word" ocupan el mismo espacio de memoria (aunque en este caso son solo 2 bytes) pero el
valor de estas últimas no puede ser negativo. Es fácil ver que, en todas las placas, excepto Arduino
Due, la variable "palabra" puede tener valores que son números enteros entre 0 y 65535.
Tipo "short": El valor de esta variable de tipo es un número entero entre -32768 y 32767 para todos
los modelos de placa (ya sean microcontroladores tipo AVR--la mayoría-- o tipo ARM-Due--), porque
utilizan 2 bytes (16 bits) de memoria para almacenamiento. En este sentido, los tipos "corto" e "int"
para las placas de la serie AVR son equivalentes, pero para la placa Arduino Due, el tipo "corto" es
el único que utiliza 16 bits.
Tipo "long": las variables de este tipo pueden tener valores que son números enteros entre -
2147483648 y 2147483647 para todos los modelos de placa (ya sean microcontroladores basados
en AVR o ARM) porque utilizan memoria de 4 bytes (32 bits) para almacenar. En este sentido, los
tipos "largo" e "int" de placas base de la serie ARM son equivalentes.
tipo "unsigned long": un valor que una variable de este tipo puede tener para todos los modelos de
placa (basados en microcontrolador o no) tipo AVR o ARM) es un número entero entre 0 y
4,294,967,295. Al igual que las variables de tipo "largo", las variables de tipo "largo sin signo" usan
4 bytes (32 bits) para almacenar sus valores, y así tener el mismo número de diferentes
combinaciones posibles de números.
El tipo “float”: el valor que puede tener una variable de este tipo es un número decimal.
Tipo "Array": Este tipo de datos en realidad no existe. Lo que existe es una matriz de variables de
tipo "booleano", una matriz de variables de tipo "int" y una matriz de variables de tipo "flotante".
Los arreglos (también llamados "vectores") son colecciones de variables de un tipo específico, todas
las cuales tienen el mismo nombre único, pero se pueden distinguir entre sí por números de índice.
Las variables - por ejemplo, de tipo "char" - son cada una independiente de otras variables
(varChar1, varChar2, varChar3...) Podemos tener una matriz, agruparlas todas bajo el mismo
nombre (por ejemplo, varChar), esto permite Cada variable puede ser tratados individualmente,
porque cada variable en la matriz se identifica mediante un índice numérico, escrito entre corchetes
(varChar[0], varChar[1], varChar[2]...). Además de ser fáciles de programar, las matrices pueden
hacer que el código sea claro y simple.
Cambio de tipo de datos (numéricos)
Nunca puede cambiar el tipo de una variable: si se declara como un tipo específico, seguirá siendo
ese tipo durante todo el boceto. Pero lo que se puede hacer es cambiar "dinámicamente" el tipo del
valor en un momento específico Incluir. Esto se llama "casting" y se usa cuando desea usar el valor
en un cálculo que requiere un tipo diferente al tipo original, o cuando desea asignar el valor de una
variable de un tipo a una variable de otro tipo sería útil. diferentes tipos.
Constantes
Una variable se puede declarar de tal manera que su valor (no importa de qué tipo) sea siempre el
mismo. Es decir, su valor nunca se puede modificar porque está marcado como "solo lectura". De
hecho, por razones obvias, las variables de este tipo ya no se denominan "constantes", sino
"constantes". Las constantes se pueden usar como cualquier variable del mismo tipo, pero el
compilador arrojará un error si intenta cambiar su valor.
Para convertir una variable (global o local) en una constante, todo lo que tiene que hacer es usar la
palabra clave const antes de declarar la variable. Por ejemplo, para hacer que una variable llamada
"sensor" de tipo "byte" sea constante, simplemente declárela así: const byte sensor; .
Parámetros de una instrucción
Los parámetros se utilizan para modificar el comportamiento de la declaración de alguna manera.
Es decir: las instrucciones sin parámetros ejecutan una sola función (la tarea que asignan) y dicen:
no hay posibilidad de modificación, porque siempre hacen lo mismo de la misma manera. Por otro
lado, cuando una instrucción tiene uno o más parámetros, también realizará su función
preestablecida, pero la forma específica vendrá dada por el valor de cada uno de sus parámetros, lo
que modificará algunas características específicas de la instrucción para ser acción realizada.
Valor de retorno de una instrucción
Otro concepto fundamental relacionado con las instrucciones del lenguaje Arduino es el "valor de
retorno". Estas instrucciones, además de recibir argumentos de entrada (si los hay), normalmente
devuelven un valor de salida (o "retorno") además de realizar la tarea que tienen que hacer.
El valor de salida son los datos que podemos obtener en el boceto como resultado "tangible" de la
ejecución de la instrucción. El significado de este valor de retorno dependerá de cada instrucción
específica: algunos son controles (que indican si la instrucción se ha ejecutado correctamente), otros
son resultados numéricos obtenidos después de la ejecución algunos cálculos matemáticos, etc.
La comunicación serie con la placa Arduino
La placa Arduino tiene un receptor/transmisor serie tipo TTL-UART que permite que la placa Arduino
UNO se comunique con otros dispositivos (generalmente, nuestra computadora) para transferir
datos entre los dos. En estos casos, el canal de comunicación físico suele ser un cable USB, pero
también pueden ser los pines digitales 0 (RX) y 1 (TX) de la placa.
Debemos conectar específicamente el pin TX de la placa y el pin RX del dispositivo, el RX de la placa
y el TX del dispositivo, y compartir la tierra de la placa con la tierra del dispositivo. Tomar en cuenta
que si estos dos pines se usan para comunicaciones en serie, no se puede utilizar como
entrada/salida digital estándar.
Serial.begin(): Abre un canal serial para que la comunicación pueda comenzar sobre él. Por tanto,
su ejecución es imprescindible antes de cualquier transmisión por dicho canal. Es por eso que
generalmente se escribe en sección "void setup()". Además, a través de sus únicos parámetros, el
tipo "largo" y el parámetro obligatorio, especifica la velocidad (en bits/segundo) a la que se
producirá la transferencia de datos en serie. Para la comunicación con el ordenador se suele utilizar
un valor de 9600, pero se puede especificar cualquier otra velocidad. Lo que importa es el valor
escrito como parámetro.
Haga coincidir lo que se especifica en la lista desplegable que aparece en el monitor serie del IDE de
Arduino; de lo contrario, la comunicación no se sincronizará bien y mostrará símbolos sin sentido.
Esta instrucción no tiene valor de retorno.
Serial.end(), sin argumentos tampoco devuelve nada, y se encarga de cerrar el canal serie, de esta
forma se deshabilita la comunicación serie y los pines RX y TX vuelven a estar disponibles para
entrada/salida general. Para reabrir el canal serial nuevamente debe usar de nuevo Serial.begin().
Instrucciones para enviar datos desde la placa al exterior
Serial.print(): Envía datos (especificados como parámetro) desde el microcontrolador al exterior a
través del canal serie. Estos datos pueden ser de cualquier tipo: caracteres, cadenas, enteros,
números decimales (dos decimales por defecto), etc. Si los datos se especifican explícitamente (no
a través de variables), recuerde que los caracteres deben ser encerrados entre comillas simples y
las cadenas en comillas dobles.
Serial.println(): Igual que Serial.print(), pero también agrega automáticamente dos caracteres
adicionales al final de los datos enviados: retorno de carro (código ASCII 13) y avance de línea
(código ASCII 13. ASCII #10). El resultado está al final de la ejecución de Serial.println(). Realiza una
nueva línea. Tiene los mismos parámetros y valor de retorno que Serial.print().
Serial.write(): Envía datos (especificados como parámetro) desde el microcontrolador al exterior a
través del canal serial. Pero a diferencia de Serial.print(), los datos a enviar solo pueden ocupar un
byte. Entonces, básicamente tiene que ser del tipo "char" o "byte".
Instrucciones para recibir datos desde el exterior
Enviar datos a la placa desde el "Serial Monitor" es muy sencillo: todo lo que tienes que hacer es
escribir lo que quieras en el cuadro de texto que aparece y pulsar el botón "Enviar". Sin embargo, si
el boceto que se ejecuta en el tablero no está configurado para recibir y procesar estos datos, la
transmisión no irá a ninguna parte. Por lo tanto, necesitamos recibir convenientemente en el boceto
los datos que llegan a la placa a través de comunicación serie. Para ello contamos con dos
instrucciones básicas: Serial.disponible() y Serial.read().
Serial.available(): Devuelve el número de bytes (caracteres) que se pueden leer externamente a
través del canal serie (a través de USB o mediante los pines TX/RX).
Serial.read(): Devuelve el primer byte no leído almacenado en el búfer de entrada del chip TTL-
UART. Si lo hace, se eliminará de ese búfer. Para devolver (leer) el siguiente byte, se debe volver a
llamar a Serial.read(). y hazlo hasta que todo haya sido leído.
Serial.peek(): Devuelve el primer byte no leído almacenado en el búfer de entrada. Sin embargo, a
diferencia de Serial.read(), los bytes leídos no se eliminan del búfer, por lo que la próxima vez que
se ejecute Serial.peek(), o Serial.read() una vez, se volverán a leer los mismos bytes. Serial.peek()
devolverá -1 si no hay bytes para leer. Esta directiva no tiene parámetros.
Serial.find(): Leer datos del búfer de entrada (eliminar desde allí) hasta que se encuentre la cadena
(o un solo carácter) especificada como argumento, o hasta que se hayan leído todos los datos en el
búfer actual. La instrucción devuelve "verdadero" si se encuentra la cadena y "falso" en caso
contrario.
Serial.findUntil(): leer datos del búfer de entrada (eliminar desde allí) hasta que se encuentre una
cadena (o un solo carácter) especificado como el primer argumento, o alcanzando el marcador de
fin de búsqueda (es decir, la cadena o el carácter especificado como el segundo argumento). La
instrucción devuelve "verdadero" si la cadena de búsqueda se encuentra antes de la etiqueta final
de búsqueda y "falso" en caso contrario.
Serial.readBytes(): Leer del búfer de entrada (eliminarlos de allí) el número de bytes especificado
como segundo argumento (o, si no llegan suficientes bytes, hasta que haya pasado el tiempo
especificado por Serial.setTimeout(). En cualquier caso, los bytes leídos se almacenan en una matriz,
de tipo "char[]", se especifica como el primer parámetro. Esta instrucción devuelve el número de
bytes leídos del búfer (por lo que un valor 0 significa que no se encontraron datos válidos).
Serial.readBytesUntil(): Lee del búfer de entrada (los elimina de allí) el número de bytes
especificado como tercer argumento, o si busca antes de la cadena (o un solo carácter) especificado
como primer argumento de la etiqueta de cierre o, si no han llegado suficientes bytes y no se ha
encontrado el marcador final hasta que haya transcurrido el tiempo especificado por
Serial.setTimeout().
En cualquier caso, los bytes leídos se almacenarán en una matriz, de tipo "char[]", especificada como
segundo argumento. Este comando devuelve un número de bytes leídos del búfer (por lo que un
valor de 0 significa que no se encontraron datos válidos).
Serial.setTimeout(): tiene un parámetro (de tipo "largo") que establece el número máximo de
milisegundos para la instrucción Serial.readBytesUntil() y Serial.readBytes() esperarán a que los
datos lleguen al búfer de entrada en serie. Si ninguna de estas dos instrucciones recibe ningún dato
y transcurre este tiempo, el boceto continuará en la línea siguiente. El tiempo de espera
predeterminado es de 1000 milisegundos. Esta declaración generalmente se escribe en "void setup
()". No tiene valor de retorno.
Serial.parseFloat(): lee (elimina de allí) todos los datos del búfer de entrada hasta que se encuentra
un número decimal. Su valor de retorno, de tipo "largo", será el número decimal encontrado.
Cuando detecta el primer carácter inválido después de él, deja de leer (por lo que no continuará
eliminando datos del búfer). Esta directiva no tiene parámetros.
Serial.parseInt(): lee (elimina desde allí) todos los datos del búfer de entrada hasta que se encuentra
un número entero. Su valor de retorno, de tipo "largo", será el entero encontrado. Cuando detecta
el primer carácter inválido después de él, dejará de leer (por lo que no se eliminarán más datos del
búfer). Esta directiva no tiene parámetros.
Instrucciones de gestión del tiempo
millis(): Devuelve el número de milisegundos (ms) desde que la placa Arduino comenzó a ejecutar
el boceto actual. Este número se restablecerá a cero. Después de unos 50 días (cuando su valor
supera el máximo permitido por su tipo, es decir, "unsigned long"). No tiene parámetros.
micros(): Devuelve el número de microsegundos (µs) desde que la placa Arduino comenzó a ejecutar
el boceto actual. el número - de tipo "unsigned long" - se restablece a cero después de
aproximadamente 70 minutos. Esta instrucción tiene una resolución de 4 µs (es decir, el valor de
retorno es siempre un múltiplo de cuatro). Recuerda, 1000 µs es un milisegundo, por lo que 1000000
µs es un segundo. No tiene parámetros.
delay(): especifica el número de milisegundos para pausar el boceto como un parámetro de tipo
"unsigned long". No tiene valor de retorno.
delayMicroseconds(): especifica la cantidad de microsegundos para pausar el boceto como
parámetro, de tipo "unsigned long". Corrientemente, El valor máximo que se puede utilizar para la
precisión es 16383. Para esperas mayores que esta, se recomienda la instrucción delay(). El valor
mínimo que se puede utilizar con precisión es de 3 µs. No tiene valor de retorno.
Instrucciones matemáticas, trigonométricas y de pseudoaleatoriedad
abs(): Devuelve el valor absoluto del número pasado como parámetro (puede ser un número entero
o un decimal). Es decir, si el número es positivo (o 0), lo devuelve sin cambiar su valor; si es negativo,
devuelve "dar positivo". Por ejemplo, 3 es el valor absoluto de 3 y -3.
min(): Devuelve el mínimo de los dos números pasados en el parámetro (puede ser un número
entero y un decimal).
max(): Devuelve el mayor de los dos números pasados en el parámetro (puede ser un número
entero o un decimal).
Las funciones min() y max() se utilizan a menudo para limitar el valor mínimo o máximo que puede
tener una variable cuyo valor proviene de un sensor.
constrain(): recalcula el valor pasado como primer argumento (llamémoslo "x"), dependiendo de si
está dentro o fuera del rango separado por los valores pasados como segundo y tercer argumento
(los llamamos "a " y "b", donde "a" siempre debe ser menor que "b").
map(): modifica un valor - especificado como primer parámetro - que inicialmente está en un rango
(con su valor mínimo - el segundo parámetro - y su valor máximo - el tercer parámetro - separados),
para que esté en otro rango (otro mínimo -el cuarto parámetro- y otro máximo -el quinto
parámetro-), para que la transformación de los valores sea lo más proporcional posible. Esto es lo
que se llama un valor "mapeado": los valores mínimo y máximo para el rango cambian, por lo que
los valores intermedios se adaptan a ese cambio. Todos los argumentos son de tipo "largo", por lo
que también se permiten enteros negativos, pero no decimales: si aparecen en el cómputo interno
de una instrucción, se truncarán. El valor devuelto por esta instrucción es exactamente el valor del
mapa.
pow(): Devuelve el valor resultante de elevar el número pasado como primer argumento ("base")
al número pasado como segundo argumento ("exponente", que puede ser incluso una fracción).
sqrt(): Devuelve la raíz cuadrada del número pasado como parámetro (puede ser un número entero
o un decimal). El valor de retorno es de tipo "double".
sin(): Devuelve el seno del ángulo especificado como argumento en radianes. El tipo de este
parámetro es "flotante". Su retorno puede ser un valor Entre -1 y 1, de tipo "double".
cos(): Devuelve el coseno del ángulo especificado como argumento en radianes. El tipo de este
parámetro es "flotante". Su retorno puede ser un valor Entre -1 y 1, de tipo "double".
tan(): Devuelve la tangente del ángulo especificado como argumento en radianes. El tipo de este
parámetro es "flotante". Su valor de retorno puede ser un valor entre -∞ y ∞ y es de tipo "double".
randomSeed(): Inicializa el generador de números pseudoaleatorios. Normalmente se ejecuta en la
sección "setup()". La instrucción tiene un parámetro de tipo "int" o "long" llamado "seed" que indica
en qué valor comenzará la secuencia de números. La misma semilla produce la misma secuencia,
por lo que sería interesante usar diferentes valores de semilla en múltiples ejecuciones de
randomSeed() para aumentar la aleatoriedad.
random(): Una vez inicializado el generador de números pseudoaleatorios con randomSeed(), esta
instrucción devuelve un número pseudoaleatorio de tipo "largo" contenido entre el valor mínimo
(especificado como primer argumento – opcional –) y el valor máximo El valor del intervalo
(especificado como el segundo argumento) menos uno. Si no se especifica el primer parámetro, el
valor mínimo predeterminado es 0. El tipo de los dos parámetros puede ser cualquier tipo. siempre
y cuando esté completo.
Operadores aritméticos
➢ + Operador suma
➢ - Operador resta
➢ * Operador multiplicación
➢ / Operador división
➢ % Operador módulo
Instrucciones de gestión de cadenas
unacadena.length(): devuelve la longitud de “unacadena” (es decir, el número de caracteres). No
se cuenta el carácter nulo que marca los finales de cadena. No tiene parámetros.
unacadena.compareTo(): compara “unacadena” con otra que se pase como parámetro (bien de
forma literal, bien mediante un objeto String). Comparar significa detectar qué cadena se ordena
antes que la otra. Las cadenas se comparan desde su principio carácter a carácter utilizando el orden
de sus códigos ASCII.
Esto quiere decir, por ejemplo, que 'a' va antes que 'b' pero después que 'A', y las cifras van antes
de las letras. Su valor de retorno será un número negativo si “unacadena” va antes que la cadena
pasada como parámetro, 0 si las dos cadenas son iguales o un número positivo si “unacadena” va
después que la cadena pasada como parámetro.
unacadena.equals(): Compara si "astring" es igual a otra cadena, pasada como argumento. La
comparación distingue entre mayúsculas y minúsculas: esto significa que la cadena "hola" no es
igual a "HOLA". Esta instrucción es equivalente al operador "==" para objetos de cadena (veremos
este operador en un poquito). Su valor devuelto es "verdadero" si "una cadena" es igual a la cadena
especificada como argumento y "falso" en caso contrario.
unacadena.equalsIgnoreCase(): Compara si "astring" es igual a otra cadena, pasada como
parámetro. La comparación "no distingue entre mayúsculas y minúsculas": esto significa que la
cadena "hola" es igual a "HOLA". Su valor devuelto es "verdadero" si "una cadena" es igual a la
cadena especificada como argumento y "falso" en caso contrario.
unacadena.indexOf(): Devuelve la posición (entero) del principio del carácter o cadena en "astring"
como argumento. Devuelve -1 si no se encuentra mirar las posiciones se numeran desde 0. De forma
predeterminada, la búsqueda comienza al principio de "unastring", pero con el segundo parámetro
opcional puede indicar dónde comenzar la búsqueda. De esta manera, esta instrucción puede
encontrar paso a paso todas las cadenas buscadas existentes.
unacadena.lastIndexOf(): Devuelve la posición en "cadena" donde se encontró el carácter o el
comienzo de la cadena (entero) especificado como un parámetro. Devuelve -1 si no se encuentra.
Tenga en cuenta que las posiciones están numeradas desde 0.
Por defecto, busca comienza hacia atrás desde el final de "unstring", pero con el segundo parámetro
opcional puede indicar dónde comenzar la búsqueda (siempre hacia atrás). De esta manera, este
comando puede paso a paso para encontrar todas las ocurrencias de si la cadena buscada existe.
unacadena.charAt(): Devuelve el carácter cuya posición (datos enteros) se ha especificado como
argumento. Las posiciones se numeran desde 0.
unacadena.substring(): Devuelve la subcadena en "astring" entre la posición inicial (especificada
como el primer argumento) y la posición final (especificada como el segundo argumento opcional).
La posición inicial indicada es inclusiva (es decir, el carácter que ocupa esa posición está incluido en
la subcadena), pero la posición final, opcional, no es inclusiva (es
Es decir, el carácter que ocupa esa posición es el primer carácter no incluido en la subcadena). Si no
se especifica tal posición final, la subcadena continúa hasta el final de "una cadena". Tenga en
cuenta que las posiciones están numeradas desde 0.
unacadena.replace(): reemplaza una subcadena existente en "astring" (especificada como primer
argumento) con otra (especificada como primer argumento como el segundo), cada ocurrencia.
También se utiliza para reemplazar caracteres individuales. El reemplazo se realiza en "astring",
sobrescribe su valor original.
unacadena.toLowerCase(): Convierte todos los caracteres de "astring" a minúsculas. La conversión
se realiza sobre "astring", sobrescribiendo su valor original.
astring.toUpperCase(): Convierte todos los caracteres en "astring" a mayúsculas. La conversión se
realiza sobre "astring", sobrescribiendo su valor original.
astring.trim(): elimina todos los espacios y tabulaciones iniciales y finales de "astring". La conversión
se realiza sobre "astring", sobrescribiendo su valor original.
astring.concat() : Agregue ("concatenar") al final de la cadena "astring" otra cadena, pasada como
argumento. Como resultado, obtendremos un nuevo valor en "una cadena": su valor original
seguido del valor pasado por el argumento, la unión. Es equivalente al operador "+" para objetos de
cadena.
unacadena.endsWith(): Comprueba si "unastring" termina con un carácter de otra cadena, pasado
como parámetro. si su valor devuelto es "verdadero" ,"una cadena" termina la cadena especificada
como un argumento; de lo contrario, "falso".
unacadena.startsWith() : Comprueba si "astring" comienza con un carácter de otra cadena, pasado
como argumento. si su valor devuelto es "verdadero" "una cadena" comienza con la cadena
especificada como argumento; de lo contrario, "falso".
unacadena.toCharArray(): Copia el número dado de caracteres pertenecientes a "unacadena" en
una matriz de tipo "char". La matriz se debe especificar como primer argumento y el número de
caracteres que se copiarán se debe especificar como segundo argumento. -- tipo "palabra" --.
Siempre obtiene caracteres desde el principio de "astring". No tiene un valor de retorno.
unacadena.getBytes(): Copia el número dado de caracteres pertenecientes a "unastring" en una
matriz de tipo "byte". La matriz se debe especificar como primer argumento y el número de
caracteres que se copiarán se debe especificar como segundo argumento. -- tipo "palabra" -- .
siempre obtener caracteres desde el principio de "astring". No tiene valor de retorno.
unacadena.toInt(): si "unastring" tiene valores que comienzan con un número, esta directiva es
capaz de distinguirlos (descartando posibles caracteres no numéricos subsiguientes) y devuelve un
valor numérico convertido a un tipo de datos entero. Es decir, convierte la cadena en un número
entero, si es posible. Esta directiva no tiene parámetros.
CREACIÓN DE INSTRUCCIONES (FUNCIONES) PROPIAS
En resumen, incluir fragmentos de código en las funciones tiene varias ventajas: las funciones
ayudan a organizar a los programadores (lo que a menudo ayuda a conceptualizar los programas),
codifican una acción en un solo lugar, por lo que una función solo debe pensarse y escribirse una
vez (esto también reduce la posibilidad de errores en modificaciones si hay que cambiar el código)
y Facilitan la reutilización de código en otros programas (haciéndolos más pequeños, más modulares
y más legibles).
"returnType" es uno de los tipos conocidos ("byte", "int", "float", etc.).
"type param1, type param2,..." son declaraciones de parámetros de funciones, nada más que
internas, y su existencia solo persiste variables mientras su código se está ejecutando.
Bloques "if" y "if/else"
El bloque "if" se usa para probar si una condición dada es verdadera ("verdadera", 1) o falsa ("falsa",
0). Si la condición es verdadera, se ejecutará la instrucción escrita en ella (es decir, dentro de las
llaves de apertura y cierre). Si no se cumple, no pasa nada, o bien, si hay un bloque "else" (opcional)
después del bloque "if", se ejecutarán las instrucciones escritas en el bloque "else". Es decir, si solo
escribimos el bloque "if", el boceto solo tendrá cuando se cumple la condición; pero si además
escribimos un bloque "else", el sketch dará la respuesta cuando se cumple la condición y cuando
no. En general, la sintaxis de un bloque "if/else"
BLOQUES REPETITIVOS (BUCLES)
bloque "mientras" es un bloque "while" es un bloque que implementa un bucle; es decir, ejecuta
repetidamente las instrucciones dentro de sus llaves de apertura y cierre.
Un ciclo "do" funciona exactamente como un ciclo "while", excepto que la condición se evalúa
después de ejecutar la instrucción. Escríbelo entre corchetes. Esto hace que la instrucción siempre
se ejecute al menos una vez, incluso si la condición es falsa, ya que la instrucción ya se ha leído antes
de la verificación (a diferencia del bucle "while", que si la condición de entrada ya es falsa, la
instrucción nunca se ejecutará).
La diferencia entre un bucle "while" (o "do") y un bucle "for" es que el número de iteraciones que
realiza el primero depende del estado que define la condición, pero en un bucle "for", el número de
las iteraciones se pueden establecer en un valor exacto. Por lo tanto, usaremos un bucle "for" para
ejecutar un conjunto de declaraciones (escritas entre llaves) un número específico de veces.
Bibliografía
https://drive.google.com/file/d/19CtiYaLspeq8Y9R4QsaLWIefqVlvF5mT/view?usp=sharing
Capítulo 4
