Curso de Arduino

Tipo de dato int en Arduino

El tipo de dato int en Arduino es un entero de 16 bits con signo. Puede almacenar valores desde -32,768 hasta 32,767.

Cuando una variable int alcanza su máximo y sigue sumando, ocurre un desbordamiento y pasa a números negativos. Para evitarlo, podemos reiniciar el contador.

Tipo de dato byte en Arduino

El tipo de dato byte es un entero de 8 bits sin signo, que solo guarda números positivos. Su rango es de 0 a 255 y ocupa 1 byte de memoria.

Ideal para valores pequeños como edades, días, puntajes o cantidades de objetos. La memoria no se desperdicia si no usamos todo el rango. Solo guarda el número que pongamos.

Visualización del byte

Imagina que el byte es una cajita que puede guardar cualquier número del 0 al 255:

Si luego ponemos 100, reemplazamos el 40 por 100:

La cajita solo guarda un número a la vez. El resto del rango (0–255) no ocupa memoria mientras no lo usemos.

Ejemplos prácticos de byte

• Edad de una persona (0–120)
• Días en un mes (0–31)
• Cantidad de estudiantes en un salón (~50)
• Inventario pequeño: lápices, libros, piezas (0–255)
• Puntajes o calificaciones en juegos educativos (0–100)

🧩 Ejercicio: Semáforo de Desbordamiento con Dos LEDs

Este ejercicio demuestra visualmente el desbordamiento de una variable byte usando DOS LEDs diferentes:

• LED ROJO (integrado, pin 13): Se enciende cuando el contador alcanza el límite máximo (255)
• LED VERDE (externo, pin 12): Se enciende cuando el contador se reinicia (0) después del desbordamiento

🔌 Conexiones necesarias:

LED Verde externo:
Pin 12 → Resistencia 220Ω → Ánodo LED (+) → Cátodo LED (-) → GND

💻 Código completo:

byte contador = 250;
const int LED_VERDE = 12;  // LED externo para contador = 0

void setup() {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);   // LED integrado (255)
  pinMode(LED_VERDE, OUTPUT);     // LED externo (0)
}

void loop() {
  Serial.println(contador);
  
  // LED ROJO enciende en 255 (límite máximo)
  digitalWrite(LED_BUILTIN, contador == 255);
  
  // LED VERDE enciende en 0 (reinicio después del desbordamiento)
  digitalWrite(LED_VERDE, contador == 0);
  
  contador++;
  delay(1000);
}
    

🎯 Comportamiento esperado:

Resumen

• int: entero de 16 bits con signo (-32,768 a 32,767). Útil para valores negativos o medianos.
• byte: entero de 8 bits sin signo (0 a 255). Útil para valores pequeños y positivos.
• short: en Arduino UNO es igual a int (16 bits). Se usa por compatibilidad con C/C++ en otras plataformas.
• Siempre elegir el tipo más pequeño que cubra el rango necesario.
• El límite de cada tipo indica el valor máximo que puede almacenar, pero no significa que se reserven todos los valores en memoria.

Tipo de dato long en Arduino

El tipo de dato long es un entero de 32 bits con signo. Su rango es de -2,147,483,648 a 2,147,483,647.

Es útil cuando necesitamos contar números muy grandes, como milisegundos de funcionamiento, pulsos de sensores o acumuladores de datos que superan el rango de int.

Ejemplo con long

long milisegundos = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  milisegundos = millis(); // Captura el tiempo desde que se inició el Arduino

  Serial.print("Tiempo encendido: ");
  Serial.print(milisegundos);
  Serial.println(" ms");

  delay(1000); // Espera 1 segundo
}
        

Tipo de dato float en Arduino

El tipo de dato float ocupa 4 bytes y puede almacenar números con decimales. Su rango aproximado es ±3.4028235E+38 con una precisión de 6–7 cifras decimales.

⚠️ En Arduino UNO no hay double como en otros lenguajes; float y double son lo mismo.

Regla práctica: No importa dónde vaya el punto decimal — lo que importa es el total de cifras significativas. Si la cantidad total de dígitos excede ~7, los últimos pueden perder precisión.

Ejemplo en Arduino

float temperatura = 23.7;  

void setup() {
  Serial.begin(9600);
}

void loop() {
  temperatura = temperatura + 0.1; // Simula aumento
  Serial.print("Temperatura actual: ");
  Serial.println(temperatura);
  delay(1000);
}
        

float peso1 = 16.5;   // Primer peso
float peso2 = 23.75;  // Segundo peso
float peso3 = 0.125;  // Peso pequeño

void setup() {
  Serial.begin(9600); // Inicia el monitor serial
}

void loop() {
  Serial.print("Peso 1: ");
  Serial.println(peso1);

  Serial.print("Peso 2: ");
  Serial.println(peso2);

  Serial.print("Peso 3: ");
  Serial.println(peso3);

  delay(2000); // Espera 2 segundos antes de repetir
}
        

🔁 EJERCICIO: DEMOSTRACIÓN DE OVERFLOW (DESBORDAMIENTO)

🎯 Objetivo claro: Crear un contador de segundos que muestre cómo una variable int se desborda (overflow) al superar su límite máximo positivo.

📝 Explicación:

En programación, un int tiene un tamaño limited (en Arduino suele ser de 16 bits). Esto significa que puede guardar valores desde -32,768 hasta 32,767. Cuando el contador llega al máximo (32,767) y le sumamos 1, automáticamente se "desborda" y pasa a -32,768, reiniciando el ciclo de valores.

⚡ Código de ejemplo:

int segundos = 32760; // Valor inicial cercano al máximo de int

void setup() {
  Serial.begin(9600); // Inicia el monitor serial
}

void loop() {
  segundos++;  // Aumenta el contador en 1
  Serial.println(segundos);
  delay(500);  // Retardo de medio segundo
}
        

🔍 Observa:

• Cuando llegue a 32767 y sume 1, el valor pasará a -32768.
• Esto demuestra claramente el fenómeno de overflow.
• Es útil para entender los límites de las variables.

Ejemplo de contador con int

int segundos = 0;

void setup() {
  Serial.begin(115200);
}

void loop() {
  delay(1000);
  segundos++;

  Serial.print(segundos);
  Serial.println(" segundos");

  // ✅ Detecta el overflow JUSTO cuando ocurre
  if (segundos == -32768) {
    Serial.println("¡OVERFLOW OCURRIDO! El contador se desbordó a negativo.");
    // segundos = 0; // Opcional: si quieres reiniciar después de mostrarlo
  }
}
        

Ejemplos de uso del límite máximo de int

• Sistema de riego automatizado:
  Contar segundos de riego o litros de agua suministrados.
  Máximo de 32,767 litros o segundos antes del reinicio.
• Contador de entradas:
  Entradas a un estadio, concierto o feria.
  Cada persona suma 1 al contador hasta 32,767 personas.
• Temporizador de procesos industriales:
  Contar segundos que tarda un proceso, como llenado de tanques o cocción de alimentos.
  Hasta 32,767 segundos (~9 horas) antes de reiniciar.

🏟️ Contador de personas en un estadio

🎯 Objetivo:
Simular un sistema de conteo de personas que entran a un estadio con capacidad para más de 50,000 personas, mostrando por qué debemos usar el tipo de dato long en lugar de int.

📖 Contexto:
Imagina que tienes un estadio con una capacidad de 60,000 espectadores. Si usas un int (que solo llega hasta 32,767 en Arduino UNO), el contador se desbordaría antes de alcanzar el número real de asistentes. Por eso, necesitamos long, que permite contar hasta más de 2 mil millones.

💻 Código en Arduino:

 // Declaramos el contador como long porque un int no alcanzaría
 long contadorPersonas = 0;

 void setup() {
   Serial.begin(9600);  // Inicia el monitor serial
   Serial.println("🏟️ Contador de personas en el estadio");
   Serial.println("Capacidad aproximada: 60,000");
 }

 void loop() {
   contadorPersonas++;  // Simula que entra una persona más

   // Mostramos en el monitor serial
   Serial.print("Personas dentro del estadio: ");
   Serial.println(contadorPersonas);

   // Si llegamos a 60,000 paramos la simulación
   if (contadorPersonas >= 60000) {
     Serial.println("✅ Estadio lleno!");
     while (true) {
       // Se queda detenido aquí
     }
   }

   delay(10); // Pequeña pausa para simular el tiempo de entrada
 }