Aprender

Punteros en Arduino, en dos lámparas y una función que reduce a la mitad un delay

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: dos lámparas y un delay reducido a la mitad mediante un punteroen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
halve(&onMs) obtiene la dirección de onMs, así puede cambiar la variable de quien llama.

A pointer is a variable that holds the address of another variable. &speed is the address of speed, int *p = &speed; keeps that address in p, and *p goes to the address, so *p = 50; changes speed. On an Uno an address is 2 bytes. Pointers are how a function changes the caller’s variable, and how an array reaches a function at all.

El circuito de arriba son dos lámparas en un Uno cuyo tiempo de parpadeo se cambia mediante un puntero. Presiona Ejecutar. El monitor serie imprime "onMs before = 400" y "onMs after = 200", porque halve(&onMs) le entregó a la función la dirección de onMs y ella redujo a la mitad lo que había allí. Después vienen "sizeof(int*) = 2", "sum of rates = 1500" y dos velocidades leídas mediante un puntero, 100 y 400.

Abajo están & y *, punteros frente a referencias, arreglos como punteros, recorrer una cadena, punteros a función y los errores, cada uno ejecutado en un Uno con lo que imprimió.

¿Quieres la versión paso a paso? La lección "Dónde vive una cosa" recorre esto con puntos de control.

Abrir la lección

Los dos símbolos

En una declaración, * significa "puntero a": int *value es un puntero a un int. En cualquier otro lugar, *value significa "el int que está en esa dirección", y &onMs significa "la dirección de onMs". Aquí está la función del sketch de arriba. Nunca ve a onMs en sí, solo dónde vive, y *value = *value / 2; lee lo que hay allí y escribe la mitad de vuelta.

Sin el puntero, una función recibe una copia del número y la variable de quien llama queda como estaba. Esa es toda la razón para entregar una dirección.

firmware/uno/examples/cppptr (la función corriendo arriba)
static void halve(int *value) {
  *value = *value / 2;
}

Una función que cambia dos variables

Intercambiar dos números es la prueba clásica. swap(&x, &y) abajo imprimió "8 3", así que ambas variables de quien llama cambiaron. Una referencia de C++ hace el mismo trabajo con menos signos: int &a en la lista de parámetros, y sin & ni * en ningún otro lugar. swapRef(x, y) los intercambió de vuelta e imprimió "3 8".

Las bibliotecas de Arduino usan ambos. Una referencia no puede estar vacía ni cambiarse para apuntar a otro lugar; un puntero puede ser nullptr, lo cual una función puede comprobar, y puede recorrer un arreglo.

Intercambio, con un puntero y con una referencia
void swap(int *a, int *b) {
  int keep = *a;
  *a = *b;
  *b = keep;
}

void swapRef(int &a, int &b) {
  int keep = a;
  a = b;
  b = keep;
}

void setup() {
  Serial.begin(9600);
  int x = 3, y = 8;
  swap(&x, &y);
  Serial.print(x);
  Serial.print(" ");
  Serial.println(y);
  swapRef(x, y);
  Serial.print(x);
  Serial.print(" ");
  Serial.println(y);
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Un arreglo llega como un puntero

An array handed to a function is handed over as a pointer to its first element. So in the sketch below, sizeof(rates) printed 8, four ints of 2 bytes, but the same sizeof inside show() printed 2: the size of a pointer. Clang warned: sizeof on array function parameter will return size of 'int *' instead of 'int[]'. That is why a function that takes an array also takes its length, as sumOf(rates, RATE_COUNT) does above.

Indexes and pointers are two spellings of one thing. With int *p = rates;, both *(p + 3) and p[3] printed 800. p++ moves the pointer on by one int, 2 bytes, so *p then printed 200.

sizeof fuera y dentro de una función
int rates[] = {100, 200, 400, 800};

void show(int list[]) {
  Serial.println(sizeof(list));
}

void setup() {
  Serial.begin(9600);
  Serial.println(sizeof(rates));
  show(rates);
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Recorrer una cadena, y una lista de funciones

A string in quotes is a row of characters with a zero byte at the end, and const char *message = "Mokxi"; points at its first letter. A loop that moves the pointer until it reaches the zero printed "M o k x i". That is how strlen() and Serial.print() find the end of your text.

Un puntero también puede guardar la dirección de una función. El sketch de abajo guarda tres funciones en un arreglo y llama a cada una por turno; imprimió "slow", "fast" y "off". Un menú o un conjunto de patrones de luz elegidos con un botón es el uso habitual: el botón cambia un número, y modes[number]() ejecuta ese modo.

Un arreglo de funciones
void slow() {
  Serial.println("slow");
}

void fast() {
  Serial.println("fast");
}

void off() {
  Serial.println("off");
}

void (*modes[])() = {slow, fast, off};

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < 3; i++) {
    modes[i]();
  }
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Errores, hechos a propósito

Un número donde va una dirección: int *p = x; detuvo la compilación con cannot initialize a variable of type 'int *' with an lvalue of type 'int'. GCC dice invalid conversion from 'int' to 'int*'. Escribe &x.

Una dirección que ya no existe: una función que regresa un puntero a su propio arreglo local entrega memoria que se reutiliza en cuanto regresa. Clang advirtió address of stack memory associated with local variable 'text' returned, y el sketch imprimió una línea en blanco en vez de "ready". GCC dice address of local variable 'text' returned. Haz el arreglo static, o haz que quien llama pase un búfer que llenar.

La dirección de nada: un puntero puesto en nullptr no apunta a nada. Prueba if (p == nullptr) antes de usar uno que quizá no se haya asignado; ese sketch imprimió "points at nothing".

Abre este circuito en el editor. Arduino Uno: dos lámparas y un delay reducido a la mitad mediante un puntero, cableado tal como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Preguntas

¿Qué es un puntero en Arduino?

Una variable que guarda la dirección de memoria de otra variable en lugar de un valor. En un Uno ocupa 2 bytes. *p lee o escribe lo que haya en esa dirección.

¿Cuál es la diferencia entre * y & en el código de Arduino?

& antes de una variable da su dirección. * en una declaración crea un puntero, y * antes de un puntero en cualquier otro lugar va al valor al que apunta. En una lista de parámetros, & después de un tipo crea una referencia.

¿Debo usar un puntero o una referencia?

Usa una referencia cuando una función debe cambiar una variable que quien la llama siempre tiene. Usa un puntero cuando podría no haber nada a lo que apuntar, o para recorrer un arreglo.

¿Por qué sizeof da mal dentro de mi función?

El arreglo llegó como un puntero, así que sizeof da el tamaño del puntero, 2 bytes en un Uno. Pasa la longitud como segundo parámetro, calculada con sizeof donde se declara el arreglo.

¿Necesito punteros para programar un Arduino?

No para empezar. Los usas sin darte cuenta cada vez que pasas un arreglo o una cadena a una función, y los necesitas para escribir una función que cambie las variables de quien la llama o para llevar una lista de funciones.

Fuentes

De dónde vienen los datos de esta página

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.