Arduino

Language Reference
Arduino programs can be divided in three main parts: structure, values (variables and constants), and
functions.
Structure Variables Functions
 setup() Constants Digital I/O
 loop()  HIGH | LOW  pinMode()
Control Structures  INPUT | OUTPUT |  digitalWrite()
 if INPUT_PULLUP  digitalRead()
 if...else  LED_BUILTIN Analog I/O
 for  true | false  analogReference()
 switch  integerconstants  analogRead()
 case  floatingpointconstants  analogWrite() - PWM
 while Data Types Dueonly
 do... while  void  analogReadResolution()
 break  boolean  analogWriteResolution()
 continue  char Advanced I/O
 return  unsignedchar  tone()
 goto  byte  noTone()
FurtherSyntax  int  shiftOut()
 ; (semicolon)  unsignedint  shiftIn()
 {} (curlybraces)  word  pulseIn()
 // (single line  long Time
comment)  unsignedlong  millis()
 /* */ (multi-line  short  micros()
comment)  float  delay()
 #define  double  delayMicroseconds()
 #include  string - chararray Math
ArithmeticOperators  String - object  min()
 = (assignmentoperator)  array  max()
 + (addition) Conversion  abs()
 - (subtraction)  char()  constrain()
 * (multiplication)  byte()  map()
 / (division)  int()  pow()
 % (modulo)  word()  sqrt()
ComparisonOperators  long() Trigonometry
 == (equalto)  float()  sin()
 != (notequalto) Variable Scope&Qualifiers  cos()
 < (lessthan)  variable scope  tan()
 > (greaterthan)  static RandomNumbers
 <= (less than or equal  volatile  randomSeed()
to)  const  random()
 >= (greater than or Utilities Bits and Bytes
equal to)  sizeof()  lowByte()
BooleanOperators  highByte()
 && (and)  bitRead()

Ing. Ronald N. Kopp Página 1

Arduino

 || (or)  bitWrite()
 ! (not)  bitSet()
Pointer Access Operators  bitClear()
 * dereferenceoperator  bit()
 &referenceoperator ExternalInterrupts
BitwiseOperators  attachInterrupt()
 & (bitwise and)  detachInterrupt()
 | (bitwiseor) Interrupts
 ^ (bitwisexor)  interrupts()
 ~ (bitwisenot)  noInterrupts()
 << (bitshiftleft) Communication
 >> (bitshiftright)  Serial
CompoundOperators  Stream
 ++ (increment) USB (Leonardo and Due only)
 -- (decrement)  Keyboard
 += (compoundaddition)  Mouse
 -=
(compoundsubtraction
)
 *=
(compoundmultiplicati
on)
 /= (compounddivision)
 &= (compoundbitwise
and)
 |=
(compoundbitwiseor)

Glosario:
 code / function: comando
 sketch: boceto/programa
 delay: retraso / demora
 loop: bucle/lazo
 set: establecer/inicializar
 running: ejecutándose

Paginas consultadas:

http://wiring.org.co/reference/
http://arduino.cc/en/Tutorial/HomePage

Ing. Ronald N. Kopp Página 2

Arduino
Código de colores de las Resistencias

Ing. Ronald N. Kopp Página 3

Arduino
Funciones básicas
Los bocetos (sketch) utilizados aquí, de ejemplos, son programas que demuestran los comandos
básicos de Arduino. Se encuentran incluidos en el programa Arduino; para abrirlos, hacemos clic en el
botón Abrir de la barra de herramientas y buscamos en la carpeta de ejemplos.

1. Basics
 BareMinimum: The bare minimum of code needed to start an Arduino sketch.
 Blink: Turn an LED on and off.
 DigitalReadSerial: Read a switch, print the state out to the Arduino Serial Monitor.
 AnalogReadSerial: Read a potentiometer, print its state out to the Arduino Serial Monitor.
 Fade: Demonstrates the use of analog output to fade an LED.
 ReadAnalogVoltage : Reads an analog input and prints the voltage to the serial monitor

Ing. Ronald N. Kopp Página 4

Arduino
1. BareMinimum: Cantidad mínima de comandos necesarios para iniciar un boceto (sketch) en
Arduino.

Este ejemplo contiene los comandos mínimos que se necesitan para hacer un boceto en Arduino y
para que éste pueda ser compilado: el comando setup () y el comando loop ().

Hardware Required
 Arduino Board

Circuit
Solo se necesita la placa Arduino para éste ejemplo.

Ing. Ronald N. Kopp Página 5

Arduino
Code
El comando setup() se coloca cuando se inicia un boceto. Lo usaremos para inicializar variables, estados
de los pines, comenzar a usar las bibliotecas, etc. El comando setup() sólo se ejecutará una vez, y esto
será, después de cada arranque o reinicio de la placa Arduino.

Nombre void setup()

Ejemplo void setup() {
pinMode(0, OUTPUT);
Serial.begin(9600);
}

void loop() {
Serial.print('.');
delay(1000);
}
Descripción La función es llamada una vez que el programa empieza a ser ejecutado. Suele definir
el ambiente inicial, tal como el estado de los pines (INPUT o OUTPUT), inicializar el
puerto serial, etc. Todo esto antes que loop() empiece a ejecutarse. Las variables
declaradas en setup() no son accesibles desde loop().
Sintaxis void setup() {
Declaraciones
}
Parámetros Declaraciones Cualquier declaración valida.

Después de realizar el comando setup(), el comando loop() hace precisamente lo que su nombre
sugiere, bucles de forma consecutiva, lo que permite al programa cambiar y responder mientras se
ejecuta. El comando loop() en el párrafo de nuestro boceto es utilizado para controlar activamente la
placa Arduino.

Nombre loop()
Ejemplo void setup() {
pinMode(0, OUTPUT);
}

void loop() {
digitalWrite(0, HIGH);
}
Descripción Continuamente ejecuta las líneas de código dentro de él bloqueándose cuando el
programa es detenido. La función loop() es usada en conjunción con setup(). El
número de veces que loop() se ejecuta por segundo puede ser controlada con las
funciones delay() y delay() y delayMicroseconds().
Sintaxis void loop() {
Declaraciones
}
Parámetros Declaraciones Una secuencia de declaraciones para ser ejecutados una y otra vez.

Ing. Ronald N. Kopp Página 6

Arduino
El código de abajo en realidad no hace nada, pero ésta estructura es útil para ser copiada y pegada, de
tal manera que podamos empezar cualquier boceto por nuestra cuenta. También muestra cómo hacer
comentarios de los comandos.

Cualquier línea que comienza con dos barras inclinadas (//) no será leído por el compilador, podremos
escribir lo que queramos después de ella. El comentar nuestro código puede ser particular mente útil
para explicar, tanto a nosotros mismo y a otros, cómo funciona nuestro programa paso a paso.

Nombre // Comentario en una sola línea

Ejemplo // Inicializa el pin 0 como OUTPUT
// Asigna el valor HIGH al pin 0
pinMode(0, OUTPUT); // Inicializa el pin 0 como OUTPUT
digitalWrite(0, HIGH); // Asigna el valor HIGH al pin 0
Descripción Notas explicitarías dentro del código. Los comentarios son usados para recordarse a
sí mismo y para informar a los demás acerca de una función en nuestro programa.
Comentarios de una sola línea son marcados con los caracteres //. Los comentarios
son ignorados por el compilador.
Sintaxis // Comentario
Parámetros Comentario Cualquier secuencia de caracteres.

void setup() {
// ponemos el código de configuración aquí, para que se ejecute una sola vez
}

void loop() {
// ponemos el código principal aquí, para que se ejecute repetidamente
}

Nombre /* */ comentario de múltiples líneas

Ejemplo /*
Cambia de HIGH a LOW un pin.
Alternando entre ellos
y esperando 100 milisegundos
entre cada alternación
*/
digitalWrite(8, HIGH);
delay(100);
digitalWrite(8, LOW);
Descripción Notas de explicación incrustadas en el código. Los comentarios son usados para
recordar e informar a otros acerca del funcionamiento de nuestro programa. Los
comentarios de múltiples líneas son usados para descripciones de textos largos o
para comentar partes del código. Mientras la aplicación este depurando los
comentarios son ignorados por el compilador.

Ing. Ronald N. Kopp Página 7

Arduino
Sintaxis /*
Comentarios
*/
Parámetros Comentarios Cualquier secuencia de caracteres.

Nombre {} llaves
Ejemplo int a[] = { 5, 20, 25, 45, 70 };
Descripción Define el inicio y fin del bloque de una función y de bloques de instrucciones de
estructuras como for() e for(). Los corchetes son también usados para definir los
valores iníciales en la declaración de un arreglo.
Sintaxis {Declaraciones}
{ele0, ..., eleN}
Parámetros Declaraciones Cualquier secuencia de instrucciones válida.
ele0, ..., eleN Lista de elementos separados por coma.

Ing. Ronald N. Kopp Página 8

Arduino
2. Blink: parpadear

Este ejemplo muestra la cosa más simple que podemos hacer con un Arduino, el destello de un LED.

Hardware Required
 ArduinoBoard
 LED

Circuit
Para construir el circuito, conectamos una resistencia de 220 ohmios al pin 13. A continuación,
conectamos la pata más larga de un LED (la pata positiva, llamada el ánodo) a la resistencia. Fijamos la
pata más corta (la pata negativa, llamado el cátodo) a tierra. A continuación, conectamos la placa
Arduino en el ordenador, iniciamos el programa de Arduino, e introducimos el código de abajo.

La mayoría de las placas Arduino ya tienen un LED conectado al pin 13 en la propia placa. Si ejecutamos
este ejemplo, sin el hardware conectado, deberíamos ver que el LED este intermitente.

Ing. Ronald N. Kopp Página 9

Arduino
Schematic

Ing. Ronald N. Kopp Página 10

Arduino
Code
En el siguiente programa, lo primero que hacemos es asignar al pin 13 como un pin de salida con la
línea:
pinMode(13, OUTPUT);

Nombre pinMode()
Ejemplo int inpin = 8;
int outpin = 9;
int val = 0;

void setup() {
pinMode(inpin, INPUT);
pinMode(outpin, OUTPUT);
}

void loop() {
val = digitalRead(inpin);
if (val == HIGH) {
digitalWrite(outpin, HIGH);
}
else {
digitalWrite(outpin, LOW);
}
}
Descripción El comando pinMode() designa al pin digital I/O especificado como INPUT o OUTPUT.
Un pin I/O digital o binaria puede tener dos posibles valores: HIGH o LOW. Es posible
asignar o leer el valor de un pin digital I/O usando los métodos digitalWrite() y
digitalRead().
Sintaxis pinMode(pin, VALOR)
Parámetros Pin Número del pin
VALOR INPUT o OUTPUT

En el bucle principal, encendemos el LED con la línea:

digitalWrite(13, HIGH);

Nombre digitalWrite()
Ejemplo int outpin = 0;

void setup() {
pinMode(outpin, OUTPUT);
}

void loop() {
digitalWrite(outpin, HIGH);
}

Ing. Ronald N. Kopp Página 11

Arduino
Descripción El comando digitalWrite() escribe un valor (o pone en un estado) a un pin digital. Los
valores o estados posibles son HIGH o LOW
Sintaxis digitalWrite(pin, VALOR);
Parámetros Pin int: el número del pin
VALOR HIGH o LOW

Esto suministra 5 voltios al pin 13 que creará una diferencia de voltaje a través de los terminales del
LED, y lo encenderá. Luego lo apagamos con la línea:
digitalWrite(13, LOW);

Para eso se necesita que el pin 13 vuelva a 0 voltios, y se vuelva a apagar el LED. Y entre el encendido
y el apagado, se requiere un tiempo suficiente para que una persona vea el cambio, por lo que el
comando delay() le dirá al Arduino que no haga nada durante 1000 milisegundos, o un segundo.

Nombre delay()
Ejemplo int pin = 0;
int ledpin = 1;

void setup() {
pinMode(pin, INPUT);
pinMode(ledpin, OUTPUT);
}

void loop() {
if (pin == HIGH) {
digitalWrite(ledpin, HIGH);
}
else {
digitalWrite(ledpin, LOW);
}
delay(250); // Detiene el programa por 250 milisegundos
}

Descripción Obliga al programa a detenerse por un tiempo especificado. El tiempo de demora es

especificado en milésimas de segundo. La llamada a la función delay(3000) detendrá
el programa por tres segundos. Alias de delayMiliseconds().
Sintaxis delay(Milisegundos)
Parámetros Milisegundos int: Especificado en milisegundos (hay 1000 milisegundos en 1
segundo)

Cuando se utiliza el comando delay(), no pasa nada más por esa cantidad de tiempo. Una vez que
hayamos entendido los ejemplos básicos, revisaremos el ejemplo BlinkWithoutDelay para aprender a
crear un retraso mientras se hace otras cosas.

delay = retraso

Ing. Ronald N. Kopp Página 12

Arduino

// el Pin 13 tiene un LED conectado en la mayoría de las placas Arduino.

// le damos un nombre:
int led = 13;

// la función setup se ejecuta solamente una vez

// cuando se presiona RESET o se enciende la placa:

void setup() {
pinMode(led, OUTPUT); // configuramos el pin digital como una salida.
}

void loop() { // la función loop se ejecutará una y otra vez por siempre

digitalWrite(led, HIGH); // enciende el LED (el nivel de tensión es un ALTO)

delay(1000); // esperar un segundo
digitalWrite(led, LOW); // apaga el LED haciendo el nivel de tensión un BAJO
delay(1000); // espera un segundo
}

Nombre int
Ejemplo int a; // Declara la variable "a" de tipo int

a = 23; // Asigna a "a" el valor 23

int b = -256; // Declara la variable "b" y le asigna el valor -256

int c = a + b; // Declara la variable "c" y le asigna la suma de "a" y "b"
Descripción Tipo de datos para enteros, números sin punto decimal. Los enteros pueden ser tan
grandes como 32.767 y tan pequeños como -32.768. Estos son almacenados como
16 bits de información.
Sintaxis int var
int var = valor
Parámetros var Nombre de la variable referenciado al valor.
valor Cualquier valor entero.

Nombre ; (punto y coma)

Ejemplo int a; // Declaración
a = 30; // Asignación de la declaración
Serial.print(a); // Función de la declaración

Ing. Ronald N. Kopp Página 13

Arduino
Descripción Es una declaración destructora que separa elementos en un programa. Una
declaración es una instrucción completa al computador y el punto y coma es usada
para separar instrucciones (es similar al punto "." al escribir en Español). Los punto
y coma son usados para separar diferentes elementos en una estructura for().
Sintaxis Declaración;
Parámetros Declaraciones Una simple declaración para ejecutar

Ing. Ronald N. Kopp Página 14

Arduino
3. Digital Read Serial: Lectura digital serial

Este ejemplo muestra cómo supervisar el estado de un interruptor mediante la comunicación serie,
entre el Arduino y el ordenador, a través del USB.

Hardware Required
 ArduinoBoard
 A momentary switch, button, or toggle switch
 10k ohm resistor
 breadboard
 hook-up wire

Circuit

Conectamos los tres cables a la placa Arduino. Los dos primeros, el rojo y el negro, se conectan a las
dos filas horizontales largas en el lado derecho del protoboard para facilitar el acceso a la alimentación
de 5 voltios y tierra. El tercer cable va desde pin digital 2 hasta una pata del pulsador. Esa misma pata
del pulsador se conecta a través de una resistencia pull-down (aquí 10K Ohms) a tierra. La otra pata
del pulsador se conecta a la alimentación de 5 voltios.

Los pulsadores o conmutadores conectan dos puntos en un circuito cuando se los presiona. Cuando el
pulsador está abierto (sin apretar) no hay ninguna conexión entre las dos patas del pulsador, por lo
que el pin está conectado a tierra (a través de la resistencia pull-down) y lee como BAJO, o 0. Cuando
se cierra el pulsador, se hace una conexión entre sus dos patas, conectando el pin a 5 voltios, de modo
que el pin lee como ALTO, o 1.

Si desconectamos el pin I/O digital del todo, el LED puede parpadear de forma errática. Esto se debe a
que la entrada es "flotante" es decir, que no tiene una conexión sólida a la tensión o a tierra, y cambiará
al azar a un estado, ya sea a un ALTO o a un BAJO. Es por eso que se necesita una resistencia pull-down
en el circuito.

Ing. Ronald N. Kopp Página 15

Arduino
Schematic

Ing. Ronald N. Kopp Página 16

Arduino
Code
En el programa a continuación, la primera cosa que haremos en la función setup será comenzar la
comunicación serie, en 9600 bits de datos por segundo, entre la placa Arduino y el ordenador con la
línea:
Serial.begin(9600);

Nombre Serial
Ejemplo int val;

void setup() {
Serial.begin(9600); // Inicializa el puerto serial en 9600 baud
}

void loop() {
if ( Serial.available() > 0 ) // Si los datos están disponibles para leer
{
val = Serial.read(); // los lee y los almacena en 'val'
}
analogWrite(0, val);
}
Descripción El puerto serial Serial de Wiring permite fácilmente leer o escribir datos hacia y desde
un dispositivo externo. Permite comunicar dos máquinas y da la flexibilidad de hacer
sus propios dispositivos y usarlos como entrada/salida de Wiring. El puerto serial es
un puerto de nueve pines que solía existir en la mayoría de las PCs y puede ser
emulado a través de un adaptador serial USB. El puerto Serial está disponible en los
pines 0(Rx) y 1(Tx). Las velocidades típicas son: 2400, 4800, 9600, 14400, 19200,
28800, 38400, 57600 y 115200 baudios.
Sintaxis Serial
Métodos begin() Abre el puerto serial para leer o escribir
read() Devuelve un número entre 0 y 255 para el siguiente byte esperado
por el buffer. Devuelve -1 si no hay ningún byte, aunque esto debería
ser evitado utilizando available() para ver si hay datos que estén
disponibles.
write() Escribe un byte en el puerto serial
print() Escribe datos (int, float, byte, char, char[], números en base (DEC,
BIN, OCT or HEX) o Strings en el puerto serial
println() Funciona como el método print pero imprime un carácter y hace un
salto de line cada vez que es llamada la función
available() Devuelve el número de bytes disponibles.
peek() Examina el siguiente byte que se encuentra disponible en el buffer
del puerto serial. Este método no saca el byte del buffer. Devuelve -
1 si no hay datos disponibles
flush() Vacía el buffer del puerto serial. Posteriormente se llama read() y
available() las cuales retornarán datos recibidos después del uso del
comando flush()
begin() Cierra el puerto serial

Ing. Ronald N. Kopp Página 17

Arduino

A continuación, configuramos el pin digital 2 (pushButton), como una entrada. Este pin leerá la señal
de entrada desde el pulsador del circuito:
pinMode(pushButton, INPUT);

Ahora que la configuración se ha completado, pasamos a configurar el bucle. Cuando se pulsa el

pulsador, 5 voltios fluirán libremente a través de nuestro circuito, y cuando no se presione, el pin de
entrada se conectará a tierra a través de la resistencia de 10 Kilo-ohmios. Esta es una entrada digital,
lo que significa que el pulsador sólo puede estar en un estado encendido (visto por el Arduino como
un "1", o ALTO) o en un estado de apagado (visto por el Arduino como un"0", o BAJO), sin nada en el
medio.

Lo primero que hay que hacer en el bucle principal del programa es establecer una variable para
contener la información que viene del pulsador. Dado que la información que viene del pulsador será
un "1" o un "0", se puede utilizar un tipo de dato int. Llamaremos a esta variable buttonState, y lo
configuramos a que sea igual a lo que se lee en el pin digital 2(pushButton) . Podemos lograr todo esto
con una sola línea de código:
int buttonState = digitalRead(pushButton);

Nombre digitalRead()
Ejemplo int inpin = 8;
int outpin = 9;
int val = 0;

void setup() {
pinMode(inpin, INPUT);
pinMode(outpin, OUTPUT);
}

void loop() {
val = digitalRead(inpin);
if (val == HIGH)
{
digitalWrite(outpin, HIGH);
} else {
digitalWrite(outpin, LOW);
}
}
Descripción Lee el estado (o valor) de un pin digital
Sintaxis digitalRead(Pin)
Parámetros Pin Int

Una vez que el Arduino ha leído la entrada, se debe hacer que imprima esta información a la
computadora como un valor decimal. Para hacer esto utilizamos el comando Serial.println() en nuestra
última línea de código:
Serial.println(buttonState);

Ing. Ronald N. Kopp Página 18

Arduino

Ahora, cuando se abra el monitor serial en el entorno Arduino, se verá una corriente de "0"s si su
interruptor está abierto, o "1"s si su interruptor está cerrado.

int pushButton = 2; // el Pin digital 2 tiene un pulsador unido a él. Le damos un nombre

void setup() {
Serial.begin(9600); // comenzamos la comunicación serial a 9600 baudios por segundo

pinMode(pushButton, INPUT); // inicializamos al pulsador como una entrada

void loop() {
int buttonState = digitalRead(pushButton); // leemos el pin de entrada

Serial.println(buttonState); // imprimimos el estado del botón

delay(1); // retraso entre las lectura para la estabilidad

}

Patas del usb

Ing. Ronald N. Kopp Página 19

Arduino

Ing. Ronald N. Kopp Página 20

Arduino
4. AnalogRead Serial: Lectura analógica serial

En este ejemplo se muestra cómo leer una entrada analógica del mundo físico mediante un
potenciómetro. Un potenciómetro es un dispositivo mecánico simple que proporciona una cantidad
variable de resistencia cuando su eje se gira. Con el paso de tensión a través de un potenciómetro y a
través de una entrada analógica del Arduino, es posible medir el valor de resistencia producida por un
potenciómetro (o un pot para abreviar) como un valor analógico. En este ejemplo nosotros queremos
monitorear el estado de nuestro potenciómetro estableciendo una comunicación serie entre el
Arduino y el ordenador.

Hardware Required
 ArduinoBoard
 10-kilohm Potentiometer

Circuit

Conectamos los tres cables del potenciómetro a la placa Arduino. La primera de las patas exteriores
del potenciómetro va a tierra. La otra pata exterior va a los 5 voltios. Y la pata del medio, va a la entrada
analógica 0.

Al girar el eje del potenciómetro, cambia la cantidad de resistencia a cada lado de las escobillas que
están conectados al terminal central del potenciómetro. Esto cambia el voltaje en el terminal central.
Cuando la resistencia entre el centro y el lado conectado a 5 voltios es cercana a cero (y la resistencia
en el otro lado es cerca de 10 kiloohmios), el voltaje en el terminal central se acerca a 5 voltios. Cuando
las resistencias se invierten, la tensión en el terminal central se acerca a 0 voltios, o tierra. Este voltaje
es el voltaje analógico que se está leyendo como una entrada.

Ing. Ronald N. Kopp Página 21

Arduino

El Arduino tiene un circuito en el interior llamado “convertidor analógico-digital” que lee éste cambio
de voltaje y lo convierte a un número entre 0 y 1023. Cuando el eje se gira todo el recorrido en una
dirección, hay 0 voltios que van al pin, y el valor de entrada es 0. Cuando el eje se gira todo el recorrido
en la dirección opuesta, hay 5 voltios que van al pin y el valor de entrada es 1023. En el medio,
analogRead(A0) devuelve un número entre 0 y 1023 que es proporcional a la cantidad de voltaje que
se aplica al pin.

Ing. Ronald N. Kopp Página 22

Arduino
Schematic

Ing. Ronald N. Kopp Página 23

Arduino
Code
En el siguiente programa, lo primero que haremos en la función de configuración, es comenzar la
comunicación serie, en 9600 bits de datos por segundo, entre el Arduino y el ordenador con el
comando:
Serial.begin(9600);

A continuación, en el bucle principal de nuestro código, es necesario establecer una variable para
almacenar el valor de la resistencia (que estará entre 0 y 1023, perfecto par un tipo de dato entero)
que viene desde nuestro potenciómetro:
int sensorValue = analogRead(A0);

Nombre analogRead()
Ejemplo int inpin = 0;
int val = 0;

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

void loop() {
val = analogRead(inpin); // lee el valor de entrada del pin análogo 0
Serial.println(val); // escribe el valor al puerto serial
}
Descripción El comando analogRead()lee el valor de un pin análogo. Los valores posibles están
en el rango 0-1023, donde 0 es 0 voltios y 1023 es 5 voltios.
Sintaxis analogRead(Pin)
Parámetro Pin Int: número del pin análogo que se quiere leer

Por último, es necesario imprimir esta información para que el monitor serial lo muestre como un valor
decimal(DEC). Nosotros haremos esto con el comando Serial.println() con la línea de código:
Serial.println(sensorValue);

Ahora, cuando se abre el monitor de serial en el entorno de desarrollo Arduino, debería verse un flujo
constante de números que van desde 0 hasta 1023, en correlación con la posición del potenciómetro.
A medida que gira el potenciómetro, estas cifras responden casi al instante.

void setup() {
Serial.begin(9600); // comienza la comunicación serial a 9600 baudios por segundo
}

void loop() {

int sensorValue = analogRead(A0); // leemos el valor de entrada del pin analógico 0:

Ing. Ronald N. Kopp Página 24

Arduino

Serial.println(sensorValue); // imprimimos el valor que se lee

delay(1); // Retraso entre las lectura para la estabilidad

// (el punto y coma cierra la sentencia)
}

Ing. Ronald N. Kopp Página 25

Arduino

Ing. Ronald N. Kopp Página 26

Arduino
5. Fading : disminución temporal de la intensidad de las señales radio eléctricas.

Este ejemplo de muestra el uso de la función analogWrite() en la decoloración de un LED apagándolo

y encendiéndolo. analogWrite() utiliza la modulación mediante pulsos (PWM), incrementando o
atenuando la señal de salida mediante pequeños intervalos, para crear un efecto de iluminación o
atenuación.

Hardware Required
 Arduinoboard
 Breadboard
 a LED
 a 220 ohm resistor

Circuit
Conectamos el ánodo (la pata más larga, positivo) de nuestro LED al pin de salida digital 9 en nuestro
Arduino a través de una resistencia de 220 ohmios. Y Conectamos el cátodo (la pata más corta,
negativo) directamente a tierra.

Ing. Ronald N. Kopp Página 27

Arduino
Schematic

Ing. Ronald N. Kopp Página 28

Arduino
Code
Después de configurar el pin 9 como una salida, no hay nada más que hacer en el comando setup() de
nuestro código.
pinMode(led, OUTPUT);

La función analogWrite() que se va a utilizar en el bucle principal de nuestro código requiere dos
argumentos: Aquel que le diga a la función en que pin va a escribir, y uno que le indique cuál es el valor
de PWM que debe escribir.
analogWrite(led, brightness);

Nombre analogWrite()
Ejemplo int outpin = 29;
int val = 0;

void setup() {
}

void loop() {
analogWrite(outpin, val); // escribe un valor en el pin 29 PWM
val = (val + 10) % 255; // incrementa el valor
// y lo mantiene en el rango 0-255
}
Descripción El comando analogWrite() asigna un valor en el pin de salida PWM. Los valores
posibles por defecto están en el rango de 0-255. Usar analogWrite() en un pin sin
capacidad PWM hace que el pin sea colocado en HIGH sin ningún otro efecto.
Sintaxis analogWrite(Pin, Valor)
Parámetro Pin Int: el número del pin de salida PWM
Valor Int: un valor en el rango de 0 - 255

Con el fin de atenuar el LED apagándolo y encendiéndolo, aumentamos gradualmente su valor PWM
de 0 (completamente apagado) a 255 (completamente encendidos) y, a continuación, de nuevo a 0
una vez más para completar el ciclo. En el boceto de abajo, el valor PWM se ajusta mediante una
variable llamada brightness. Cada vez que pasa a través del bucle, aumenta el valor de la variable en
fadeAmount.
brightness = brightness + fadeAmount;
int fadeAmount = 5

Si el brillo llega a los extremos en cualquiera de sus valores (0 ó 255), entonces fadeAmount se cambia
a negativo. En otras palabras, si fadeAmount es 5, cuando brightness llegue a 255 fadeAmountse se
establecerá en -5. Esto hará que vaya disminuyendo la intensidad en escalones de 5, hasta llegar a 0.
Al llegar a este valor fadeAmount cambiará nuevamente de -5 a 5 y esto hará que vaya aumentando
en escalones de 5 hasta llegar a 255. Como vemos el brillo no solo cambia de atenuación sino también
de dirección.
if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount;

Ing. Ronald N. Kopp Página 29

Arduino

Nombre if ()
Ejemplo true || false // Evalúa verdadero porque el primero es verdadero
false || true // Evalúa verdadero porque el segundo es verdadero
true || true // Evalúa verdadero porque ambas son verdaderas
false || false // Evalúa falso porque ambas son falso
Descripción Permite al programa tomar una decisión sobre que bloque de código ejecutar. Si la
expresión evalúa true, las instrucciones encerradas en bloque son ejecutadas y si la
expresión evalúa false las instrucciones no son ejecutada
Sintaxis if (Expresión) {
Declaraciones
}
Parámetro Expresión Cualquier expresión que evalúe true o false
Declaración Una o más instrucciones para ser ejecutadas

Nombre == (equality)
Ejemplo int a = 23;
int b = 23;
if (a == b) {
Serial.print("las variables a y b son iguales");
}
Descripción Determina si dos valores son equivalentes. El operador de igualdad es diferente del
operador de asignación
Sintaxis Valor1 == Valor2
Parámetro Valor1 int, float, char, byte, boolean
Valor2 int, float, char, byte, boolean

Nombre || (lógica OR)

Ejemplo true || false // Evalúa verdadero porque el primero es verdadero
false || true // Evalúa verdadero porque el segundo es verdadero
true || true // Evalúa verdadero porque ambas son verdaderas
false || false // Evalúa falso porque ambas son falso
Descripción Permite al programa tomar una decisión sobre que bloque de código ejecutar. Si la
expresión evalúa true, las instrucciones encerradas en bloque son ejecutadas y si la
expresión evalúa false las instrucciones no son ejecutada
Sintaxis Expresión1 || Expresión2
Parámetro Expresión 1 Cualquier expresión válida
Expresión 2 Cualquier expresión válida

Amount = valor/cantidad/monto

Ing. Ronald N. Kopp Página 30

Arduino
analogWrite() permite cambiar el valor PWM muy fácilmente, porque el retraso delay() al final del
boceto controla la velocidad de atenuación (fade). Intentemos cambiar el valor de demora delay() y
ver cómo cambia el programa.
delay(30);

int led = 9; // el pin al LED está conectado

int brightness = 0; // lo brillante que esta el LED
int fadeAmount = 5; // cuantos escalones se desvanecerá el LED por vez

void setup() {
pinMode(led, OUTPUT); // inicializamos el pin 9 como una salida
}

void loop() {
analogWrite(led, brightness); // escribimos el valor de la variable brightness en el pin 9

brightness = brightness + fadeAmount; // cambiamos el brillo para la próxima vez que

// se recorra el bucle:

if (brightness == 0 || brightness == 255) { // invertimos la dirección de la decoloración

fadeAmount = -fadeAmount; // en los extremos de la atenuación
}
delay(30); // Esperarnos 30 milisegundos para ver el efecto de atenuación
}

Ing. Ronald N. Kopp Página 31

Arduino
6. Analog Read Voltage: lectura analógica de tensión

En este ejemplo se muestra cómo leer una entrada analógica desde el pin 0, convertir los valores de
analogRead() en tensión, e imprimirlo en el monitor serial.

Hardware Required
 ArduinoBoard
 a variable resistor, like a potentiometer

Circuit

Conectamos los tres cables del potenciómetro a la placa Arduino. La primera de las patas exteriores
del potenciómetro va a tierra. La otra pata exterior va a los 5 voltios. Y la pata del medio, va a la entrada
analógica A0.

Al girar el eje del potenciómetro, cambia la cantidad de resistencia a cada lado de la escobilla que está
conectado al terminal central del potenciómetro. Esto cambia el voltaje en el terminal central. Cuando
la resistencia entre el centro y el lado conectado a 5 voltios es cercana a cero (y la resistencia en el
otro lado está cerca de 10 kiloohmios), el voltaje en el terminal central se acerca a 5 voltios. Cuando
las resistencias se invierten, la tensión en el terminal central se acerca a 0 voltios, o tierra. Este voltaje
es el voltaje analógico que se está leyendo como una entrada.

El Arduino tiene un circuito en el interior llamado “convertidor analógico-digital” que lee este cambio
voltaje y lo convierte a un número entre 0 y 1023. Cuando el eje gira todo el recorrido en una dirección,
hay 0 voltios que van al pin 0, y el valor de entrada es 0. Cuando el eje gira todo el recorrido en la
dirección opuesta, hay 5 voltios que van al pin 0 y el valor de entrada es 1023. En el medio,

Ing. Ronald N. Kopp Página 32

Arduino
analogRead() devuelve un número entre 0 y 1023 que es proporcional a la cantidad de voltaje que se
aplica al pin.

Schematic

Code
En el siguiente programa, lo único que haremos en la función de configuración, es comenzar la
comunicación serial, en 9600 bits de datos por segundo, entre el Arduino y el ordenador con el
comando:
Serial.begin(9600);

A continuación, en el bucle principal de nuestro código, es necesario establecer una variable para
almacenar el valor de la resistencia (que estará entre 0 y 1023, perfecto para un tipo de dato entero)
que viene desde nuestro potenciómetro:
int sensorValue = analogRead;

Ing. Ronald N. Kopp Página 33

Arduino

Para cambiar los valores de 0 a 1023 en un rango que corresponda a la tensión que la clavija está
leyendo, tendremos que crear otra variable, un float, y hacer un poco de matemáticas. Para crear un
factor de escala entre 0,0 y 5,0, dividimos 5,0 por 1023,0 y luego lo multiplicamos por sensorValue:
float voltage = sensorValue * (5.0 / 1023.0);

Nombre float
Ejemplo float a; // Declara la variable "a" de tipo float
a = 1.5387; // Asigna a "a" el valor 1.5387
float b = -2.984; // Declara la variable "b" y le asigna el valor -2.984
float c = a + b; // Declara la variable "c" y le asigna la suma de "a" y "b"
Descripción Tipo de datos para números de punto flotante, un número que tiene un punto
decimal. Los números de punto flotante son usados frecuentemente para aproximar
valores análogos y continuos porque tienen más resolución que los enteros. Los
números de tipo float pueden ser tan grandes como 3.4028235E+38 y tan pequeños
como -3.4028235E+38. Estos son almacenados como 32 bits (4 bytes) de
información
Sintaxis float Var
float Var = Valor
Parámetro Var Nombre de variable referenciada al número de punto flotante
Valor cualquier valor de punto flotante

Por último, es necesario imprimir esta información para que el monitor serial lo muestre como un valor
decimal (DEC). Nosotros haremos esto con el comando Serial.println() con la línea de código:
Serial.println(voltage);

Ahora, cuando abrimos el monitor serial en el entorno Arduino, deberíamos ver un flujo constante de
números que van desde 0,0 hasta 5,0. A medida que se gira el potenciómetro, esto corresponderá a la
tensión de entrada en el pin A0.

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

void loop() {
int sensorValue = analogRead(A0); // leemos la entrada del pin analógico 0
// y lo almacenamos en la variable sensorValue
// convertirmos la lectura analógica (que va desde 0 hasta 1023) en un voltaje (0 - 5V):
float voltage = sensorValue * (5.0 / 1023.0); // convertirnos la lectura analógica
// (que va desde 0 hasta 1023) en un voltaje (0 - 5V)

Serial.println(voltage); // imprimimos el valor que se lee

}

Ing. Ronald N. Kopp Página 34

Arduino

Ing. Ronald N. Kopp Página 35