# Arduino

# Concepto byte & PWM

# Byte

El byte es la unidad de información digital formada generalmente por ocho bits (serie de ceros y unos). Estos 8 bits permiten 256 combinaciones.

El byte es la unidad que las computadoras utilizan para representar un caracter como una letra, un número y otros símbolos. El byte es la unidad de datos más pequeña con significado y la menor unidad de memoria. Es uno de los fundamentos del IDE de arduino (Integrated Development Environment o Entorno de Desarrollo Integrado) trabajaremos con bytes para controlar los pines PWM (pulse width modulation o modulación por ancho de pulso) que explicaremos más adelante. Otra relación con los bytes es que cada byte representa un carácter o una tecla o grupo de tecla.

# PWM (puse with modulation)

Para emular una señal analógica se cambia el ciclo de trabajo (el tiempo que permanece encendido y apagado de tal forma que el valor promedio de la señal sea el voltaje aproximado que se desea obtener, pudiendo entonces enviar hasta 256 voltajes diferentes entre 0 y 5 voltios.

# Concepto pin de Arduino

En arduino encontramos 3 tipos de pines.

# Digitales (entrada o salida)

Son en los que tenemos dos posibilidades 0 ó 5 voltios en arduino lo veremos como "low" o "high", como apagado o encendido

# PWM (salida)

Son los que podemos tener 256 voltajes diferentes entre 0 y 5 voltios.

# Analógico (entrada)

Son convertidores de señales analogicas en señales digitales a diferencia de PWM que utilizan 8 bits en analógico utilizamos 10 bits con lo que tenemos 1024 intervalos voltajes entre 0 y 5 voltios.

# Concepto sensor-actuador

# Sensores

Un sensor es un dispositivo con alguna propiedad eléctrica capaz de detectar magnitudes físicas o químicas, por ejemplo, la temperatura, una distancia, intensidad lumínica, aceleración, inclinación…

En arduino se configuran siempre como entrada y nos proporciona información que procesaremos generalmente para dar una respuesta a un actuador/es.

En róbotica educativa se utilizan mucho los sensores de ultrasonidos (HC-SR04) para evitar obstáculos y los infrarrojos(TCRT5000) para seguir líneas. Otros muy utilizados en kits de iniciación son el de temperatura (TMP36), temperatura y humedad (DHT11) y fotoresistencia LDR.

# Actuadores

Por otro lado los actuadores son la respuesta al procesamiento de la programación transformando un valor digital o seudoanalógico (PWM) en un movimiento mecánico (motores, servos ...), la producción de sonido (buzzers)...

En arduino los programaremos junto con sensores para dar algún tipo de respuesta con la información que nos proporcionan, por ejemplo, con los sensores de ultrasonidos podríamos detectar un obstáculo y hacer que retroceda y gire robot para salvarlo.

En robótica educativa los que más solemos utilizar son los motores, los servos, buzzer y leds.

# Crear una Library en Arduino

Morse Library

Necesitamos al menos de dos archivos para una biblioteca:

• Morse.h
• Morse.cpp

# Encabezado (Morse.h)

El archivo de encabezado tiene definiciones para la biblioteca: básicamente una lista de todo lo que hay dentro.

#ifndef Morse_h
#define Morse_h

#include "Arduino.h"

class Morse
{
  public:
    Morse(int pin);
    void dot();
    void dash();
  private:
    int _pin;
};

#endif

Es común envolver todo el archivo de encabezado en una construcción de aspecto extraño

#ifndef Morse_h
#define Morse_h

#endif

Básicamente, esto evita problemas si alguien # incluye accidentalmente su biblioteca dos veces.

#include "Arduino.h"

Una es una declaración #include que le da acceso a los tipos y constantes estándar del lenguaje Arduino.

Una clase es simplemente una colección de funciones y variables que se mantienen juntas en un solo lugar. Pueden ser públicas , lo que significa que son accesibles desde cualquier parte a ellas, o privadas , lo que significa que solo se puede acceder a ellas desde la propia clase. Cada clase tiene una función especial conocida como constructor , que se utiliza para crear una instancia de la clase. El constructor tiene el mismo nombre que la clase y no tiene tipo de retorno.

# Origen (*.cpp)

El archivo fuente tiene el código real:

#include "Arduino.h"
#include "Morse.h"

Morse::Morse(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
}

void Morse::dot()
{
  digitalWrite(_pin, HIGH);
  delay(250);
  digitalWrite(_pin, LOW);
  delay(250);  
}

void Morse::dash()
{
  digitalWrite(_pin, HIGH);
  delay(1000);
  digitalWrite(_pin, LOW);
  delay(250);
}

Primero vienen un par de declaraciones #include. Estos le dan al resto del código acceso a las funciones estándar de Arduino y a las definiciones en su archivo de encabezado:

#include "Arduino.h"
#include "Morse.h"

Luego viene el constructor. Nuevamente, esto explica lo que debería suceder cuando alguien crea una instancia de su clase. En este caso, el usuario especifica qué pin le gustaría usar. Configuramos el pin como una salida y lo guardamos en una variable privada para usar en las otras funciones:

Morse::Morse(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
}

Luego viene el código real del boceto que está convirtiendo en una biblioteca

void Morse::dot()
{
  digitalWrite(_pin, HIGH);
  delay(250);
  digitalWrite(_pin, LOW);
  delay(250);  
}

void Morse::dash()
{
  digitalWrite(_pin, HIGH);
  delay(1000);
  digitalWrite(_pin, LOW);
  delay(250);
}

# Sketch + Library

#include <Morse.h>

Morse morse(13);

void setup()
{
}

void loop()
{
  morse.dot(); morse.dot(); morse.dot(); // ...

  morse.dash(); morse.dash(); morse.dash(); // ---

  morse.dot(); morse.dot(); morse.dot(); // ...

  delay(3000);
}

Incluimos la librería y llamamos al constructor

#include <Morse.h>

Morse morse(13);

Ejecutamos las funciones (métodos) de la clase:

morse.dot();
morse.dash();