Arduino

8. Strings
 Character Analysis: Use the operators to recognise the type of character we are dealing with.
 String Addition Operator: Add strings together in a variety of ways.
 String Append Operator: Use the += operator and the concat() method to append things to
Strings.
 String Case Changes: Change the case of a string.
 String Characters: Get/set the value of a specific character in a string.
 String Comparison Operators: Compare strings alphabetically.
 String Constructors: Initialize string objects.
 String Index Of: Look for the first/last instance of a character in a string.
 String Length & String Length Trim: Get and trim the length of a string.
 String Replace: Replace individual characters in a string.
 String Start With Ends With: Check which characters/substrings a given string starts or ends
with.
 String Substring: Look for "phrases" within a given string.
 String To Int: Allows you to convert a String to an integer number.

Ing. Ronald N. Kopp Pá gina 1

 Arduino
46. Character Analysis: Análisis de Cadena de caracteres

En este ejemplo se utilizan los operadores que nos permiten reconocer el tipo de carácter que
usamos. Es útil para comprobar si un carácter es ASCII, o es mayúscula, o numérico, o se trata de una
marca de puntuación y así sucesivamente. Las opciones disponibles abarcan una variedad de
situaciones y esto se demuestra en el siguiente esquema. Cada carácter enviado a la placa a través
del monitor serial, del software de Arduino (IDE), es analizada por el boceto que devuelve toda la
información que pudo encontrar. Un solo carácter puede disparar más de una condición y por lo
tanto se puede obtener varias respuestas para una sola entrada.

Los operadores disponibles son:

 isAlphaNumeric()
es alfanumérico
 isAlpha()
es alfabética
 isAscii()
es ASCII
 isWhitespace()
es un espacio en blanco
 isControl()
es un carácter de control
 isDigit()
es un dígito numérico
 isGraph()
es un carácter imprimible que no es un espacio en blanco
 isLowerCase()
es minúscula
 isPrintable()
es imprimible
 isPunct()
es puntuación
 isSpace()
es un carácter de espacio
 isUpperCase()
es mayúscula
 isHexadecimalDigit()
es un hexadecimal digital válido (Por ej. 0 - 9, a - F, or A - F)

Hardware Required
 Arduino or Genuino Board

Ing. Ronald N. Kopp Pá gina 2

Arduino
Circuit

No hay ningún circuito para este ejemplo, aunque la placa debe estar conectada a nuestro ordenador
a través del USB y la ventana del monitor serial del software de Arduino, debe estar abierta.

Ing. Ronald N. Kopp Pá gina 3

Arduino
Código
Abrimos la ventana del monitor serial del software de Arduino (IDE) y tipiamos un solo carácter a la
vez, a continuación, pulsamos Enviar para obtener un informe sobre ese carácter.

void setup() {
  // abrimos las comunicaciones seriales y esperar a que el puerto se abra:
Serial.begin(9600);
while (!Serial) {
; // esperamos para que le puerto serial esté conectado.
}

// enviamos una introducción:

Serial.println("ENVIAME CUALQUIER BYTES Y TE DIRE TODO LO QUE PUEDA SOBRE EL ");
Serial.println();
}

void loop() {
// obtenemos cualquier bytes entrante:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// decir que es lo que fue enviado:

Serial.print("USTED ME ENVIO: \'");
Serial.write(thisChar);
Serial.print("\' valor ASCII: ");
Serial.println(thisChar);

// analizamos que es lo que fue enviado:

if (isAlphaNumeric(thisChar)) {
Serial.println("it's alphanumeric");
}
if (isAlpha(thisChar)) {
Serial.println("it's alphabetic");
}
if (isAscii(thisChar)) {
Serial.println("it's ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("it's whitespace");
}
if (isControl(thisChar)) {
Serial.println("it's a control character");

Ing. Ronald N. Kopp Pá gina 4

Arduino

}
if (isDigit(thisChar)) {
Serial.println("it's a numeric digit");
}
if (isGraph(thisChar)) {
Serial.println("it's a printable character that's not whitespace");
}
if (isLowerCase(thisChar)) {
Serial.println("it's lower case");
}
if (isPrintable(thisChar)) {
Serial.println("it's printable");
}
if (isPunct(thisChar)) {
Serial.println("it's punctuation");
}
if (isSpace(thisChar)) {
Serial.println("it's a space character");
}
if (isUpperCase(thisChar)) {
Serial.println("it's upper case");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("it's a valid hexadecimaldigit (i.e. 0 - 9, a - F, or A - F)");
}

// añadimos un poco de espacio y pedimos otro byte:

Serial.println();
Serial.println("DAME OTRO BYTE:");
Serial.println();
}
}

Ing. Ronald N. Kopp Pá gina 5

Arduino

Ing. Ronald N. Kopp Pá gina 6

Arduino
47. String Addition Operator: Operador de adición de cadenas

Podemos agregar Strings (cadenas) a través de una variedad de formas. A esto se

llama concatenación y el resultado es que el string sea más largo que el string original por la longitud
de la matriz de caracteres o de cadena de caracteres con la que concatena ella. El + operador le
permite combinar una cadena con otra cadena, con una constante de matriz de caracteres, una
representación ASCII de un número constante o variable, o un carácter constante.

Pantallas de LED a menudo se empaquetan como matrices de LEDs dispuestos en filas de ánodos

comunes y columnas de cátodos comunes, o al revés. He aquí un ejemplo típico , y su esquema:

Ing. Ronald N. Kopp Pá gina 7

Arduino
Estas pantallas pueden ser muy útiles. Para controlar una matriz, se conectan tanto sus filas y sus
columnas a un microcontrolador. Las columnas están conectados a los cátodos de los LEDs (véase la
figura 1), por lo que una columna tiene que tener un LOW para encender los LEDs de esa
columna. Las filas están conectados a los ánodos LEDs, por lo que la fila tiene que tener un HIGH para
encender los LEDs de esa fila. Si la fila y la columna son HIGH o LOW al mismo tiempo, no hay
diferencia de tensión a través del LED por lo que no se enciende.

Para controlar un LED individual, ajustamos su columna en LOW y su fila en HIGH. Para controlar
múltiples LEDs en una fila, ajustamos la fila en HIGH, y luego ponemos las columnas en LOW para
encenderlos, si quisiéramos apagarlos, ajustaríamos las columnas a HIGH.

Aunque existen matrices de LED pre-hechos, también podemos hacer nuestra propia matriz de
64 LEDs , utilizando el esquema que se muestra arriba.

No importa qué pines del microcontrolador se conectan a las filas y columnas, porque pueden ser
asignar mediante software. Pero es conveniente conectar los pines en una forma ordenada, para
hacer más fácil el cableado. Un diseño típico se muestra a continuación.

Matriz de pines no. Fila Columna el número de pin de Arduino

1 5 - 13
2 7 - 12
3 - 2 11
4 - 3 10
5 8 - 16 (pin analógico 2)
6 - 5 17 (pin analógico 3)
7 6 - 18 (4 pin analógico)
8 3 - 19 (pin analógico 5)
9 1 - 2
10 - 4 3
11 - 6 4
12 4 - 5
13 - 1 6
14 2 - 7
15 - 7 8
dieciséis - 8 9

Hardware Required
 Arduino or Genuino Board
 LED bar graph display or 10 LEDs
 Potentiometer
 10 220 ohm resistors
 hook-up wires
 breadboard

Circuito

Ing. Ronald N. Kopp Pá gina 8

Arduino
Los 16 pines de la matriz, se enganchan a los 16 pines de la placa Arduino o Genuino.  Cuatro de los
pines analógicos son utilizados como entradas digitales 16 a 19. El orden de los pines son asignados
por dos arrays (matrices), en el código.
Dos potenciómetros, conectados a los pines analógicos 0 y 1, controlar el movimiento de un LED que
se enciende en la matriz.

Schematic

Ing. Ronald N. Kopp Pá gina 9

Arduino

Código

Ing. Ronald N. Kopp Pá gina 10

Arduino

// array de números de pines de las filas:

const int row[8] = {
2, 7, 19, 5, 13, 18, 12, 16
};

// array de números de pines de las columnas:

const int col[8] = {
6, 11, 10, 3, 17, 4, 8, 9
};

// array de pixeles, cada LED representa un pixel formado por X e Y:

int pixels[8][8];

// posición inicial del cursor:

int x = 5;
int y = 5;

void setup() {
  // inicializamos los pines de E/S como salidas e
  // iteramos sobre los pines:
for (int thisPin = 0; thisPin < 8; thisPin++) {
pinMode(col[thisPin], OUTPUT);
pinMode(row[thisPin], OUTPUT);
// tomamos los pines de la columna (ej. los cátodos) y lo ponemos en ALTO
// para asegurarnos que los LEDs estén todos apagados:
digitalWrite(col[thisPin], HIGH);
}

// inicializamos la matriz de pixeles:

for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
pixels[x][y] = HIGH;
}
}
}

void loop() {
// leemos las entradas:
readSensors();

// dibujamos la pantalla:
refreshScreen();
}

Ing. Ronald N. Kopp Pá gina 11

Arduino

void readSensors() {

// apagamos la última posición en que el pixel fue encendido con un HIGH,

// ya que esto pone el cátodo en ALTO para ese valor de x e y:
pixels[x][y] = HIGH;

// leemos los valores de los sensores en X e Y:

x = 7 - map(analogRead(A0), 0, 1023, 0, 7);
y = map(analogRead(A1), 0, 1023, 0, 7);

// configuramos que el nuevo valor de x e y (posición del pixel) sea igual a LOW
// para que el LED se encienda en la próxima actualización de la pantalla:
pixels[x][y] = LOW;

void refreshScreen() {
// iteramos sobre las filas (ánodos):
for (int thisRow = 0; thisRow < 8; thisRow++) {

// tomamos el pin de la fila (ánodos) y lo ponemos en ALTO:

digitalWrite(row[thisRow], HIGH);

// iteramos sobre las columnas (cátodos):

for (int thisCol = 0; thisCol < 8; thisCol++) {

// obtenemos el estado del píxel actual, a través de

// que cuando pixels[thisRow][thisCol] = pixels[x][y] = LOW ;
int thisPixel = pixels[thisRow][thisCol];

// y como la filas están en ALTO, cuando la columna sea un BAJO,

// en ese punto se enciende el LED:
digitalWrite(col[thisCol], thisPixel);

// si no ponemos el pixel en off:

if (thisPixel == LOW) {
digitalWrite(col[thisCol], HIGH);
}
}
// ponemos el pin de la fila en BAJO para apagar toda la fila:
digitalWrite(row[thisRow], LOW);
// ahora vuelve a producirse toda la secuencia sobre otra fila
}
}

48. String Append Operator: Operador Encadenador de Sring (Cadena).

Ing. Ronald N. Kopp Pá gina 12

Arduino

Al igual que puede concatenar cadenas (Strings) con otros objetos de datos
utilizando StringAdditionOperator , también se puede utilizar el operador += y la forma concat() para
añadir cosas a la cadena (strings). El operador += y la forma concat() trabajan de la misma manera, es
sólo una cuestión de estilo que uno prefiera. Los dos ejemplos a continuación ilustran ambos casos, y
resultado es la misma cadena:

String stringOne = "A long integer: ";

// usando += para agregar un variable larga con string:
stringOne += 123456789;

or
String stringTwo = "A long integer: ";
// usando concat() para agregar un variable larga con string:
stringTwo.concat(123456789);

Hardware Required
 Arduino or Genuino Board

Circuit

No hay ningún circuito para este ejemplo, aunque la placa debe estar conectada a nuestro ordenador
a través del USB y la ventana del monitor serial del software de Arduino, debe estar abierta.

Código

Ing. Ronald N. Kopp Pá gina 13

Arduino
Abrimos la ventana del monitor serial del software de Arduino (IDE) y tipiamos un solo carácter a la
vez, a continuación, pulsamos Enviar para obtener un informe sobre ese carácter.

String stringOne, stringTwo;

void setup() {
// Abrimos el puerto serial y esperamos a que se abra:
Serial.begin(9600);
while (!Serial) {
; // esperamos hasta que el Puerto serial esté conectado.
}

stringOne = String("Sensor ");

stringTwo = String("value");

Serial.println("\n\nAppending to a string:"); // enviamos una introducción:

Serial.println();
}

void loop() {
Serial.println(stringOne); // imprimimos "Sensor "

stringOne += stringTwo; // agregamos un string a un string:

Serial.println(stringOne); // imprime "Sensor value"

stringOne += " for input "; // agrega un string constante al string:

Serial.println(stringOne); // imprime "Sensor value for input"

stringOne += 'A'; // agraga un caracter constante al string

Serial.println(stringOne); // imprime "Sensor value for input A"

stringOne += 0; // agraga un constante entera al string

Serial.println(stringOne); // imprime "Sensor value for input A0"

stringOne += ": "; // agraga un constante entera al string

Serial.println(stringOne); // imprime "Sensor value for input A0:”

stringOne += analogRead(A0); // agraga un variable entera al string:

Serial.println(stringOne); // imprime "Sensor value for input A0: 456"
// o el valor que es analogRead(A0)

Serial.println("\n\nchanging the Strings' values");

Ing. Ronald N. Kopp Pá gina 14

Arduino

stringOne = "A long integer: ";

stringTwo = "The millis(): ";

stringOne += 123456789; // agrega una constante entera larga (constant long integer) al string:
Serial.println(stringOne); // imprime "A long integer: 123456789"

// usamos concat() para agregar una variable long a un string:

stringTwo.concat(millis());
Serial.println(stringTwo); // imprime "The millis(): 43534" o el valor que es millis()

while (true); // no hacer nada mientras sea verdadero

}

49. String Case Changes: Cambio del Caso en un String.

Ing. Ronald N. Kopp Pá gina 15

Arduino

La función case en String permite cambiar el caso de un String. Funciona tal cual sus nombres lo
indican. toUpperCase()cambia toda la cadena de caracteres en mayúsculas y toLowerCase()cambia
toda la cadena de caracteres en minúscula. Sólo los caracteres de la “A” a “Z”, o de a “a” la “z” se ven
afectados.

Hardware Required
 Arduino or Genuino Board

Circuit

No hay ningún circuito para este ejemplo, aunque la placa debe estar conectada a nuestro ordenador
a través del USB y la ventana del monitor serial del software de Arduino, debe estar abierta.

Código

Ing. Ronald N. Kopp Pá gina 16

Arduino
Abrimos la ventana del monitor serial del software de Arduino (IDE) y tipiamos un solo carácter a la
vez, a continuación, pulsamos Enviar para obtener un informe sobre ese carácter.

void setup() {
// Abrimos el puerto serial y esperamos a que se abra:
Serial.begin(9600);
while (!Serial) {
; // esperamos hasta que el Puerto serial esté conectado.
}

Serial.println("\n\nString case changes:"); // enviamos una introducción:

Serial.println();
}

void loop() {
// toUpperCase() cambia todas las letras a mayúsculas:
String stringOne = "<html><head><body>";
Serial.println(stringOne);
stringOne.toUpperCase();
Serial.println(stringOne);

// toLowerCase() cambia todas las letras a minúsculas:

String stringTwo = "</BODY></HTML>";
Serial.println(stringTwo);
stringTwo.toLowerCase();
Serial.println(stringTwo);

while (true); // no hacer nada mientras sea verdadero (bucle cerrado)

}

50. String Characters:

Ing. Ronald N. Kopp Pá gina 17

Arduino

Las funciones String charAt() y setCharAt() se utilizan para obtener o establecer el valor de un

carácter en una posición determinada de un String.

En su forma más simple, estas funciones le ayudan a buscar y reemplazar un carácter

determinado. Por ejemplo, el siguiente sustituye los dos puntos en una cadena (String) con un signo
igual:

String reportString = "SensorReading: 456";

int colonPosition = reportString.indexOf(':');
reportString.setCharAt(colonPosition, '=');

Aquí hay un ejemplo que comprueba si la primera letra de la segunda palabra es 'B':
String reportString = "Franklin, Benjamin";
int spacePosition = reportString.indexOf(' ');
if (reportString.charAt(spacePosition + 1) == 'B') {
Serial.println("You might have found the Benjamins.")
}

Atención: Si se intenta obtener  charAt o se usar setCharAt() en un valor que es mayor que la

longitud de la cadena, se obtendrá resultados inesperados. Si no se está seguro, compruebe que la
posición que desea establecer o conseguir es menor que la longitud de la cadena utilizando la
función length().

Ing. Ronald N. Kopp Pá gina 18

Arduino
Hardware Required
 Arduino or Genuino Board

Circuit

No hay ningún circuito para este ejemplo, aunque la placa debe estar conectada a nuestro ordenador
a través del USB y la ventana del monitor serial del software de Arduino, debe estar abierta.

Código

Ing. Ronald N. Kopp Pá gina 19

Arduino
Abrimos la ventana del monitor serial del software de Arduino (IDE) y tipiamos un solo carácter a la
vez, a continuación, pulsamos Enviar para obtener un informe sobre ese carácter.

void setup() {
// Abrimos el puerto serial y esperamos a que se abra:
Serial.begin(9600);
while (!Serial) {
; // esperamos hasta que el Puerto serial esté conectado.
}

Serial.println("\n\nString charAt() and setCharAt():"); // enviamos una introducción:

Serial.println();
}

void loop() {
// hacemos un string para reportar la lectura del sensor:
String reportString = "SensorReading: 456";
Serial.println(reportString);

// el dígito más significativo de la lectura está en la posición 15 en el reportString:

char mostSignificantDigit = reportString.charAt(15);

String message = "Most significant digit of the sensor reading is: ";
Serial.println(message + mostSignificantDigit);

// agregamos un espacio en blanco:

Serial.println();

// también podemos establecer el carácter de un String. Cambiamos los : por =

reportString.setCharAt(13, '=');
Serial.println(reportString);

while (true); // no hacer nada mientras sea verdadero (bucle cerrado)

}

S e n s o r R e a d i n g : 4 5 6
Carácter 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

String Comparison Operators

Ing. Ronald N. Kopp Pá gina 20
Arduino

Ing. Ronald N. Kopp Pá gina 21