I/O DIGITALES

VARIABLES

ENTRADAS
ANALÓGICAS

WHILE - IF

PUERTO SERIE

ARDUINO
Apuntes teóricos importantes
Arduino es una plataforma de prototipos electrónica de código
abierto (open-source) basada en hardware y software flexibles y
fáciles de usar.

TECNOLOGÍAS DE LA
INFORMACIÓN (TI)
Ugolini Ailin
+
I/O DIGITALES
Con pinMode () podés configurar el pin especificado para que se
comporte como una entrada o como una salida. Se hace de la siguiete forma:

Sintaxis:

pinMode(PIN, MODE);

Parámetros:

PIN: El número de pin al que desea configurar

MODE: INPUT, OUTPUT, or INPUT_PULLUP.

Escritura
Otra de las cosas que podemos hacer es escribir un valor HIGH o LOW en un pin
digital inicializado como salida

Sintaxis:

digitalWrite(PIN, VALUE);

Parámetros:

PIN: el número de pin

VALUE: HIGH o LOW

Devoluciones:

Nada
 Lectura
Para poder leer el valor de un pin también tenemos una función

Sintaxis

digitalRead(PIN);

Parámetros

pin: el número del pin digital que quieres leer

Devoluciones

HIGH o LOW

Lo que hacemos con digitalRead(PIN); es leer el valor que hay en dicho pin.
Para poder mantener esta información debemos guardarla en una variable. Pero, ¿Cómo
hacemos esto? El primer paso es inicializar una variable, supongamos que su nombre es
‘Variable’. Lo que debo hacer para guardar la información de la lectura es:

Variable = digitalRead(PIN); //Queda en ‘Variable’ el valor que leí.

Delay:
Su función es la de pausar el programa por una cantidad de tiempo (en
milisegundos) especificado como parámetro. (Recordá que hay 1000 milisegundos
en un segundo).

Sintaxis

delay(ms);

Parámetros

ms: el número de milisegundos para pausar ( unsigned long)

Devoluciones

Nada
 Contadores:
Llamamos contador a una variable cuyo valor se incrementa o decrementa en un valor
fijo (en cada iteración de un bucle).

Boton = digitalRead( X );

if (Boton == 0) //Si el boton está apretado

While (Boton == 0 ) //Mientras este apretado

Boton = digitalRead( X ); //Leo el boton

CONTADOR = CONTADOR + 1; //Aumento el valor

Veamos como quedaría esto en un ejemplo completo hecho por Matias Silveiro:
else
// Sketch de prueba de una rutina de semaforo {
int DELAY_MS = 500; proxima_rutina == 1;
char estado_boton; }
char proxima_rutina; }

void setup()
{ // Controlo que rutina muestro
// Inicializacion de salidas digitales (LEDs) if(proxima_rutina == 1)
pinMode(2, OUTPUT); {
pinMode(3, OUTPUT); digitalWrite(2,HIGH);
pinMode(4, OUTPUT); digitalWrite(3, LOW);
pinMode(5, OUTPUT); digitalWrite(4, LOW);
pinMode(7, INPUT_PULLUP); digitalWrite(5,HIGH);
delay(DELAY_MS);
// Inicializo la proxima rutina a mostrar
proxima_rutina = 1; digitalWrite(2, LOW);
} digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
void loop() digitalWrite(5, LOW);
{ delay(DELAY_MS);
// Por un lado controlo el boton, y por otro la rutina }

// Leo el estado del boton else

estado_boton = digitalRead(7); {
digitalWrite(2,HIGH);
// Si presione el boton... digitalWrite(3,HIGH);
if(estado_boton == 0) digitalWrite(4, LOW);
{ digitalWrite(5, LOW);
// Espero a que se suelte el boton delay(DELAY_MS);
while(estado_boton == 0)
{ digitalWrite(2, LOW);
estado_boton = digitalRead(7); digitalWrite(3, LOW);
} digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
// Cambio a la otra rutina delay(DELAY_MS);
if(proxima_rutina == 1) }
{ }
proxima_rutina = 2;
}
 Puerto Serie:
Los puertos serie son la forma principal de comunicar una placa Arduino con un
ordenador. Gracias al puerto serie podemos, por ejemplo, mover el mousse o simular la
escritura de un usuario en el teclado, enviar correos con alertas, controlar un robot
realizando los cálculos en el ordenador, encender o apagar un dispositivo desde una
página Web a través de Internet, o desde una aplicación móvil a través de Bluetooth.

Para realizar la conexión mediante puerto serie únicamente es necesario conectar

nuestra placa Arduino empleando el mismo puerto que empleamos para programarlo. A
continuación abrimos el IDE Standard de Arduino y hacemos click en el “Monitor Serial”,
que es una pequeña utilidad integrada dentro de IDE Standard que nos permite enviar
y recibir fácilmente información a través del puerto serie. Su uso es muy sencillo,
y dispone de dos zonas, una que muestra los datos recibidos, y otra para enviarlos.
 Recordá que en el Setup tenés que inicializar el puerto serie usando la función
detallada a continuación:

Sintaxis:
Serial.begin(speed);

Parámetros:
speed: in bits per second (baud) – long

Devoluciones:

Nada

Para imprimir en pantalla tenemos una función que imprime datos en el

puerto serie como texto ASCII legible por humanos. Este comando puede tomar
muchas formas. Los números se imprimen utilizando un carácter ASCII para cada
dígito, pasamos a detallarla:

Sintaxis:
Serial.print(Valor);

Serial.print(Valor, formato);

Parámetros:
Valor: El valor para imprimir

Formato: especifica la base de los números (para los tipos

de datos integrales) o la cantidad de lugares decimales (para los
tipos de coma flotante)

Devoluciones:

size_t (long): print () devuelve el número de bytes

escritos, aunque leer ese número es opcional .

Código ASCII:
La comunicación a través de cualquier puerto serie es en código binario y se
mandan en grupos de 8 bits (byte). Puesto que el humano entiende caracteres
alfanuméricos, codificamos los caracteres en binario según el código ASCII.
 PWM (Pulse Width Modulation):
La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés
de pulse-width modulation) de una señal o fuente de energía es una técnica en la que se
modifica el ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por
ejemplo), ya sea para transmitir información a través de un canal de comunicaciones o
para controlar la cantidad de energía que se envía a una carga.
En un circuito simple, que consta de un resistor y un led, necesitamos variar el
valor de la Resistencia para ver cambiar la intensidad del led. Mi objetivo principal es
iluminar, pero parte de la energía se la lleva la Resistencia, es decir que no toda la
energía me va al diodo Led. Además, ¿qué precision tengo al mover un potenciómtro? al
moverlo manualmente no tengo precision, es una perilla. Entonces tengo ciertos
problemas:

- Mala precision.
- Al usar un potenciómetro para variarlo, el led comienza a parpadear (solo con
led, explicación dada en clase)
- Lo que use para variar (preset, potenciómetro, etc) me consume.

Entonces nosotros usamos PWM para mejorar la eficiencia y la precisión.

 Notemos que:
- El período (T) la señal rectangular es siempre el mismo, recordemos que la
frecuencia es 1/T
- Varío cuanto tiempo de la señal “está en alto”, pero so se llama modelación por
ANCHO de pulso. Por eso varía la intensidad.
- Cuando tengo una frecuencia grande no veo el parpadeo del led, ya que tiene
muchos ciclos por segundo.

En Arduino, con ATmega168 o ATmega328, la señal de salida PWM (pines

3,5,6,9,10, y 11) es una señal de frecuencia 490 Hz aproximadamente y que sólo nos
permite cambiar el "duty cycle" o el tiempo que el pulso está activo (on) o inactivo (off),
utilizando la función analogWrite().

El programa pone el pin 10 a HIGH una vez por segundo durante medio segundo
(ciclo de trabajo 50%), la frecuencia que se genera en dicho pin es de 1 pulso por
segundo o 1 Hz de frecuencia (periodo de 1 segundo). Cambiando la temporización del
programa, podremos cambiar el ciclo de trabajo de la señal. Por ejemplo, si cambiamos
las dos líneas con delay(500) por delay(250) y delay(750), modificamos el ciclo de
trabajo a 25%; ahora, el programa pone el pin 10 a HIGH una vez por segundo durante
1/4 de segundo y la frecuencia sigue siendo de 1 Hz.
 Sintaxis:

analogWrite(PIN, VALUE);

Parámetros:

PIN: el número de pin (debe tener el ~ ).

VALUE: el ciclo de trabajo: entre 0 (siempre apagado) y 255

(siempre activado). Tipos de datos permitidos: int

Devoluciones:

Nada

Entradas Analógicas:
- AD: Conversor Analógico Digital.

Entran infinitos
valores hasta Vcc. A/D 2n = Resolución =
1024 (si n=10)

Cuando leo un valor analógico pierdo parte de la información, esta es al

resolución. En el ejemplo de arriba tengo 1024 combinaciones de 0 y 1 para
representar lo ingresado.

V (lo que ingresa) N (lo que sale)

0 0000000000
2,5 511
5 1023

Entonces llegamos a la conclusión de que:

𝟓
𝑽= 𝑵∗
𝟏𝟎𝟐𝟒

N = analogRead(A0)
 (N ∗ 5)
𝐕 = //Obtengo que voltaje analógico entró.
1024

Profundicemos sobre la función analogRead(A0)

Sintaxis:

analogRead(PIN);

Parámetros:

PIN: el número de pin (A0 a A5 para el UNO)

Devoluciones:

int (0 a 1023)