Arduino en español

¿QUE ES ARDUINO?
Arduino es una plataforma de prototipos electrónica de código abierto
(open-source) basada en hardware y software flexibles y fácil de usar. Está
pensado para artistas, diseñadores, como hobby y para cualquiera
interesado en crear objetos o entornos interactivos.
Arduino puede sentir el entorno mediante la recepción de entradas desde
una variedad de sensores y puede afectar a su alrededor mediante el
control de luces, motores y otros artefactos. El microcontrolador de la
placa se programa usando el Arduino Programming
Language (basado en Wiring) y el Arduino Development
Environment (basado en Processing).
Los proyectos de Arduino pueden ser autónomos o se pueden comunicar
con software en ejecución en un ordenador (por ejemplo con Flash,
Processing, MaxMSP, etc.).
Las placas se pueden ensamblar a mano o encargarlas preensambladas;
el software se puede descargar gratuitamente. Los diseños de referencia
del hardware (archivos CAD) están disponibles bajo licencia open-source,
por lo que eres libre de adaptarlas a tus necesidades.
Arduino recibió una mención honorífica en la sección Digital
Communities del Ars Electrónica Prix en 2006.

¿Por qué Arduino?

Hay muchos otros microcontroladores y plataformas microcontroladoras
disponibles para computación física. Parallax Basic Stamp, Netmedia’s
BX-24, Phidgets, MIT’s Handyboard, y muchas otras ofertas de
funcionalidad similar. Todas estas herramientas toman los desordenados
detalles de la programación de microcontrolador y la encierran en un
paquete fácil de usar. Arduino también simplifica el proceso de trabajo con
microcontroladores, pero ofrece algunas ventajas para profesores,
estudiantes y a aficionados interesados sobre otros sistemas:
 Barato: Las placas Arduino son relativamente baratas comparadas
con otras plataformas microcontroladoras. La versión menos cara
del modulo Arduino puede ser ensamblada a mano, e incluso los
módulos de Arduino preensamblados cuestan menos de 50$.

1
  Multiplataforma: El software de Arduino se ejecuta en sistemas
operativos Windows, Macintosh OSX y GNU/Linux. La mayoría de
los sistemas microcontroladores están limitados a Windows.
 Entorno de programación simple y claro: El entorno de
programación de Arduino es fácil de usar para principiantes, pero
suficientemente flexible para que usuarios avanzados
puedan aprovecharlo también. Para profesores, está
convenientemente basado en el entorno de programación
Processing, de manera que estudiantes que estan aprendiendo a
programar en ese entorno estarán familiarizados con el aspecto y la
imagen de Arduino.
 Código abierto y software extensible: El software Arduino está
publicado como herramientas de código abierto, disponible para
extensión por programadores experimentados. El lenguaje puede
ser expandido mediante librerias C++, y la gente que quiera
entender los detalles técnicos pueden hacer el salto desde Arduino
a la programación en lenguaje AVR C en el cual está basado. De
forma similar, puedes añadir código AVR-C directamente en
tus programas Arduino si quieres.
 Código abierto y hardware extensible: El Arduino está basado en
microcontroladores ATMEGA8 y ATMEGA168 de Atmel. Los planos
para los módulos están publicados bajo licencia Creative Commons,
por lo que diseñadores experimentados de circuitos pueden
hacer su propia versión del módulo, extendiéndolo y mejorándolo.
Incluso usuarios relativamente inexpertos pueden construir la
versión de la placa del módulo para entender como funciona y
ahorrar dinero.

MODELOS DE ARDUINO

ARDUINO UNO R3

2
Este es el nuevo Arduino Uno R3, utiliza el microcontrolador ATmega328.
En adición a todas las características de las tarjetas anteriores, el Arduino
Uno utiliza el ATmega16U2 para el manejo de USB en lugar del 8U2 (o del
FTDI encontrado en generaciones previas). Esto permite ratios de
transferencia más rápidos y más memoria. No se necesitan drivers para
Linux o Mac (el archivo inf para Windows es necesario y está incluido en
el IDE de Arduino).
La tarjeta Arduino Uno R3 incluso añade pins SDA y SCL cercanos al pin
AREF. Es más, hay dos nuevos pines cerca del pin RESET. Uno es el
IOREF, que permite a los shields adaptarse al voltaje brindado por la
tarjeta. El otro pin no se encuentra conectado y está reservado para
propósitos futuros. La tarjeta trabaja con todos los shields existentes y
podrá adaptarse con los nuevos shields utilizando esos pines adicionales.
El Arduino es una plataforma computacional física open-source basada en
una simple tarjeta de I/O y un entorno de desarrollo que implementa el
lenguaje Processing/Wiring. El Arduino Uno R3 puede ser utilizado para
desarrollar objetos interactivos o puede ser conectado a software de tu
computadora (por ejemplo, Flash, Processing, MaxMSP). El IDE open-
source puede ser descargado gratuitamente (actualmente para Mac OS X,
Windows y Linux).
Nota: Esta plataforma requiere la carpeta de drivers Arduino 1.0 para
poder instalarlo de forma apropiada en algunos computadores. Hemos
probado y confirmado que el Arduino Uno R3 puede ser programado en
versiones anteriores del IDE. Sin embargo, la primera vez que uses el
Arduino en una nueva computadora deberás tener el Arduino 1.0 instalado
en la máquina. Si estás interesado en leer más acerca de los cambios en
el IDE, revisa las notas oficiales de Arduino 1.0.

3
Características:
 Microcontrolador ATmega328.
 Voltaje de entrada 7-12 V.
 14 pines digitales de I/O (6 salidas PWM). 6 entradas analógicas.
 32 KB de memoria Flash.
 Reloj de 16 MHz de velocidad.

ARDUINO MEGA 2560 R3

El Arduino Mega está basado en el microcontrolador ATMega2560. Tiene

54 pines de entradas/salidas digitales (14 de las cuales pueden ser
utilizadas como salidas PWM), 16 entradas analógicas, 4 UARTs (puertos
serie por hardware), cristal oscilador de 16 Mhz, conexión USB, jack de
alimentación, conector ICSP y botón de reset. Incorpora todo lo necesario
para que el microcontrolador trabaje; simplemente conectalo a tu PC por
medio de un cable USB o con una fuente de alimentación externa. El
Arduino Mega es compatible con la mayoría de los shields diseñados para
Arduino Duemilanove, Diecimila o UNO.
Esta nueva versión de Arduino Mega 2560 además de todas las
características de su sucesor, el Arduino Mega ahora utiliza un
microcontrolador ATMega8U2 en vez del chip FTDI. Esto permite mayores
velocidades de transmisión por su puerto USB y no requiere drivers para
Linux o MAC (archivo inf es necesario para Windows) además ahora
cuenta con la capacidad de ser reconocido por el PC como un teclado,
mouse, joystick, etc.

4
Características:
 Microcontrolador ATmega2560.
 Voltage de entrada de – 7-12 V. 54 pines digitales de Entrada/Salida
(14 de ellos son salidas PWM).
 16 entradas analógicas.
 256 KB de memoria flash.
 Velocidad del reloj de 16 Mhz

ARDUINO LEONARDO

El Leonardo es la primera placa de desarrollo de Arduino que utiliza un

microcontrolador con USB incorporado. Usando el ATmega32U4 como su
único microcontrolador permite que sea más barato y más simple.
También, debido a que el 32U4 está manejando el USB directamente,
estan disponibles bibliotecas de código que permiten a la placa emular un
teclado de computadora, ratón, y más usando el protocolo USB HID!
Tiene 20 pines digitales de entrada / salida (de los cuales 7 puede utilizarse
para salidas PWM y 12 entradas como analógicas), un oscilador de 16
5
MHz, una conexión micro USB, un conector de alimentación, un conector
ICSP, y un botón de reinicio. Contiene todo lo necesario para apoyar el
microcontrolador; basta con conectarlo a un ordenador con un cable USB,
adaptador AC a DC o batería para empezar.

Características:
 Microcontrolador ATmega32u4.
 Voltaje de entrada: 7-12 V.
 20 Pines digitales I/O.
 7 canales PWM. 12 ADCs.
 Velocidad de reloj 16 MHz.
 32 KB de memoria Flash.

ARDUINO DUE

El Arduino Due es la primera placa de desarrollo de Arduino basado en

ARM. Esta placa esta basada en un potente microcontrolador ARM
CortexM3 de 32 bits, programable mediante el familiar IDE de Arduino.
Aumenta la potencia de cálculo disponible para los usuarios de Arduino
manteniendo el lenguaje lo mas compatible posible para que muchos
programas puedan migrar en cuestión de minutos.
El Arduino Due dispone de 54 pines digitales de entrada / salida (de los
cuales 12 pueden utilizarse para salidas PWM), 12 entradas analógicas, 4

6
UARTs (puertos serie), un reloj de 84 MHz, una conexión USB OTG, 2
DAC (convertidor digital a analógico), 2 TWI, un conector de alimentación,
un cabezal SPI, un conector JTAG, un botón de reinicio y un botón de
borrado. También hay algunas características interesantes como DACs,
Audio, DMA, una biblioteca multitarea experimental y más.
Para compilar el código para el procesador ARM, necesitarás la última
versión del IDE de Arduino: v1.5 (Después de un período de prueba y
depuración, este reemplazará al 1.0.1 IDE al completo)
Debido a las limitaciones de tensión del sistema impuesto por el Atmel
SAM3X8E, los shields de Arduino basados en los modelos de 5 V no
funcionarán correctamente. Todos los shields que implementen
plenamente la disposición Arduino R3 son compatibles directamente
(como el Arduino WiFi y Ethernet Shield), pero otros shields podrían no ser
compatibles. Tenga cuidado cuando este enchufando cosas!
Nota: A diferencia de otras placas Arduino, la placa Arduino Due funciona
a 3.3 V. El voltaje máximo que los pines de I/O pueden tolerar es 3.3 V.
Proporcionar voltajes más altos, como 5 V a un pin I/O podría dañar la
placa.

Características:
 Microcontrolador: AT91SAM3X8E
 Voltaje de operación: 3.3 V
 Voltaje de entrada recomendado: 7-12 V
 Voltaje de entrada min/max: 6-20 V
 Digital I/O Pins: 54 (de los cuales 12 son salida PWM)
 Pines de entrada analógica: 12
 Pines de salida analógica: 2
 Corriente total de salida DC en todas las lineas I/O: 130 mA
 Corriente DC para el Pin de 3.3 V: 800 mA
 Corriente DC para el Pin de 5 V: 800 mA
 Memoria Flash: 512 KB disponibles para aplicaciones del usuario
SRAM: 96 KB (dos bancos: 64KB y 32KB)
 Velocidad del reloj: 84 MHz

7
ARDUINO YÚN

El Arduino YÚN es el primer miembro de una nueva familia de Arduinos

que combina el poder de Linux con la facilidad de uso de las placas
Arduino.
El Arduino YÚN es la combinación de un Arduino Leonardo (basado en el
procesador Atmega32U4) con un chip interno de Wifi ejecutandose Linino
(una distribución GNU/Linux basada en OpenWRT). La máquina Linux
está embebida en el PCB de Arduino Leonardo y ambos están
comunicados, por lo que es muy fácil ejecutar comandos Arduino desde
Linux y utilizar las interfaces Ethernet y Wifi.
Históricamente, la interfaz Arduino con servicios web complejos ha sido
todo un reto debido a limitada cantidad de memoria disponible. Los
servicios Web suelen utilizar formatos basados en texto como XML que
requieren bastante memoria RAM para poder analizarlos. En Arduino Yun
hemos creado una biblioteca llamada bridge, que delega todas las
conexiones y el procesamiento de las transacciones de red HTTP en la
máquina Linux incluida en la tarjeta.
Para hacer aún más sencilla la creación de aplicaciones complejas, el
Arduino Yun viene cargado con la potencia de Temboo, una startup
innovadora que proporciona un acceso normalizado a 100 + APIs, bases
de datos y servicios de código a partir de un único punto de contacto,
permitiendo a los desarrolladores mezclar y combinar los datos

8
procedentes de múltiples plataformas (por ejemplo, Facebook,
Foursquare, Dropbox e incluso FedEx y PayPal).
La YUN se puede programar con un cable USB de la forma Arduino clásica
o através de la conexión Wi-Fi sin necesidad de conectarse físicamente.
El nuevo IDE Arduino 1.5.4 tiene la capacidad de detectar cualquier
Arduino Yun conectado a la red local. Al hacer click en el nombre de la
tarjeta y la introducción de una contraseña es todo lo que se necesita para
programar una YUN.

Especificaciones Técnicas:
 Microcontrolador ATmega32u4
 Tensión de trabajo 5 V<
 Tensión de entrada (recomendada) 5 V via microUSB o PoE 802.3af
 Tensión de entrada (limites) 6-20 V
 Pines Digitales I/O 14
 Canales PWM 7>
 Canales de entrada analógica 6 (más 6 multiplexados en 6 pines
digitales)
 Corriente DC por pin I/O 40 mA
 Corriente DC por pin a 3.3 V 50 mA
 Memoria Flash 32 KB (ATmega32u4) de los cuales 4 KB se usan
para el bootloader
 SRAM 2.5 KB (ATmega32u4)
 EEPROM 1 KB (ATmega32u4)
 Velocidad del reloj 16 MHz
 MIPS 24K trabajando el microprocesador a 400 MHz
 DDR2 64 MB de RAM y 6 MB SPI Flash
 Completa IEEE 802.11bgn 1×1 AP o router
 Dispositivo host USB 2.0 poE compatible 802.3af
 Soporte para tarjeta MicroSD

9
ARDUINO PRO MINI 328, 5 V, 16 MHz

¡Es azul! Es delgado (0,8 mm)! Es el Arduino Pro Mini !. Se trata de un

Arduino a 5 V que ejecuta el gestor de arranque a 16 MHz. Arduino Pro
Mini no viene provisto de conectores para que pueda soldar un cable en
cualquier conector con cualquier orientación que necesita.
Recomendamos a los usuarios que comienzan con Arduino que usen el
Duemilanove. Es una gran placa que lo llevará a trabajar rápidamente. La
serie Pro Arduino está destinada a los usuarios que entienden las
limitaciones de tensión del sistema (5 V), la falta de conectores USB, etc.
Realmente queríamos para reducir al mínimo el costo de un Arduino. La
Arduino Pro Mini es como el Arduino Mini (los mismos pines), pero para
mantener el bajo costo, utilizamos todos los componentes SMD, circuito
impreso de dos capas, etc. Esta placa se conecta directamente a la placa
base FTDI Breakout y soporta auto-reset. La Arduino Pro Mini también
funciona con el cable FTDI pero el cable FTDI no llevar a cabo el pin DTR
por lo que la función de auto-reset no funcionará.

Caracteristicas:
 ATmega328 funcionando a 16 MHz con resonador externo (0,5% de
tolerancia)
 Conexión USB de placa
 Soporta auto-reset

10
  Regulador de 5V Salida máxima de 150 mA
 Protección contra sobreintensidad
 Protegido contra inversión de polaridad
 Entrada de CC 5 V hasta 12 V
 LEDs de presencia de tensión y de estado

ARDUINO PRO MINI 328, 3.3 V, 8 MHz

¡Es azul! Es delgado (0,8 mm)! Es el Arduino Pro Mini !. Se trata de un

Arduino a 3,3V. No viene provisto de conectores para que puedas soldar
un cable en cualquier conector con cualquier orientación que necesites.
La serie Pro Arduino está destinada a los usuarios que entienden las
limitaciones de tensión del sistema (3.3 V), la falta de conectores USB, etc.
La Arduino Pro Mini es como el Arduino Mini (los mismos pines), pero para
mantener el bajo costo, utilizamos todos los componentes SMD, circuito
impreso de dos capas, etc. Esta placa se conecta directamente a la placa

11
base FTDI Breakout y soporta auto-reset. La Arduino Pro Mini también
funciona con el cable FTDI pero el cable FTDI no lleva incorporado el pin
DTR por lo que la función de auto-reset no funcionará.

Caracteristicas:
 ATmega328 funcionando a 8 MHz con resonador externo (0,5% de
tolerancia)
 La baja tensión de alimentación hace inecesario cualquier interface
para dispositivos que trabajan a 3.3 V (GPS, acelerómetros,
sensores, etc).
 Conexión USB externa a la placa
 Soporta auto-reset
 Regulador de 3.3 V
 Salida máxima de 150 mA
 Protección contra sobreintensidad
 Protegido contra inversión de polaridad
 Entrada de CC 3.3 V hasta 12 V
 LEDs de presencia de tensión y de estado

Dimensiones:
 0.7×1.3″ (18x33mm)
 Peso menor de 2 gramos

12
ARDUINO ETHERNET

Tarjeta única que integra el ATMEGA328, el microcontrolador Arduino Uno

con el Arduino Ethernet Shield. Tiene 14 pines de entradas/salidas
digitales, 6 salidas analógicas, un oscilador de 16 MHz de cristal, una
conexión RJ45, un conector Jack, un cabezal ICSP y un botón reset.

Nota: Los pines 10, 11, 12 y 13 se reservan para hacer interface con el
módulo Ethernet y no deberían ser usados para otra cosa. Esto reduce el
número de pines disponibles a 9, con 4 disponibles para salida PWM.
También podría añadirse un módulo Power over Ethernet (PoE) a esta
tarjeta.
El Ethernet difiere de otras tarjetas en que no tiene un chip driver USB a
serie incorporado, pero tiene una interface Wiznet Ethernet. Esta es la
misma interface encontrada en los dispositivos Ethernet Shield.
Incorpora un lector de tarjetas microSD, que puede ser usado para guardar
archivos que sirvan en la red, accesibles a través de la librería SD. El pin
10 está reservado para la interface Wiznet. El SS para la tarjeta SD está
en el pin 4.
El pin 6 para el cabezal de programación serie es compatible con el cable
USB FTDI o con las tarjetas USB a serie FTDI-style básica. Incluye soporte
para reseteo automático, permite que los códigos sean subidos sin

13
presionar el botón de reset de la tarjeta. Cuando se conecta a un adaptador
USB a serie, el Arduino Ethernet es alimentado desde el adaptador.

Características:
 Microcontrolador: ATmega328.
 Voltaje de operación: 5 V.
 Voltaje de salida de conexión (recomendada): 7-12 V.
 Voltaje de salida de conexión (límites): 6-20 V.
 Pines de entrada/salida digitales: 14 (4 de los cuales proveen salida
de PWM).

Pines Arduino reservados:

 10 a 13 usados para SPI.
 4 usados para tarjeta SD.
 2 de interrupción W 5100 (cuando está en puente).
 Pines de salida analógicos: 6.
 Corriente DC por cada pin de entrada/salida: 40 mA.
 Corriente DC para pines de 3.3 V: 50mA.
 Memoria flash: 32Kb (ATmega328) de os cuales 0.5 Kb son usados
por el gestor de arranque.
 SRAM: 2 Kb (ATmega328).
 EEPROM: 1 Kb (ATmega328).
 Velocidad de reloj: 16 MHz.
 Controlador Ethernet integrado W 5100 TCP/IP.
 Tarjeta Micro SD, con transistores de voltaje activos.

Alimentación:

La alimentación externa puede venir desde un adaptador AC a DC (wall-

wart) o de una batería. El adaptador puede ser conectado uniendo un
conector de 2.1 mm de centro positivo al conector de alimentación Jack de

14
tu tarjeta. Los conectores de la batería pueden ser insertados en los
terminales GND y Vin del conector POWER.
La tarjeta puede operar con un suministro externo de 6 a 20 volts. Si se
suministra menos de 7 V, el pin de 5 V puede proporcionar menos de cinco
volts y la tarjeta puede funcionar inestablemente. Si se usan más de 12 V,
el regulador de voltaje se puede calentar y dañar la tarjeta. El rango
recomendado es de 7 a 12 volts.

Los pines de alimentación son los siguientes:

VIN. La entrada de voltaje de la tarjeta Arduino cuando se esta usando una
fuente de energía externa (opuesto a los 5 V desde la conexión USB u otra
fuente de energía regulada. Puedes darle tensión a través de este pin o,
si suministras voltaje vía conector Jack, puedes acceder a él por este pin).
5 V. Este pin proporciona una salida regulada de 5 V desde el regulador
incorporado en la tarjeta. La tarjeta puede tomar tensión desde el conector
Jack de energía DC (7-12 V), el conector USB (5 V) o el pin WIN de la
tarjeta (7-12 V). Tomar energía a través de los pines de 5 V o el de 3.3 V
no sigue la conexión del regulador y puede dañar tu tarjeta. No lo
recomendamos.
3.3 V. Suministro de 3.3 volts generado por el regulador incorporado. La
corriente máxima generada es de 50mA.
GND. Pines de tierra.
El módulo opcional PoE es diseñado para extraer energía desde un cable
Ethernet categoría 5 de par trenzado:
 Certificado por la IEEE802.3af.
 Baja salida de ruido y onda (100 mVpp).
 Rango de entrada de voltaje de 36 V a 57 V.
 Protección de sobrecarga y cortocircuito.
 Salida de 9 V.
 Convertidor DC/DC de alta eficiencia: tipo 75% @ 50% de carga.
 Aislamiento de 1500 V (entrada a salida).

Memoria:

15
El ATmega328 tiene 32 KB (con 0.5 KB usados por el gestor de arranque).
También tiene 2 KB de SRAM y 1 KB de EEPROM (que se puede leer y
escribir con la librería EEPROM).

Entrada y salida:
Cada uno de los 14 pines digitales de la tarjeta Ethernet pueden ser
utilizados como salida o entrada, usando las
funciones pinMode(), digitalWrite() y digitalRead(). Operan a 5 V. Cada
pin puede proveer o recibir un máximo de 40 mA y tiene un resistor pull-up
interno (desconectado por defecto) de 20-50 kOhms. Adicionalmente,
algunos pines tienen funciones especializadas
 Serie: 0 (RX) y 1 (TX). Usado para recibir (RX) y transmitir (TX)
datos serie a nivel TTL.
 Interrupciones externas 2 y 3. Estos pines pueden ser
configurados para disparar una interrupción con un nivel de valor
bajo, un flanco de subida o bajada o un cambio de valor. Ver la
función attachInterrupt() para mas detalles.
 PWM: 3,5,6,9 y 10. Proveen una salida PWM de 8-bit con la
función analogWrite().
 SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines soportan
comunicación SPI usando la librería SPI.
 LED:9. hay un LED incorporado conectado al pin digital 9. Cuando
el pin tiene valor ALTO, el LED se enciende, cuando el pin esta en
BAJO, se apaga. En la mayoría de las otras tarjetas Arduino, este
LED se encuentra en el pin 13. Está en el pin 9 de la tarjeta Ethernet
porque el pin 13 se usa como parte de la conexión SPI.
La tarjeta Ethernet tiene 6 salidas analógicas, etiquetadas de A0 hasta A5,
cada una de las cuales proporciona 10 bits de resolución (1024 diferentes
valores). Miden desde tierra a 5 volts por defecto, aunque es posible
cambiar el rango superior e inferior usando el pin AREF y la
función analogReference(). Adicionalmente, algunos pines tienen
funciones específicas
TWI: A4 (SDA) y A5 (SCL). Soporta comunicación TWI usando la librería
Wire.
Hay otro par de pines en la tarjeta
AREF, voltaje de referencia para entradas análogas. Para ser usada
con analogReference().

16
Reset. Lleva esta línea a BAJO para resetear el microcontrolador.
Típicamente usado para adicionar un botón de reseteo para estructuras
armadas que tienen su botón bloqueado.
Ver también el mapeo de pines Arduino y de puertos ATMega328.

Comunicación:
El Ethernet Arduino tiene grandes facilidades para comunicarse con tu
computador, otro Arduino u otros microcontroladores.
La librería SoftwareSerial permite la comunicación serie con cualquiera
de los pines digitales del Uno.
El ATmega328 también soporta comunicación TWI y SPI. El software
Arduino incluye una librería Wire para simplificar el uso del bus TWI; ver
la documentación para más detalles. Para la comunicación SPI, usar
la librería SPI.
Esta tarjeta también se puede conectar a una red de cables vía Ethernet.
Cuando se conecta a una red, necesitarás darle una dirección IP y una
dirección MAC. La librería Ethernet es totalmente compatible.
El lector de tarjeta microSD incluido se puede acceder vía librería SD.
Cuando se trabaja con esta librería, el SS está en el pin 4.

Programación
Es posible programar la tarjeta Arduino Ethernet de 2 formas: a través del
conector de programación de 6 pines, o con un programador externo ISP.
El conector de programación serie de 6 pines es compatible con los cables
USB FTDI y las tarjetas de conexión USB a serie básicas incluyendo el
conector Arduino USB-serie. Incluye soporte para reseteo automático, lo
que permite subir los sketchs sin presionar el botón de reseteo de la tarjeta.
Cuando se conecta a un adaptador USB FTDI, el Ethernet Arduino se
alimenta desde el adaptador.
También puedes programar la tarjeta Ethernet con un programador
externo como el AVRISP mkII o el USBTinyISP. Para configurar tu
ambiente de subida de los códigos con un programador sigue estas
instrucciones. Sin embargo, esto borrará el gestor de arranque serie.
Todos los códigos de ejemplo de Ethernet funcionan como si estuvieran
corriendo en módulos Ethernet Shield. Asegúrate de cambiar la
configuración de red a las especificaciones propias.

17
Características físicas:
El largo y ancho máximo del PCB Ethernet son de 2.7 y 2.1 pulgadas
respectivamente, con el conector RJ45 y el conector Jack que se extienden
fuera de este rango. 4 orificios para tornillos permiten que la tarjeta se una
a cualquier superficie o carcasa. Notar que la distancia entre los pines
digitales 7 y 8 es de 160 milésimas de pulgada (0.16”), que ni siquiera es
múltiplo del espacio de los otros pines, que es de 100 milésimas de
pulgada.

Configuración:
Con esta tarjeta necesitas cambiar los archivos boards.txt en tu directorio
Arduino (encuéntralo en: “Arduino-00xx > hardware > arduino”) con esta
versión mas actualizada que también incluye la tarjeta Mega ADK
 Arduino 0022 o más antiguo: boards.txt.
 Arduino 1.0 beta: boards1.0.txt.

Si quieres usar el cable FTDI para descargar tus códigos al Ethernet

Arduino, por favor revisa esta guía: actualizar el gestor de arranque
Arduino Ethernet a su última versión.

ARDUINO NANO

18
El Arduino Nano es una pequeña, pero poderosa tarjeta basada en
el ATmega328. Posee las mismas funcionalidades que un Arduino UNO,
solo que en un tamaño reducido. Para programarla solo se necesita de un
cable Mini USB.

Características:
 Microcontrolador: ATMega328
 Voltaje de operación: 5 V
 Voltaje de alimentación (Recomendado): 7-12 V
 I/O Digitales: 14 (6 son PWM)
 Memoria Flash: 32 KB
 EEPROM: 1KB
 Frecuencia de trabajo: 16 MHz
 Dimensiones: 0.73″ x 1.70″

ARDUINO FIO

19
El Arduino Funnel I/O (FIO) es una placa diseñada por Shigeru Kobayashi,
basado en el diseño original de LilyPad.
Funnel es un conjunto de herramientas para ejecutar su idea físicamente,
y se compone de bibliotecas de software y hardware. Mediante el uso de
Funnel, el usuario puede interactuar con los sensores y/o actuadores con
varios lenguajes de programación tales como ActionScript 3, Processing,
y Ruby.
Arduino Fio es compatible con Funnel. Tiene conexiones para una batería
de polímero de litio e incluye un circuito de carga a través de USB. Un
zócalo XBee está disponible en la parte inferior de la placa. El Fio ha sido
diseñado para ser reprogramable de forma inalámbrica.
Nota: El conector miniUSB se utiliza para cargar la batería solamente.
Para cargar nuevo firmware, necesitará una conexión serie externa a
través de un FTDI Basic, cable FTDI, u otra conexión serie.
Nota: El zócalo XBee y conexión FTDI viven en los mismos pines TX / RX
del ATmega328. Usted tendrá que quitar el módulo XBee mientras
reprograma mediante serie. Le recomendamos que utilice un gestor de
arranque inalámbrico siempre que sea posible para evitar este paso.

Características:
 ATmega328V funcionando a 8MHz
 Arduino Bootloader
 XBee socket
 Compatible con baterías de polímero de litio
 Cargador LiPo MCP73831T
 Reset button
 On/Off Switch
 Status/Charge/RSSI LEDs

20
ARDUINO LYLIPAD 328

Tarjeta de desarrollo Arduino LilyPad consistente en un ATmega 328 con

el gestor de arranque Arduino y un mínimo número de componentes
externos para mantenerlo lo más pequeño y simple posible. La tarjeta
funciona desde 2 a 5 V. La versión más nueva del LilyPad presenta un
reseteo automático para una programación aún más fácil. ¡La parte de
atrás del LilyPad es completamente plana! Ahora usamos un conector de
programación de montaje en superficie para que el conector tenga un
contacto correcto.
Esta versión del LilyPad ahora usa el nuevo ATmega328 a 8 MHz. Arduino
0016 es compatible con el Arduino Pro Mini 328/8 MHz. Usa esta
configuración cuando trabajes con el LilyPad 328.
El LilyPad es una tecnología desarrollada por Leah Buechley y diseñada
en coordinación con Leah y SparkFun. Cada LilyPad fue diseñado de
manera creativa para que tengan grandes pads de conexión que le
permiten ser cosidas a cualquier prenda. Varias entradas, salidas, formas
de alimentación y sensores están disponibles para su uso. ¡Incluso son
lavables!

21
Dimensiones
 50 mm de diámetro externo.
 Delgado PCB de 0.8mm.

ESTRUCTURA DEL LENGUAJE

Un programa Arduino se puede ejecutar en dos partes:
 void setup()
 void loop()
setup() es la configuración, y loop() es la ejecución.

La sección setup(), se encuentra siempre al comienzo del programa, en el

se configuran los pinMode, se inicializa la comunicación serie, etc.
La función setup() solo se ejecutará una vez, después de cada encendido
o cuando se resetea la placa Arduino.
En la sección loop() se encuentra el código que será ejecutado, como la
lectura de entradas, disparo de salidas, etc.

Ejemplo
const int buttonPin = 3;

// la función setup inicializa la comunicación serie y el pin del pulsador

void setup()
{
Serial.begin (9600);
pinMode (buttonPin, INPUT);
}

// la función loop comprueba el pin del pulsador cada vez,

// y enviara su estado al monitor serie
void loop()
{
if (digitalRead (buttonPin) == HIGH)
Serial.write ('H');
else
Serial.write ('L');

delay (1000);
}

22
Variables
Una variable es una manera de nombrar y almacenar un valor para su uso
posterior por el programa, tales como los datos de un sensor o un valor
intermedio utilizado en un cálculo.

Declaración de variables
Antes de ser utilizadas, todas las variables tienen que ser declaradas. La
declaración de una variable significa que define su tipo, y, opcionalmente,
el establecimiento de un valor inicial (inicializar la variable). Las variables
no tienen que ser inicializadas (asignado un valor) cuando se declaran,
pero a menudo es útil.
int inputVariable1;
int inputVariable2 = 0; // ambos son correctos

Los programadores deben tener en cuenta el tamaño de los números que

desee almacenar en la elección de los tipos de variables. Las variables se
dan la vuelta cuando el valor almacenado supera el espacio asignado
para almacenarlo. Vea a continuación un ejemplo.

Alcance de las variables

Otra opción importante al que se enfrentan los programadores es donde
declarar las variables. El lugar específico que se declaran variables influye
en cómo varias funciones en un programa se ve la variable. Esto se
denomina alcance de la variable .

La inicialización de variables
Las variables pueden ser inicializadas (asignado un valor de partida) que
hayan sido declaradas o no. Siempre es una buena práctica de
programación sin embargo para corroborar que una variable tiene datos
válidos en el mismo, antes de que se accede por algún otro propósito.
Ejemplo:
int calibrationVal = 17; // Declara calibrationVal y establecer el valor inicial

Roll over de las variables

Cuando se hace que las variables excedan su capacidad máxima se dice
que se dan la vuelta ("roll over") a su capacidad mínima, tenga en cuenta
que esto ocurre en ambas direcciones.
int x
x = 32.768;
x = x - 1; // X ahora contiene 32.767 - se da la vuelta en neg. dirección
x = 32.767;
23
 x = x + 1; // X ahora contiene 32.768 - Se da la vuelta

Uso de variables
Una vez que las variables han sido declaradas, son utilizadas por la
asignación de la variable igual al valor que se desea almacenar con
el operador de asignación (un solo signo igual). El operador de
asignación indica al programa que ponga lo que está en el lado derecho
del signo igual en la variable en el lado izquierdo.
inputVariable1 = 7; // Establece la variable llamada inputVariable1 a 7
inputVariable2 = analogRead (2); // Establece la variable llamada a la
inputVariable2
//entrada de tensión analógica leìda desde el pin # 2
(Digitalizada)

Ejemplos
int lightSensVal;
Char currentLetter;
unsigned long speedOfLight = 186000UL;

Char errorMessage = { "elegir otra opción"}; // mira la cadena

Una vez que una variable se ha establecido (asignado un valor), puede

probar su valor para ver si cumple con ciertas condiciones, o puede usar
su valor directamente. Por ejemplo, las siguientes pruebas de código si el
inputVariable2 es inferior a 100, a continuación, establece un retardo
basado en inputVariable2 que es un mínimo de 100:
if (inputVariable2 < 100)

{
inputVariable2 = 100
}

delay(inputVariable2)
Este ejemplo muestra las tres operaciones útiles con variables. Pone a
prueba la variable ( if (inputVariable2 < 100)), se establece la variable si
pasa la prueba ( inputVariable2 = 100 ), y se utiliza el valor de la variable
como un parámetro de entrada para la función de retardo ()(delay
(inputVariable2)) )
Nota: Usted debe dar a las variables nombres descriptivos, con el fin de
hacer que el código sea más legible. Los nombres de variables
como tiltSensor o botón pulsador le ayudan a usted (y cualquier otra
persona que lea su código) para que entiendan lo que representa la
variable. Los nombres de variables como var o valor , por el contrario,
hacen el código poco legible.

24
Se puede nombrar a una variable con cualquier palabra que no sea una
de las palabras clave en Arduino. Evitar que comiencen los nombres de
variables con caracteres numéricos.

Algunos tipos de variables

- char
- byte
- int
- unsigned int
- long
- unsigned long
- float
- double

if...else
El bucle if...else permite un mayor control del flujo de código que la
instrucción básica if, al permitir múltiples comprobaciones agrupadas. Por
ejemplo, se puede comprobar una entrada analógica y realizar una acción
si el valor de la entrada es menor que 500, y realizar otra acción distinta si
la entrada es 500 o mayor. El código se vería así:

if (pinFiveInput < 500)

{
// acción A
}
else
{
// acción B
}

else puede ir precedido de otra condición de manera que se pueden

establecer varias estructuras condicionales de tipo unas dentro de las
otras (anidamiento) de forma que sean mutuamente excluyentes
pudiéndose ejecutar a la vez. Es incluso posible tener un número ilimitado
de estos condicionales. Recuerde sin embargo qué sólo un conjunto de
declaraciones se llevará a cabo dependiendo de la condición probada:
Tenga en cuenta que un bloque if...else se puede utilizar con o sin un
bloque de terminación else y viceversa. Se permite un número ilimitado de
dichas ramificaciones if...else.

25
if (pinFiveInput < 500)
{
// instrucciones A
}
else if (pinFiveInput >= 1000)
{
// instrucciones B
}
else
{
// instrucciones C
}

+ Suma
+ Adición, - Subtracción, * Multiplicación y / División

Descripción
Estos operadores devuelven la suma, resta, producto, o cociente
(respectivamente) de dos operandos. La operación se realiza usando el
tipo de datos de los operandos, así, por ejemplo, 9 / 4 da 2 ya que 9 y 4
son int (enteros). Esto también significa que la operación puede
desbordarse si el resultado es más grande que el que puede ser guardado
en ese tipo de datos (por ejemplo, la suma de 1 con un int de valor 32,767
da -32,768).
Si los operandos son de diferentes tipos, se usa para el cálculo el tipo
"mayor".
Si uno de los números (operandos) es del tipo float o del tipo double, se
usa para el cálculo el tipo matemático float.

Ejemplo
y = y + 3;
x = x - 7;
r = r / 5;
i=j*6

Sintaxis
result = value1 + value2;
result = value1 - value2;
result = value1 / value2;
result = value1 * value2;
26
Parámetros:
value1: cualquier variable o constante
value2: cualquier variable o constante
Consejos de programación:
 Las constantes enteras son, por defecto, int , por lo que
algunos cálculos con constantes pueden desbordarse (por
ejemplo, 60 * 1000 dá un resultado negativo).
 Elegir los tamaños de las variables que sean lo
suficientemente grandes para contener los resultados más
importantes de sus cálculos.
 Hay que saber en qué punto la variable puede "darse la
vuelta", y también lo que sucede en la otra dirección, por
ejemplo, (0 - 1) o (0 - - 32768).
 Para operaciones matemáticas que requieran fracciones,
utilizar variables float, pero ser conscientes de sus
inconvenientes: gran tamaño, velocidades lentas de cálculo.
Utilice el operador de conversión, por ejemplo, (Int) myFloat
para convertir un tipo de variable a otro sobre la marcha.
Comentarios
Los comentarios son líneas en el programa que se utilizan para
informar a usted o a otras personas acerca de la forma en que
funciona el programa. Son ignorados por el compilador, y no se
exportan al procesador, por lo que no ocupan ningún espacio en el
chip ATmega.
Los comentarios se usan para ayudarle a entender (o recordar)
cómo funciona el programa o para informar a los demás cómo
funciona el programa. Hay dos maneras diferentes de marcar una
línea como un comentario:

Ejemplo
x = 5; // Esto es un comentario de una línea. Cualquier cosa
después de las barras
// es un comentario hasta el final de la línea

27
/* esto es un comentario multulínea - usar para comentar bloques
de código

(gwb == 0){ // es válido un comentario de una línea dentro de uno

multilínea
x = 3; /* pero no otro multilínea - eso no es válido */
}
// no olvidarse de "cerrar" el comentario-Deben estar balanceados

Consejo
Experimentar con el código "comentando" partes de su programa es
una manera conveniente de eliminar las líneas que pueden
contener errores. Esto deja a las líneas en el código, pero los
convierte en los comentarios, por lo que el compilador simplemente
los ignora. Esto puede ser especialmente útil cuando se trata de
localizar un problema, o cuando un programa se niega a compilar y
el error del compilador es críptico e ineficiente.
{ } (llaves)
Las llaves son una parte importante del lenguaje de programación
C. Se utilizan diferentes construcciones, que se describen a
continuación, y esto a veces puede ser confuso para los
principiantes.
Una llave de apertura "{" siempre debe ir seguida de una llave de
cierre "}". Esta es una condición que se refiere a que
las llaves están equilibradas. El Arduino IDE (entorno de desarrollo
integrado) incluye una herramienta de gran utilidad para comprobar
el saldo de llaves. Sólo con marcar la llave, o incluso hacer clic en
el punto de inserción inmediatamente después de una llave, y se
destaca su compañera lógica.
En la actualidad, esta función se tiene algunos fallos como que el
IDE encontrará a menudo (incorrectamente) unallave en el texto
que está "comentado".
Los programadores principiantes y programadores que vienen a C
del lenguaje BASIC a menudo encuentran el uso dellaves confuso
o intimidante. Después de todo, las mismas llaves sustituyen a la

28
sentencia RETURN en una subrutina (función), ENDIF en una
condicional y la declaración siguiente en un bucle FOR.
Debido a que el uso de la llave de cierre es tan variada, es una
buena práctica de programación escribir la llave de cierre
inmediatamente después de escribir la llave de apertura cuando se
inserta una construcción que requierellaves. Luego insertar algunos
retornos de carro entre las llaves y comenzar a insertar
instrucciones. Sus llavesnunca llegarán a estar desequilibradas.
Las llaves desequilibradas a menudo pueden conducir a errores de
compilación crípticos e impenetrables que a veces pueden ser
difíciles de localizar en un programa grande. Debido a sus variados
usos, las llaves son increíblemente importantes para la sintaxis de
un programa y mover una llave una o dos líneas puede afectar
dramáticamente al significado de un programa.

El uso principal de las llaves

Funciones
void myfunction(datatype argument){
instruccion(es)
}

Bucles
while (expresión booleana)
{ instruccion(es)
}

do
{
instruccion(es)
}
while (expresión booleana);

for (initialisation; termination condition; incrementing expr)

{
instruccion(es)
}

29
Instrucciones condicionales

if (expression booleana)
{
intrucción(es)
}

else if (expression booleana)

{
instrucción(es)
}
else
{
instrucción(es)
}

; (punto y coma)
Se usa para finalizar una instrucción.

Ejemplo

int a = 13;

Consejo

Olvidarse poner fin a una línea con un punto y coma dará lugar a un
error de compilación. El texto de error puede ser obvio, y se refieren
a un punto y coma que falta, o puede que no. Si un error del
compilador impenetrable o aparentemente ilógico aparece, una de
las primeras cosas que se debe comprobar es que falta un punto y
coma, en las inmediaciones, que precede a la línea en la que se
queja el compilador.

return

30
Termina una función y devuelve un valor desde una función a la
función que llama, si se desea.
Lo que escribamos por debajo de return en la función donde lo
usemos, no se ejecutará nunca. Ya que, cuando llega a return,
vuelve a la función que lo llamó.

Sintaxis:

return;

return value; // ambas formas son válidas

Parámetros

value: cualquier tipo variable o constante

Ejemplos:

Una función para comparar una entrada de un sensor con un

umbral.

int checkSensor(){
if (analogRead(0) > 400) {
return 1;
else{
}
return 0;
}

La palabra clave de return es muy útil para probar una sección de

código sin tener que "comentar" grandes secciones de código
posiblemente con errores.

31
void loop(){
//idea brillante para comprobar su código aquí
return;
// este código no se ejecuta
// aquí el resto de código que no funciona
}

for
Descripción
La declaración for se usa para repetir un bloque de sentencias
encerradas entre llaves un número determinado de veces. Cada vez
que se ejecutan las instrucciones del bucle se vuelve a comprobar
la condición. La declaración fortiene tres partes separadas por ';' ,
veamos el ejemplo de su sintaxis:
for (initialization; condition; increment)
{
//instrucción(es);
}

32
La inicialización de una variable local se produce una sola vez
y la condición se prueba cada vez que se termina la ejecución
de las instrucciones dentro del bucle. Si la condición sigue
cumpliéndose, las instrucciones del bucle se vuelven a
ejecutar. Cuando la condición no se cumple, el bucle termina.
Ejemplo
// Reduce el brillo de un LED usando un pin PWM
int PWMpin = 10; // LED en serie con una resistencia de 470
ohm en el pin 10
void setup ()
{
// no es necesario el setup
}
void loop()
{
delay(10);
for (int i=0; i <= 255; i++)
{
analogWrite(PWMpin, i);
}
}
Consejos

33
Nota: El bucle for en el lenguaje C es mucho más flexible que
otros bucles encontrados en algunos otros lenguajes de
programación, incluyendo BASIC. Cualquiera de los tres
elementos de cabecera puede omitirse, aunque el punto y
coma es obligatorio. También las declaraciones de
inicialización, condición y expresión puede ser cualquier
estamento válido en lenguaje C sin relación con las variables
declaradas. Estos tipos de estados son extraños pero permiten
crear soluciones a algunos problemas de programación
específicos.
Por ejemplo, usando una multiplicación en el incremento de la
línea generará una progresión logarítmica:

for (int x = 2; x < 100; x = x * 1.5)

{
println (x);
}
Genera: 2,3,4,6,9,13,19,28,42,63,94
Otro ejemplo, encendido y apagado progresivo de un LED con
un lazo for:
void loop()
{
x = 1;
(int i = 0; i > -1; i = i + x)
{
analogWrite(PWMpin, i);
if (i == 255) x = -1; // cambia de dirección
delay(10);
}
}

switch...case
Al igual que las instrucciones if, switch ... case controla el flujo del
programa permitiendo que los programas especifiquen un código
diferente que debe ser ejecutado en distintas condiciones. En
particular, una sentenciaswitch compara el valor de una variable
con los valores especificados en las instrucciones case. Cuando se
encuentra una sentencia case cuyo valor coincide con el de la
variable, el código de esa declaración case se ejecuta.

34
La palabra reservada break interrumpe la sentencia switch, y se
usa normalmente al final de cada declaración case. Sin una
declaración de interrupción, la sentencia switch continuará la
ejecución de las siguientes expresiones hasta que se alcanza una
interrupción o hasta el final de la sentencia switch.

Ejemplo
switch (var)
{
case 1
//hace algo cuando var es igual a 1
break

case 2
//hace algo cuando var es igual a 2
break

default:
//si nada coincide, hace lo predeterminado
// default es optional
break
}

Sintaxis
switch (var)
{
case label
// instrucciones
break;

case label:
// instrucciones
break;

default:
// instrucciones
break;
}

Parametros

35
var: la variable cuyo valor es comparado en los distintos case.
label: el valor a comparar con la variable

while
Descripción
Los bucles while se ejecutan de forma continua, e infinitamente,
hasta que la expresión dentro del paréntesis () se convierte en falsa.
Algo debe cambiar la variable de prueba, o el bucle while nunca se
terminará. Este cambio podría ser en el código, tal como que una
variable sea incrementada, o una condición externa, tal como la
comprobación de un sensor.

Sintaxis
while(expression){
instrucción(s)
}

Parámetros
expression - una instrucción (boolean) C que se evalúa como
verdadera o falsa.

Ejemplo
var = 0;

while(var < 200){

// repite algo 200 veces

var++;
}

do...while

36
El bucle do...while funciona de la misma manera que el
bucle while, con la excepción de que la condición se comprueba al
final del bucle, por lo que el bucle se ejecutará siempre al menos
una vez.
do
{
// bloque de instrucciones
}
while (condición de prueba);

Ejemplo
do
{
delay (50); // espera a que el sensor se estabilice
}
while (x < 100);

do...while
El bucle do...while funciona de la misma manera que el
bucle while, con la excepción de que la condición se comprueba al
final del bucle, por lo que el bucle se ejecutará siempre al menos
una vez.
do
{
// bloque de instrucciones
}
while (condición de prueba);

Ejemplo
do
{
delay (50); // espera a que el sensor se estabilice
}
while (x < 100);

continue
La sentencia continue se salta el resto de la iteración actual de un
bucle (do, for, o while). Después continúa la comprobación de la
37
expresión condicional del bucle, y con cualquiera de las iteraciones
posteriores.A diferencia de break, el bucle no se abandona, sino
que se seguirá ejecutando mientras la condición se cumpla.

Ejemplo
for (x = 0; x < 255; x ++)
{
if (x > 40 && x < 120){ // crea un salto de valores
continue;
}
analogWrite(PWMpin, x);
delay(50);
}

% Módulo

Description

Calcula el resto cuando un entero es dividido por otro. Es útil para

mantener una variable dentro de un intervalo particular por ejemplo,
el tamaño de una matriz).

Sintaxis

result = dividendo % divisor

Parámetros

dividendo: el número a ser dividido

divisor: el número por el que se divide

38
Retornos

el resto

Ejemplos

x = 7 % 5; // x contiene ahora 2
x = 9 % 5; // x contiene ahora 4
x = 5 % 5; // x contiene ahora 0
x = 4 % 5; // x contiene ahora 4

Código de Ejemplos
/* actualiza un valor en una matriz cada vez que se ejecuta el bucle
*/
int values[10];
int i = 0;
void setup() {} void loop() {
i = (i + 1) % 10; // el operador de módulo "rolls over" la variable
values[i] = analogRead(0); }

Consejo

El operador módulo no funciona con tipos float.

Operadores compuestos

Descripción
Realiza una operación matemática de una variable con otra variable
o constante. El operador += (y otros) son sólo un método rápido y
conveniente para la sintaxis expandida, se enumeran a
continuación..

Sintaxis

x += y; // equivalente a la expresión x = x + y;

39
x -= y; // equivalente a la expresión x = x - y;

x *= y; // equivalente a la expresión x = x * y;

x %= y; / equivalente a la expresión x = x % y;

x /= y; // equivalente a la expresión x = x / y;

Parámetros

x: cualquier tipo de variable

y: cualquier tipo de variable o constante

Ejemplos

x = 2;

x += 4; // x ahora contiene 6

x -= 3; // x ahora contiene 3

x *= 10; // x ahora contiene 30

40
x /= 2; // x ahora contiene 15

x %= 5; // x ahora contiene 0

++ (incremento) / -- (decremento)

Descripción

Incrementa r decrementa una variable

Sintaxis

x++; // incrementa x en una unidad y devuelve el anterior valor de x

++x; // incrementa x en una unidad y devuelve el nuevo valor de x

x-- ; // decrementa x en una unidad y devuelve el anterior valor de x

--x ; // decrementa x en una unidad y devuelve el nuevo valor de x

Parámetros

x: un int o long (posiblemente sin signo)

Retornos

El original o nuevo valor incrementado/decrementado de la variable.

Ejemplos

41
x = 2;
y = ++x; // x ahora contiene 3, y contiene 3
y = x--; // x contiene 2 de nuevo, y todavía contiene 3

HIGH
Las constantes son expresiones predefinidas en el lenguaje
Arduino. Las contantes se utilizan para que el programa sea más
fácil de leer. Clasificamos las constantes en grupos:

Definición de niveles lógicos: true y false (Constantes

Booleanas)
Hay dos palabras que se usan en el lenguaje Arduino para
representar la verdad y la falsedad: true, y false.

false
false es la más fácil de definir, se define como 0 (cero).

true
true a menudo se define como 1, lo cual es correcto, pero cierto que
tiene una definición más amplia. Cualquier número entero que es
distinto de cero es true en un sentido Booleano. Así -1, 2 y -200 se
definen como true, también en sentido Booleano.

Tenga en cuenta que las constantes true y false se escriben en

mayúsculas, al igual que HIGH, LOW, INPUT y OUTPUT.

Definición de los niveles de los pines: HIGH y LOW

Cuando leemos o escribimos un pin digital, solo hay dos
valores posibles que el pin puede tener, activado o
desactivado: HIGH o LOW.

42
HIGH (Nivel alto)

El significado de HIGH (en referencia a un pin) es algo diferente

según se trate de si un pin se configura como INPUT (entrada) o
como OUTPUT (salida).

Cuando un pin se configura como INPUT con pinMode() y se lee

con digitalRead() HIGH si:
 una tensión mayor de 3 voltios está presente en el pin (placas
de 5 V)
 una tensión mayor de 2 voltios está presente en el pin (placas
de 3,3 V)
Un pin se puede configurar como INPUT con pinMode(), y en
consecuencia, ponerse a nivel HIGH con digitalWrite(). Esto
habilitará las resistencias pullup internas de 20 K, que provocará
que el pin de entrada se ponga a nivel HIGH a menos que se lleve a
nivel LOW por la circuitería externa. Así es
como trabaja INPUT_PULLUP descrito más adelante con más
detalle.
Cuando un pin se configura como OUTPUT con pinMode () y se
activa a nivel HIGH con digitalWrite() el pin está a:
 5 voltios (en placas alimentadas a 5 V);
 3.3 voltios (en placas alimentadas a 3.3V);
En este estado el pin actúa como source (fuente) de corriente, por
ejemplo, encender un LED conectado a masa por medio de una
resistencia limitadora.

43
LOW (Nivel bajo)

El significado de LOW también tiene un significado diferente

dependiendo si se configura como INPUT o como OUTPUT.
Cuando un pin se configura como INPUT con pinMode y se lee con
digitalRead Arduino (Atmega) informará LOW si:
 una tensión menor de 3 voltios está presente en el pin (placas
5 V);
 una tensión menor de 2 voltios está presente en el pin (placas
3.3 V);
Cuando un pin está configurado como OUTPUT con pinMode () y es
puesto a nivel LOW con digitalWrite (), el pin está a 0 voltios (en
ambas placas de 5 V y 3.3 V). En este estado el pin actúa como
sink (drenador) de corriente, por ejemplo, para encender un LED
conectado por medio de una resistencia limitadora a +5 voltios (o a
+3.3 voltios).

Definición de los modos de los pines digitales: INPUT,

INPUT_PULLUP, y OUTPUT

Los pines digitales se pueden usar como INPUT, INPUT_PULLUP

o OUTPUT.

Cuando se cambia un pin con pinMode (), cambia el

comportamiento eléctrico del pin.

Pines configurados como INPUT

44
Los pines de Arduino (Atmega) configurados como INPUT con
pinMode () se dice que están en estado de alta impedancia. Los
pines configurados como INPUT demandan una corriente
extremadamente baja del circuito que esta muestreando,
equivalente a una resistencia en serie de 100 Megohms. Esto los
hace útiles para la lectura de un sensor.

Si tenemos un pin configurado como INPUT y estamos leyendo un

interruptor, cuando el interruptor está en estado abierto la entrada
del pin está "flotante", dando como resultado una lectura
impredecible. Para asegurar una lectura apropiada del pin cuando el
interruptor está abierto, debe usarse una
resistencia pullup o pulldow. La función de estas resistencias es
llevar el pin a un estado conocido cuando el interruptor está abierto.
Usualmente se elige una resistencia de 10 K ohm, ya que es un
valor suficientemente bajo como para evitar que una entrada quede
"flotante", y al mismo tiempo un valor suficientemente alto como
para no drenar demasiada corriente cuando el interruptor está
cerrado. Ver el tutorial Digital Read Serial para más información.

Si se usa una resistencia pulldown, el pin de entrada estará a nivel

LOW cuando el interruptor esté abierto y en estado HOGH cuando
el interruptor esté abierto.

Si se usa una resistencia pullup, el pin estará a nivel HIGH cuando

el interruptor esté abierto y LOW cuando el interruptor esté cerrado.

Pines configurados como INPUT_PULLUP

45
El microcontrolador Atmega del Arduino tiene resistencias pull-up
internas (resistencias conectadas internamente a la alimentación) a
las que podemos acceder. Si prefieres usar estas en lugar de
resistencias pull-up externas, puedes usar el
argumento INPUT_PULLUP en pinMode ()

Ver el tutorial Input Pullup Serial para ver un ejemplo de este uso.

Los pines configurados como INPUT o INPUT_PULLUP se pueden

dañar o destruir si se conectan a tensiones más bajas que la
masa (tensiones negativas) o por encima de la tensión de
alimentación (5 V o 3,3 V).

Pines configurados como Outputs

Los pines configurados como OUTPUT con pinMode () se dice que

están en estado de baja impedancia. Esto significa que pueden
proporcionar una cantidad sustancial de corriente a otros circuitos.
Los pines del Atmega pueden ser source (fuente, proporcionar
corriente) o sink (drenador, absorver corriente) hasta 40 mA
(milliamperios) a otros dispositivos o circuitos. Esto hace que sean
útiles para encender LEDs porque los LEDs típicamente consumen
menos de 40 mA. Carga mayores de 40 mA (por ejemplo, motores)
requieren un transistor u otra circuitería de interface.

Los pines configurados como salidas se pueden dañar o destruir se

se conectan directamente a masa o al positivo de la alimentación.

46
Definición de los LED_BUILTIN (LED incorporados)

Mucha placas Arduino tienen un pin conectado a un LED

incluido en la placa conectado con una resistencia en serie. La
constante LED_BUILTIN es el número de pin al que el LED
incluido está conectado en la placa. La mayoría de las placas
tiene este LED conectado al pin digital 13.

int

Descripción

Los int (enteros) son el tipo de datos primario para el

almacenamiento de números.
En el Arduino Uno (y otras placa basadas en el ATMega)
un int almacena un valor de 16-bit (2-byte). Esto produce un rango
de -32,768 to 32,767 (valor mínimo de -2^15 y un valor máximo de
(2^15) - 1).
En el Arduino Due, unint almacena un valor de 32-bit (4-byte). Esto
produce un rango de -2,147,483,648 a2,147,483,647 (valor mínimo
de -2^31 y un valor máximo de (2^31) - 1).

Losint almacenan números negativos con una técnica

llamada complemento matemático a 2. El bit más alto, a veces
llamado bit de "signo" es la bandera que define el número como
negativo. El resto de los bits se invierte y se les añade 1.

El Arduino se encarga de tratar los número negativos por nosotros,

por lo que las operaciones aritméticas trabajan de forma
transparente de la manera esperada. Sin embargo, podemos
encontrarnos con una complicación inesperada con el
operador bitshift right (>>) (desplazamiento de bit a la derecha).
47
 Example
int ledPin = 13;

Sintaxis
int var = val;

 var - el valor de la variable int.

 val - el valoe que asignamos a esta variable

Consejo de programación

Cuando las variables superan su máxima capacidad estas se "roll

over", es decir, se dan la vuelta y comienzan por el otro extremo,
tenga en cuenta que esto sucede en ambas direcciones. Ejemplo
para un int de 16-bit:

int x;

x = -32768;

x = x - 1; // x contiene ahoras 32,767 - rolls over en dirección

negativa

x = 32767;

x = x + 1; // x contiene ahora -32,768 - rolls over

48
byte

Description

Un byte almacena un número sin signo de 8-bit, de 0 a 255.

Example
byte b = B10010; // "B" es el formateador binario (B10010 = 18
decimal)

char sin signo

Descripción

Un char sin signo es un tipo de datos que ocupa un byte de

memoria. Lo mismos que el tipo de datos byte.

El tipo de datos char sin signo codifica númeos de o a 255.

Por consistencia con el estilo de programación de Arduino, se

prefiere el tipo de datos byte.

Example
unsigned char myChar = 240;

Enviar por correo electrónico

char

Descripción

Un char es un tipo de datos que ocupa 1 byte de memoria y

almacena el valor de un caracter. Los literales de caracteres se

49
escriben entre comillas, similar a esto: 'A' (para varios caracteres -
cadenas- use dobles comillas: "ABC").

Sin embargo, los caracteres se almacenan como números. Puedes

ver la codificación específica enla Carta ASCII. Esto significa que es
posible hacer operaciones matam´ticas con los caracteres, en las
que se utiliza el valor ASCII del caracter (por ejemplo, 'A' + 1 tiene
como valor 66, porque el valor ASCII de la A mayúscula es 65). Ver
la referencia Serial.println para más información sobre cómo los
caracteres se convierten a números.
El tipo de datos char es un tipo con signo, que codifica números
entre -128 y 127. Para un tipo de datos sin signo, un byte (8 bits),
utilice el tipo de datos byte.

Ejemplo

char myChar = 'A';

char myChar = 65; // ambos son equivalentes

Boolean
Un tipo de datos boolean soporta uno de los dos
valores, true o false. (Cada variable boolean ocupa un byte de
memoria.)

Ejenplo
int LEDpin = 5; // LED conectado al pin 5

int switchPin = 13; // pulsador al pin 13, el otro extremo a masa

50
boolean running = false;

void setup()

pinMode(LEDpin, OUTPUT);

pinMode(switchPin, INPUT);

digitalWrite(switchPin, HIGH); // conecta la resistencia pullup

void loop()

if (digitalRead(switchPin) == LOW)

{ // pulsador presionado - la pullup pone el pin normalmente high

delay(100); // tiempo para el rebote del pulsador

running = !running; // conmuta la variable

digitalWrite(LEDpin, running) //indicada por medio del LED

long
51
 Descripción
Las variables long son variables de tamaño extendido para
almacenamiento de números de 32 bits (4 bytes), desde -
2,147,483,648 a 2,147,483,647.
Si se hace operaciones matemáticas con enteros, al menos
uno de los números debe estar seguido de una L, forzando
a este número a ser unlong. Ver la página Constantes
enteras para más detalles.

Ejemplo

long speedOfLight = 186000L; // ver la página

Constantes enteras para una explicación de 'L'

Sintaxis
long var = val;

 var - el nmbre de la variable long

 val - el valor asignado a la variable

word

52
Descripción

En el Arduino Uno y otras placas basadas en el ATMEGA, una palabra

(word) almacena un número sin signo de 16-bit. En el Due y en el Zero se
almacena un número sin signo de 32-bit.

Ejemplo
word w = 10000;

int sin signo

Descripción
En el Arduino Uno y otras placas basadas en el ATMEGA,
los unsigned ints (enteros sin signo) son lo mismo que los
int que almacenan un valor de 2 bytes. En lugar de
almacenar números negativos, solo almacenan valores
positivos, produciendo un rango de 0 a 65,535 (2^16) - 1).
El ArduinoDue almacena un valor de 4 bytes (32-bit), con
un rango de 0 a 4,294,967,295 (2^32 - 1).
La diferencia entre enteros sin signo y enteros con signo,
radica en la forma en que se trata el bit más alto, a veces
llamado bit de "signo". En el Arduino el tipo int (con signo),
si el bit más alto es "1", el número se interpreta como que
es un número negativo, y los otros 15 bits se interpretan
como complemento matemático a 2.

Example
unsigned int ledPin = 13;

53
 Syntax
unsigned int var = val;

 var - el nombre de nuestra varaible int sin signo

 val - el valor que asignamos a esta variable

Consejo de programación
Cuando las variables superan su máxima capacidad estas
se "roll over", es decir, se dan la vuelta y comienzan por el
otro extremo, tenga en cuenta que esto sucede en ambas
direcciones. Ejemplo para un int de 16-bit:

unsigned int x

x = 0;

x = x - 1; // x contiene ahora 65535 - rolls over en

dirección negativa

x = x + 1; // x contiene ahoras 0 - rolls over

char()

54
Descripción

Convierte un valor al tipo de datos char.

Sintaxis

char(x)

Parameters

x: un valor de cualquier tipo

Retornos

caracter
Matrices (Arrays)
Una matriz es un conjunto de variables a las que se accede con un número de
índice. Las matrices en el lenguaje de programación C, en el que se basa
Arduino, pueden ser complicadas, pero el uso de matrices simples es
relativamente sencillo.

Creación (Declaración) de una Matriz

Cualquiera de los métodos que se indican abajo son adecuados para crear
(declarar) una matriz.
int myInts[6];

int myPins[] = {2, 4, 8, 3, 6};

int mySensVals[6] = {2, 4, -8, 3, 2};

char message[6] = "hola";

Puede declarar una matriz sin inicializar como myInts.

En myPins declaramos una matriz sin elegir un tamaño de forma
explícita. El compilador cuenta los elementos y crea una matriz de
tamaño apropiado.
Por último se puede inicializar dar tamaño de la matriz, como en
mySensVals. Tenga en cuenta que cuando se declara un array de tipo

55
char, se requiere un elemento más de su inicialización, para
mantener el carácter nulo requerido.

Acceso a una Matriz

Las matrices se indexan desde cero, es decir, el primer elemento de la matriz

está en el index 0, por lo tanto

mySensVals[0] == 2, mySensVals[1] == 4, y así sucesivamente.

Esto significa que en una matriz de diez elementos, el índice nueve es el

último elemento. Por lo tanto:
int myArray[10]={9,3,2,4,3,2,7,8,9,11};

// myArray[9] contiene 11

// myArray[10] no es válido y contiene información aleatória (otra dirección de

memoria)

Por esta razón se debe tener cuidado al acceder a las matrices. El

acceso a más allá del final de una matriz (utilizando un número de
índice mayor que el tamaño de su matriz declarada - 1) se lee de la
memoria que se utiliza para otros fines. La lectura de estas
ubicaciones probablemente no va a servir para nada. La escritura en
las posiciones de memoria al azar es definitivamente una mala idea
y, a menudo puede conducir a resultados infelices tales como
accidentes o mal funcionamiento del programa. Esto también puede
ser un error difícil de localizar.
A diferencia de BASIC o Java, el compilador de C no hace la
comprobación para ver si el acceso matriz está dentro de los límites
legales del tamaño de la matriz que se ha declarado.

Para asignar un valor a una matriz:

mySensVals[0] = 10;

Para recuperar un valor de una matriz:

x = mySensVals[4];

56
Matrices y bucles FOR
Las matrices se utilizan muchas veces dentro de los bucles, en el que
el contador de bucle se utiliza como el índice de cada elemento de la
matriz. Por ejemplo, para imprimir los elementos de una matriz a
través del puerto serie, se podría hacer algo como esto:
int i;

for (i = 0; i < 5; i = i + 1) {

Serial.println(myPins[i]);

Ejemplo

Para ver un programa completo que muestra el uso de matrices, ver el

tutorial Knight Rider example.
String - Objeto
Descripción
La clase String, que forma parte del núcleo partir de la
versión 0019, le permite usar y manipular cadenas de texto
en formas más complejas que character arrays. Puede
concatenar cadenas, anexar a eallas, buscar charAt() y
reemplazar subcadenas, y mucho más. Se requiere más
memoria que una simple matriz de caracteres, pero también
es más útil.
Como referencia, las matrices de caracteres se conocen
como string con s minúscula, y las instancias de la clase
String se denominan cadenas con S mayúscula . Tenga en
cuenta que, las constantes de cadena especificadas con
"comillas dobles" son tratadas como arrays de char, no
casos de la clase String.
Ejemplos

57
 StringConstructors
 StringAdditionOperator
 StringIndexOf
 StringAppendOperator
 StringLengthTrim
 StringCaseChanges
 StringReplace
 StringRemove
 StringCharacters
 StringStartsWithEndsWith
 StringComparisonOperators
 StringSubstring

string - matriz de caracteres

Descripción
Las cadenas de texto pueden ser representadas de dos
formas. se puede usar el tipo de datos String, que forma
parte del núcleo a partir de la versión 0019, o se puede hacer
una cadena de una matriz de tipo char y terminación nula.
Esta página decribe el último método. Para más detalles
sobre el objeto string, que le da más funcionalidad a cambio
de más uso de memoria, ver la página String object.

Ejemplos
Todas las declaraciones siguientes son válidas para
cadenas.

char Str1[15];

char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};

58
 char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};

char Str4[ ] = "arduino";

char Str5[8] = "arduino";

char Str6[15] = "arduino";

Posibilidades para la declaración de cadenas

 - Declarar una matriz de caracteres inicializandola como
Str1
 - Declarar una matriz de caracters (con un caracter extra) y
el compilador añadirá el caracer nulo requerido, como Str2
 - Agregar explicitamente el caracter nulo, Str3
 - Inicializar una constante de cadena entre comillas; el
compilador ajustará el tamaño de la matriz para adaptarse a
la cadena y un caracter nulo de terminación, Str4

59
 - Incializar una matriz con un tamaño explícito y una
constante de cadena, Str5
 - Inicializar la matriz, dejando espacio extra para una
cadena larga, Str6

Null termination
Generalmente. las cadenas terminan con un carácter nulo
(ASCII código 0). Esto permite que las funciones (como
Serial.print()) sepan donde terminan las cadenas. De lo
contrario, seguirían leyendo los siguientes bits de memoria
que no son, en relidad, parte de la cadena.
Esto significa que la cadena tiene que tener espacio para un
carácter más que el texto que desea que contenga. Por eso
Str2 y Str5 deben tener ocho caracteres, a pesar de que
"Arduino" tiene sólo siete - la última posición se rellena
automáticamente con un carácter nulo. Str4 tomará el
tamaño automáticamente a ocho caracteres, uno para el
caracter extra nulo adicional. En Str3, hemos incluido
explícitamente el carácter nulo (escrito '\ 0') por nosotros
mismos.
Tenga en cuenta que es posible tener una cadena sin un
carácter nulo final (por ejemplo, si ha especificado la
longitud de Str2 como siete en lugar de ocho). Esto
interrumpirá la mayoría de las funciones que utilizan
cadenas, por lo que no debería hacerlo intencionalmente. Si
usted nota que algo se comporta de forma extraña (que

60
opera en caracteres no en la cadena), esto podría ser el
problema.
¿Comillas sencillas o dobles?
Las cadenas siempre están definidas dentro de comillas
dobles ("Abc") y los caracteres está siempre definidos
dentro de comillas simples ('A').
Envolviendo cadenas largas
Puede envolver cadenas largas de esta forma:

char myString[] = "Esta es la primera línea"

" esta es la segunda línea"

" etcetera";

Matrices de cadenas
A menudo es conveniente, cuando se trabaja con grandes
cantidades de texto, como un proyecto con una pantalla
LCD, configurar una matriz de cadenas. Debido a que las
cadenas en sí son matrices, esto es en realidad un ejemplo
de una matriz de dos dimensiones.

61
En el código siguiente, el asterisco después del tipo de datos
char "char *" indica que se trata de una matriz de
"punteros". Todos los nombres de matrices son en realidad
punteros, así que esto es necesario para hacer una matriz de
matrices. Los punteros son una de las partes más esotéricas
de C para que los principiantes puedan entender, pero no es
necesario entender los punteros en detalle para utilizarlos
de manera efectiva aquí.

Ejemplo

char* myStrings[]={"Esta es la cadena 1", "Esta es la

cadena 2", "Esta es la cadena 3",

"Esta es la cadena 4", "Esta es la cadena 5","Esta es la

cadena 6"};

void setup(){

62
Serial.begin(9600);

void loop(){

for (int i = 0; i < 6; i++){

Serial.println(myStrings[i]);

delay(500);

63
double

Descripción
Número de punto flotante de doble precisión. En el Arduino
Uno y otras placas basadasen el ATMEGA, este número
ocupa 4 bytes. Es decir, que la implementación de duble es
exactamente la misma que un float, no gana en precisión.
En el Arduino Due, los números double tienen 8-byte (64
bit) de precisión.

Consejo
Los usuarios que toman prestado código de otras fuentes
que incluye variables double pueden desear examinar el
código para ver si la precisión implícita es diferente de la
que realmente es alcanzada en Arduinos basados en
ATMEGA.

float

Descripción
Tipo de datos para números de punto flotante, un número
que tiene un punto decimal. Los números de coma flotante
se utilizan a menudo para aproximar los valores analógicos
y continuos porque tienen mayor resolución que los
números enteros. Los números de coma flotante pueden ser
tan grandes como 3.4028235E + 38 y tan pequeños como -
3.4028235E + 38. Se almacenan como 32 bits (4 bytes) de
información.

64
Los float tienen sólo 6-7 dígitos decimales de precisión. Eso
significa que el número total de dígitos, no es el número a
la derecha del punto decimal. A diferencia de otras
plataformas, donde se puede obtener una mayor precisión
mediante el uso de un double (por ejemplo, hasta 15
dígitos), en el Arduino, el double es del mismo tamaño que
el float.
Los números de punto flotante no son exactos y pueden
producir resultados extraños si se comparan. Por ejemplo
6.0 / 3.0 puede no ser igual 2.0. En su lugar debe comprobar
que el valor absoluto de la diferencia entre el número es
menor que un número pequeño.
Las operaciones matemáticas de punto flotante también son
mucho más lento que las operaciones matemáticas con
enteros en los cálculos que realizan, por lo que deben
evitarse si, por ejemplo, un bucle tiene que correr a gran
velocidad para una función crítica de sincronización. Los
programadores suelen convertir los cálculos de punto
flotante a entero para aumentar la velocidad.
Si hacemos operaciones matemáticas con float, es necesario
agregar un punto decimal, de lo contrario, será tratado como
unint. Ver la página Constantes de punto flotante para más
detalles.

Ejemplos

float myfloat;

65
 float sensorCalbrate = 1.117;

Sintaxis
float var = val;

 var - el nombre de nuestra variable

 val - el valor asignado a la variable

Example Code

int x;

int y;

float z;

x = 1;

y = x / 2; // y contiene ahora 0, ints que pueden

soportar fracciones

66
 z = (float)x / 2.0; // z contiene ahoa .5 (podriamos usar
2.0, no 2)

short

Descripción
Un short es un tipo de datos de 16-bit.
En todos los Arduinos (ATMega y basados en ARM)
un short almacena un valor de 16-bit (2-byte). Esto produce
un rango de -32,768 to 32,767 (valor mínimo de -2^15 y un
valor máximo de (2^15) - 1).

Ejemplo
short ledPin = 13;

Sintaxis
short var = val;
 var - el nombre de nuestra variable
 val - el valor asignado a la variable

long sin signo

Descripción
Las variables log sin signo son variables de tamaño
extendido para almacenamiento de números y almacenan
números de 32 bits (4 bytes). A diferencia de los long
67
estándar no almacenan números negativos, teniendo un
rango desde 0 a 4,294,967,295 (2^32 - 1).

Ejemplo

unsigned long time;

void setup()

Serial.begin(9600);

void loop()

time = millis();

68
 Serial.print("Time: ");

//imprime el tiempo desde que se inició el programa

Serial.println(time);

// espera un segundo para no enviar un número masivo de

datos

delay(1000);

Sintaxis
unsigned long var = val;

 var - el nombre de nuestra variable

 val - el valor que asignamos a la variable

const
69
La palabra clave const significa constante. Es un
calificador variable que modifica el comportamiento de la
variable, haciendo que sea una variable de "sólo lectura".
Esto significa que la variable se puede utilizar como
cualquier otra variable de este tipo, pero su valor no se
puede cambiar. Obtendrá un error de compilación si se
intenta asignar un valor a una variableconst.
Las constantes definidas con la palabra
clave const obedecen las reglas de alcance de las
variables que gobiernan otras variables. Esto, y los
problemas usando #define, hacen de la palabra
clave const un método superior para la definición de las
constantes y es preferido al uso de #define.

Ejemplo

const float pi = 3.14;

float x;

// ....

x = pi * 2; //uso correcto de la constante en matemáticas

70
pi = 7; // illegal - no se puede escribir (modificar) una
constante

#define o const
Se puede usar const o #define para crear constantes
numéricas o de cadena. Para arrays (matrices), es necesario
usar const. En general const es preferido a #define para
definir constantes.

volatile
volatile es una palabra clave conocidad como qualifier
(cualificadora), se usa usualmente antes del tipo de datos
de una variable, para modificar la manera en que el
compilador y el programa deben tratar a esta variable.
La declaración de una variable volatile es una directiva del
compilador. El compilador es un software que traduce el
código C/C ++ en el código de máquina, que son las
instrucciones reales para el chip Atmel en el Arduino.

71
Específicamente, el compilador carga la variable de RAM
y no de un registro de almacenamiento, que es una
ubicación de memoria temporal donde se almacenan y
manipulan las variables del programa. Bajo ciertas
condiciones, el valor de una variable almacenada en los
registros puede ser inexacto.
Una variable debe ser declarada volatile cada vez que su
valor pueda ser cambiado por algo más allá del control de
la sección de código en la que aparece, como otro código
que se ejecuta simultáneamente. En el Arduino, el único
lugar que es probable que esto ocurra es en secciones de
código asociadas a las interrupciones, que llaman a una
rutina de servicio de interrupción.

Ejemplo

// conmuta un LED cuando una interrupción cambia es

estado de un pin

int pin = 13;

volatile int state = LOW;

void setup()

{
72
void loop()

pinMode(pin, OUTPUT);

attachInterrupt(0, blink, CHANGE);

digitalWrite(pin, state);

void blink()

state = !state;

73
static
La palabra clave static se usa para crear variables que solo
son visibles dentro de una función.Sin embargo a diferencia
de las variables locales que se crean y destruyen cada vez
que se invoca una función, las variables estatic persisten
más allá de la llamada a la función, preservan sus datos
entre llamadas a funciones.
Las variables declaradas como static sólo se crean e
inicializan la primera vez que una función se llama.

Ejemplo

/* Paseo aleatorio

* Paul Badger 2007

* Paseo aleatorio se pasea arriba y abajo al azar entre dos

* puntos finales. La medida máxima en un bucle se rige

por

* Una variable estática se mueve hacia arriba y hacia abajo

una cantidad aleatoria.
74
* el parámetro "stepsize" (tamaño del paso).

#define randomWalkLowRange -20

* Esta técnica también se conoce como "ruido rosa" y

"caminar borracho".

*/

#define randomWalkHighRange 20

{ // comprueba la función randomWalk

int stepsize;

int thisTime;

int total;

void setup()
75
{

Serial.begin(9600);

void loop()

stepsize = 5;

static int place; // variable para almacenar el valor de

random walk - declarada static ya almacenada

thisTime = randomWalk(stepsize);

Serial.println(thisTime);

delay(10);

int randomWalk(int moveSize){

place = place + (random(-moveSize, moveSize + 1));

76
//valores entre llamadas a funciones, pero otras funciones
no pueden cambiar su valor

if (place < randomWalkLowRange){ //

comprueba los límites alto y bajo

place = place - (place - randomWalkHighRange);

//refleja el número de vuelta en dirección negativa

place = place + (randomWalkLowRange - place); //

refleja el número de vuelta en dirección positiva

else if(place > randomWalkHighRange){

return place;

77
Alcance de las variables
Las variables en el lenguaje de programación C, que utiliza
Arduino, tienen una propiedad denominada alcance. Esto
está en contraste con las primeras versiones de lenguajes
como BASIC donde cada variable es una variable global.

Una variable global es una variable que puede ser vista por
cada función en un programa. Las variables locales son
accesibles solamente a la función en la que se declaran. En
el entorno de Arduino, cualquier variable declarada fuera
de una función (por ejemplo, setup (), loop (), etc.), es una
variable global.

Cuando los programas comienzan a hacerse más grandes y

más complejos, las variables locales son una forma útil para
asegurar que sólo una función tiene acceso a sus propias
variables. Esto evita errores de programación, cuando una
función inadvertidamente modifica variables utilizadas por
otra función.

A veces también es útil declarar e inicializar una variable

dentro de un bucle. Esto crea una variable que sólo se puede
acceder desde el interior de las llaves del bucle.

Ejemplo:

int gPWMval; // cualquier función verá esta variable

78
void setup()

// ...

void loop()

float f; // "f" is only "visible" inside of "loop"

int i; // "i" solo es "visible" dentro de "loop"

// ...

for (int j = 0; j <100; j++){

79
 // la variable j solo está accesible dentro de las llaves del
bucle for

float()
Descripción

Convierte un valor al tipo de datos float.

Sintaxis

float(x)

Parámetros

x: un valor de cualquier tipo

Rrtornos

float

Notas

Ver la referencia float para más detalles acerca de la precisiñon y limitaciones

de los números de coma flotante en Arduino.

long()
Descripción

Convierte un valor en un tipo de datos long.

Sintaxis

long(x)

80
Parámetros

x: un valor de cualquier tipo

Retornos

long

word()
Descripción

Convierte un valor al tipo de datos word o crea una palabra (word) de dos
bytes.

Sintaxis

word(x)
word(h, l)

Parámetros

x: un valor de cualquier tipo

h: el byte más alto (más a la izquierda) de la palabra

l: el byte más bajo (más a la derecha) de la palabra

Retornos

word

int()
Descripción

Convierte un valor al tipo de datos int.

81
Sintaxis

int(x)

Parámetros

x: un valor de cualquier tipo

Retornos

int

byte()
Descripción

Convierte un valor al tipo de datos byte.

Sintaxis

byte(x)

Parameters

x:un valor de cualquier tipo

Retornos

byte

analogReference()

Descripción
Configurala tensión de referencia usada para las entradas
analógicas (por ejemplo, el valor utilizado como la parte
superior del rango de entrada). Las opciones son:

82
 DEFAULT: la referencia analógica por defecto, 5 V (en
placas Arduino alimentadas a 5 V) o 3.3 V (en
placas Arduino alimentadas a 3.3 V)
 INTERNAL: una referencia incorporada, igual a 1.1 voltios
en elATmega168 o ATmega328 y 2.56 voltios en
el ATmega8 (no disponible en el Arduino Mega)
 INTERNAL1V1: una referencia incorporada de 1.1 V
(solo Arduino Mega )
 INTERNAL2V56: una referencia incorporada de 2.56 V
(solo Arduino Mega)
 EXTERNAL: la tensión aplicada al pin AREF (solo de 0 a5
V) se usa como referencia.

Sintaxis
analogReference(type)

Parámetros
type: el tipo de referencia a usar (DEFAULT,
INTERNAL, INTERNAL1V1, INTERNAL2V56 o
EXTERNAL).

Retornos
Ninguno.

Note
Después de cambiar la referencia analógica, las primeras
lecturas de analogRead () puede que no sean exactas.

Advertencia
¡No utilice cualquier tensión menor de 0 V o mayor de 5 V
como tensión de referencia externa en el pin AREF! Si está

83
utilizando una referencia externa en el pin AREF, debe
establecer la referencia analógica a EXTERNAL antes de
llamar analogRead (). De lo contrario, se produde un
cortocircuito entre la tensión de referencia interna
(generada internamente) y la tensión aplicada al pin AREF,
dañando posiblemente el microcontrolador de la placa
Arduino.
Como alternativa, puede conectar la tensión de referencia
externa al pin AREF a través de una resistencia de 5 K, que
le permite cambiar entre las tensiones de referencia externa
e internas. Tenga en cuenta que la resistencia va a alterar la
tensión que se usa como referencia porque hay una
resistencia interna de 32 K en el pin AREF. Las dos actúan
como un divisor de tensión, por lo que, por ejemplo, 2,5 V
aplicados a través de la resistencia producirá 2,5 * 32 / (32
+ 5) = ~ 2,2 V en el pin AREF.

digitalRead()

Descripción
Lee el valor de un pin digital especificado, puede
ser HIGH o LOW.

Sintaxis
digitalRead(pin)

Parámetros
pin: el número de pin digital que se quiere leer (int)

84
Retornos
HIGH o LOW

Ejemplo
Establece el pin 13 con el mismo valor que el pin 7,
declarado como una entrada.
int ledPin = 13; // LED conectado al pin digital 13
int inPin = 7; // pulsador conectado al pin digital 7
int val = 0; // variable para almacenar el valor leido

void setup()
{
pinMode(ledPin, OUTPUT); // configura el pin digital
13como salida
pinMode(inPin, INPUT); // configura el pin digital 7
como entrada
}

void loop()
{
val = digitalRead(inPin); // lee el pin de entrada
digitalWrite(ledPin, val); // configura el pin del LED al
mismo valor que el pulsador
}

85
Nota
Si el pin no está conectado a nada, digitalRead () puede
devolver HIGH o LOW (y esto puede cambiar
aleatóriamente).
Los pines de entrada analógica se puede utilizar como pines
digitales, refiriendonos a ellos como A0, A1, etc.

digitalWrite()

Descripción
Escribe un valor HIGH o un valor LOW en un pin digital.
Si el pin ha sido configurado como OUTPUT
con pinMode(), su voltaje se establece en el valor
correspondiente: 5V (o 3.3 V en placas de 3.3 V) para
HIGH, 0 V (masa) para LOW.
Si el pin se configura como INPUT, digitalWrite() activará
(HIGH) o desactivará(LOW) las resistencias pullup
enternas en el pin de entrada. Es recomendable
configurar pinMode() aINPUT_PULLUP para habilitar las
resistencias pull-up internas. Ver el tutorial digital
pins para más información.
NOTA: Si no se configura pinMode () como salida, y se
conecta un LED a un pin, al llamar digitalWrite (HIGH), el
LED aparece apagado. Sin establecer explícitamente
pinMode (), digitalWrite () han permitido a la resistencia
pull-up interna, que actúe como una gran resistencia
limitadora de corriente.

86
Sintaxis
digitalWrite(pin, value)

Parameters
pin: el número de pin
value: HIGH o LOW

Retornos
Ninguno

Ejemplo

int ledPin = 13; // LED conectado al pin digital

13

void setup()

pinMode(ledPin, OUTPUT); // configura el pin digital

como salida

87
void loop()

digitalWrite(ledPin, HIGH); // enciende el LED

digitalWrite(ledPin, LOW); // apaga el LED

delay(1000); // espera un segundo

delay(1000); // espera un segundo

Pone el pin 13 a nivel HIGH, durante un segundo, hace un

retraso de un segundo, pone el pin a nivel LOW.

Nota
Los pines de entrada analógica pueden usarse como pines
digitales, refiriéndose a ellos como A0, A1, etc.

pinMode()

88
Descripción
Configura el pin especificado para comportarse como una
entrada o como una salida. Ver la descripción de digital
pins para ver detalles sobre la funcionalidad de los pines.
A partir de Arduino 1.0.1, es posible activar las resistencias
pull-up internas con el modo INPUT_PULLUP. Además, el
modo INPUT desactiva de forma explícita las pull ups
internas.

Sintaxis
pinMode(pin, mode)

Parameters
pin: el número de pin cuyo modo queremos configurar
mode: INPUT, OUTPUT, o INPUT_PULLUP. (ver la
página digital pins para una descripción más completa de
esta funcionalidad.)

Retornos
Ninguno

Ejemplo

int ledPin = 13; // LED conectado al pin digital

13

void setup()
{

89
 pinMode(ledPin, OUTPUT); // configura el pin como
salida
}

void loop()
{
digitalWrite(ledPin, HIGH); // enciende el LED
delay(1000); // espera un segundo
digitalWrite(ledPin, LOW); // apaga el LED
delay(1000); // espera un segundo
}

Nota
Los pines de entrada analógica se pueden utilizar como
pines digitales, referenciandolos como A0, A1, etc.

PROGMEM
Almacena datos en la memoria flash (memoria de
programa) en lugar de la SRAM. En este enlace hay una
descripción de varios tipos de memoia disponibles en una
placa Arduino.
La palabra clave PROGMEM es un nodificador de variable,
debe ser usada solo con los tipos de datos definidos en la
biblioteca pgmspace.h. Se le dice al compilador "poner esta
información en la memoria flash", en lugar de en la SRAM,
donde normalmente iría.

90
 PROGMEM es parte de la biblioteca pgmspace.h que está
disponible solo en la arquitectura AVR. Por lo que primero
necesita incluir la biblioteca en la parte superior de su
boceto, como esto:
#include <avr/pgmspace.h>

Sintaxis
const dataType
variableName[] PROGMEM = {data0, data1, data3...};
 - dataType - cualquier tipo de variable
 - variableName - el nombre de nuesto dato o matriz


Tenga en cuenta que debido a que PROGMEM es un

modificador de la variable, no hay ninguna regla dura y
rápida acerca de donde debe ir, por lo que el compilador de
Arduino acepta todas las definiciones de más abajo, que
también son sinónimos. Sin embargo los experimentos han
indicado que, en varias versiones de Arduino (que tienen
que ver con la versión de GCC), PROGMEM puede trabajar
en un lugar y no en otro. El ejemplo "tabla de cadenas"
siguiente ha sido probado para trabajar con Arduino 13. Las
versiones anteriores del IDE pueden funcionar mejor si se
incluye PROGMEM después del el nombre de la variable.
const dataType variableName[] PROGMEM = {}; // usar
este formato
const PROGMEM dataType variableName[] = {}; // o
este formato
const dataType PROGMEM variableName[] = {}; // no
usar este

91
Mientras que PROGMEM podría ser utilizado con una sola
variable, realmente sólo vale la pena el trabajo si se tiene un
bloque más grande de datos que necesitan ser almacenados,
que suele ser más fácil en una matriz, (u otra estructura de
datos C más allá de nuestra presente discusión) .
El uso de PROGMEM es un procedimiento de dos pasos.
Después de obtener los datos en la memoria Flash, que
requiere métodos especiales (funciones), también definidas
en la biblioteca pgmspace.h leemos de nuevo los datos de
la memoria de programa en SRAM, por lo que podemos
hacer algo útil con él.

Ejemplo
El siguiente fragmento de código ilustra como podemos leer
y escribir caracteres (bytes) e ints (2 bytes) en PROGMEM.
#include <avr/pgmspace.h>

//guarda algunos ints sin digno

const PROGMEM uint16_t
charSet[] = { 65000, 32796, 16843, 10, 11234};

// guarda algunos caracteres

const char signMessage[] PROGMEM = {"YO SOY
PREDATOR, COMBATIENTE INVISIBLE . CREADO
POR EL DEPARTAMENTO DE LOS ESTADOS
UNIDOS"};

unsigned int displayInt;

int k; // contador de la variable
92
char myChar;

void setup() {
Serial.begin(9600);
while (!Serial);

// aquí se pone el código de setup para ejecutar una sola

vez:
// lee de nuevo un int de 2 bytes
for (k = 0; k < 5; k++)
{
displayInt = pgm_read_word_near(charSet + k);
Serial.println(displayInt);
}
Serial.println();

//lee de nuevo un caracter

int len = strlen_P(signMessage);
for (k = 0; k < len; k++)
{
myChar = pgm_read_byte_near(signMessage + k);
Serial.print(myChar);
}

Serial.println();
93
}

void loop() {
// aquí ponemos el código principal que se ejecuta
repetidamente:

}
Matriz de cadenas
A menudo es conveniente cuando se trabaja con grandes
cantidades de texto, como un proyecto con una pantalla
LCD, configurar una matriz de cadenas. Debido a que las
cadenas en sí son arrays, esto es en realidad un ejemplo de
una matriz de dos dimensiones.
Estas tienden a ser grandes estructuras para su puesta en
memoria de programa que a menudo es deseable. El código
siguiente ilustra la idea.

/*
Demo de PROGMEM con cadenas
Como almacenar una tabla de cadenas en la memoria de
programa (flash),
y recuperarles después

Información redumida de:

http://www.nongnu.org/avr-libc/user-
manual/pgmspace.html

94
 La creación de una tabla (array)de cadenas en la memoria
de programa es algo complicado pero
aquí tenemos una plantilla para hacerlo.

La configuración de las cadenas es un proceso de dos

pasos. Primero definimos las cadenas
*/

#include <avr/pgmspace.h>
const char string_0[] PROGMEM = "String 0"; // "String
0" etc son cadenas a guardar .
const char string_1[] PROGMEM = "String 1";
const char string_2[] PROGMEM = "String 2";
const char string_3[] PROGMEM = "String 3";
const char string_4[] PROGMEM = "String 4";
const char string_5[] PROGMEM = "String 5";

// Después definir una tabla para referirse a nuestras

cadenas.

const char* const

string_table[] PROGMEM = {string_0, string_1, string_2,
string_3, string_4, string_5};

char buffer[30]; // asegurarse de que esto es lo suficiente

grande para la mayor cadena

95
void setup()
{
Serial.begin(9600);
while(!Serial);
Serial.println("OK");
}

void loop()
{

/* El uso de una tabla de cadenas en la memoria de

programa necesita funciones especiales para
recuperar los datos.
La función strcpy_P copia una cadena desde el espacio
de programa a una cadena en la RAM ("buffer").
Asegurarse de que la cadena recibida en la RAM es tan
grande como para alojar cualquier cadena recuperada
del espacio de memoria */

for (int i = 0; i < 6; i++)

{
strcpy_P(buffer, (char*)pgm_read_word(&(string_table
[i]))); // Necessary casts and dereferencing, just copy.
Serial.println(buffer);
delay( 500 );
}
96
}
Noa

Tenga en cuenta que las variables deben definirse como

globales, o definidas con la palabra clave static, para poder
trabajar con PROGMEM.
El siguiente código no trabajará dentro de una función:
const char long_str[] PROGMEM = "Hola, me gustaría
contarles un poco acerca de mí mismo.\n";

El siguiente código funciona, incluso si está definido a nivel

local dentro de una función:
const static char long_str[] PROGMEM = "Hola, me
gustaría contarles un poco acerca de mí mismo.\n"

La macro F()
Cuando una instrucción similar a esta :
Serial.print("Escribe algo en el Monitor Serie");
se utiliza, la cadena que se va a imprimir se guarda
normalmente en la memoria RAM. Si el sketch imprime un
montón de cosas en el monitor serie, puede llenar
fácilmente la memoria RAM. Si tenemos espacio libre en la
memoria FLASH, fácilmente podemos indicar que la
cadena debe estar guardada en flash utilizando la sintaxis:
Serial.print(F("Escribe algo en el monitor de serie que se
almacena en FLASH"));

97
sizeof

Descripción
El operador sizeof devuelve el número de bytes de un tipo
variable, o el número de bytes ocupados por una matriz.

Sintaxis
sizeof(variable)

Parámetros
variable: cualquier tipo de variable o matriz (por ejemplo,
int, float, byte)

Example de código
El operador sizeof es útil para trabajar con arrays (tales
como cadenas) donde es conveniente ser capaz de cambiar
el tamaño de la matriz sin romper otras partes del programa.
Este programa imprime una cadena de texto un carácter
cada vez. Intente cambiar la frase de texto.
char myStr[] = "Esto es una prueba";
int i;

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

void loop() {
for (i = 0; i < sizeof(myStr) - 1; i++){
98
 Serial.print(i, DEC);
Serial.print(" = ");
Serial.write(myStr[i]);
Serial.println();
}
delay(5000); //ralentiza el programa
}

Tenga en cuenta que sizeof devuelve el número total de

bytes. Así que para los tipos de variables de mayor tamaño
como int, el bucle for sería algo como esto. Tenga en cuenta
también que una cadena con el formato adecuado termina
con el símbolo NULL, que tiene un valor ASCII 0.
for (i = 0; i < (sizeof(myInts)/sizeof(int)); i++) {
//hacer algo con myInts [i]
}

sqrt(x)
Description

Calcula la raíz cuadrada de un número.

Parámetros

x: el número, cualquier tipo de datos

Retornos

double, la raíz cuafrada del número.

Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con FacebookCompartir en Pinterest

99
pow(base, exponent)
Descripción

Calcula el valor de un número elevado a una potencia. Pow () se puede utilizar

para elevar un número a una potencia fraccionaria. Esto es útil para la
generación de aplicación exponencial de los valores o curvas.

Parámetros

base: el número (float)

exponent: la potencia a la que se eleva la base (float)

Retorno

El resultado de la exponenciación (double)

Ejemplo

Ver la función fscale en las bibliotecas.

map(value, fromLow, fromHigh, toLow, toHigh)

Descripción
Re-asigna un número de una gama a otra. Es decir, un valor
de fromLow sería asignado a toLow, un valor offromHigh
a toHigh, los valores intermedios a valores intemedios, etc.
No restringe los valores dentro del rango, ya que los valores
fuera de la gama a veces se entiende que son útiles. La
función constrain () se puede usar antes o después de esta
función, si se desean límites de los intervalos.

100
Tenga en cuenta que los "límites inferiores" de cualquier
rango pueden ser más grandes o más pequeños que los
"límites superiores" para que la función map () se pueda
usar para revertir una serie de números, por ejemplo
y = map(x, 1, 50, 50, 1);
La función también funciona con números negativos, según
este ejemplo
y = map(x, 1, 50, 50, -100);
y también funciona con palabras.
La función map () usa números enteros por lo que no va a
generar decimales, cuando las operaciones matemáticas
podrían indicar que debería hacerlo. Los decimales
remanentes se truncan, y no son redondeados o
promediados.

Parámetros
value: el número a mapear
fromLow: el límite inferior del rango actual del valor
fromHigh: el límite superiordel rango actual del valor
toLow: el límite inferior del rango resultado del valor
toHigh: el límite superiordel rango resultado del valor

Retornos
El valor mapeado.

Ejemplo
/* Mapea un valor analógico de 8 bits (0 a255) */

101
void setup() { }

void loop()

int val = analogRead(0);

val = map(val, 0, 1023, 0, 255);

analogWrite(9, val);

Apéndice
Para lo amantes de las mayemáticas, aquí está toda la función
long map(long x, long in_min, long in_max, long out_min, long out_max)

return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;

constrain(x, a, b)
Descripción

Restringe un número para estar dentro de un rango.

Parámetro

x: el número a restringir, todos los tipos de datos

a: el número más bajo del rango, todos los tipos de datos

b: el número más alto del rango, todos los tipos de datos

102
Returns

x: ai x está entre a y b

a: sif x es menor que a

b: si x es mayor que b

Ejemplo
sensVal = constrain(sensVal, 10, 150);

// limita el rango del sensor entre 10 y 150

abs(x)
Descripción

Calcula el valor absoluto de un número.

Parámetro

x: el número

Retornos

x: si x es mayor o igual a 0.

-x: si x es menor que 0.

Advertencia

Debido a la forma en que se implementa la función abs (), evitar el uso de

otras funciones dentro de los corchetes, ya puede dar lugar a resultados
incorrectos.
abs(a++); // evitar esto - produce resultados incorrectos

abs(a);
a++; // utilizar esto en su lugar - mantener a otras operaciones matemáticas fuera de la
función

103
max(x, y)
Descripción

Calcula el máximo de dos números.

Parámetros

x: el primer número, cualquier tipo de datos

y: el segundo número, cualquier tipo de datos

Retornos

El mayor de los dos números.

Ejemplos

sensVal = max(sensVal, 20); //asigna sensVal al mayor de sensVal o 20

//asegurando que siempre al menos es 20

Nota

Tal vez el contador-intuitivo, max () se utiliza a menudo para limitar el

extremo inferior del rango de una variable, mientras min () se utiliza para
restringir el extremo superior de la gama.

Advertencia

Debido a la forma en que se implementa la función max (), evitar el uso de

otras funciones dentro de los corchetes, ya puede dar lugar a resultados
incorrectos

min(a--, 0); // evitar esto - produce resultados incorrectos

min(a, 0);
a--; //utilizar esto en su lugar - mantener a otras operaciones matemáticas fuera de la función

104
min(x, y)
Descripción

Calcula el mínimo de dos números.

Parámetros

x: el primer número, cualquier tipo de datos

y: el segundo número, cualquier tipo de datos

Retornos

El menor de los dos números.

Ejemplos

sensVal = min(sensVal, 100); //asigna sensVal al menor de sensVal o 100

//asegurando que nunca se pone por encima de 100.

Nota

Tal vez el contador-intuitivo, max () se utiliza a menudo para limitar el extremo

inferior del rango de una variable, mientras min () se utiliza para restringir el
extremo superior de la gama.

Advertencia
Debido a la forma en que se implementa la función min (), evitar el uso de otras
funciones dentro de los corchetes, ya puede dar lugar a resultados incorrectos
min(a++, 100); // evitar esto - produce resultados incorrectos
min(a, 100);
a++; //utilizar esto en su lugar - mantener a otras operaciones matemáticas fuera
de la función

delayMicroseconds()

105
Descripción
Hace una pausa en el programa porla cantidad de tiempo (en
microsegundos) especificado como parámetro. Hay mil microsegundos
en una milésima de segundo, y un millón de microsegundos en un
segundo.
En la actualidad, el valor más grande que producirá un retardo
preciso es 16383. Esto podría cambiar con la futuras versiones de
Arduino. Para retardos de más de unos pocos miles de
microsegundos, debe usarse delay() en su lugar.

Sintaxis

delayMicroseconds(us)

Parámetros

us: el número de microsegundos a esperar (int sin signo)

Retuornos

Ninguno

Ejemplo
int outPin = 8; // digital pin 8

void setup()
{
pinMode(outPin, OUTPUT); // sets the digital pin as output
}

void loop()
{
digitalWrite(outPin, HIGH); // sets the pin on
delayMicroseconds(50); // pauses for 50 microseconds
digitalWrite(outPin, LOW); // sets the pin off
delayMicroseconds(50); // pauses for 50 microseconds
}

configura el número de pin 8 para trabajar como un pin de salida. Se envía un

tren de pulsos de un periodo de aproximadamente 100 microsegundos. La
aproximación es debida a la ejecución de las otras instrucciones en el código.

106
Advertencias y Problemas conocidos
Esta función trabaja con mucha precisión en el rango de 3
microsegundos y más alto. No podemos asegurar que
delayMicroseconds funcione con un reatrdo menor.
A partir de Arduino 0018, delayMicroseconds () ya no desactiva las
interrupciones.

micros()
Descripción
Devuelve el número de microsegundos desde la que placa Arduino
empezó a ejecutar el programa actual. Este número se desbordará
(volverá a cero), después de aproximadamente 70 minutos. En placas
Arduino de 16 MHz (por ejemplo Duemilanove y Nano), esta función
tiene una resolución de cuatro microsegundos (es decir, el valor
devuelto es siempre un múltiplo de cuatro). En las placas Arduino 8
MHz (por ejemplo, la LilyPad), esta función tiene una resolución de
ocho microsegundos.
Nota: hay 1.000 microsegundos en un milisegundo y 1.000.000
microsegundos en un segundo.

Parámetros

Ninguno

Retornos

Número de microsegundos desde que se inició el programa (long sin signo)

Ejemplo
unsigned long time;

void setup(){

Serial.begin(9600);

107
}

void loop(){

Serial.print("Time: ");

time = micros();

//prints time since program started

Serial.println(time);

// wait a second so as not to send massive amounts of data

delay(1000);

millis()

Descripción
Devuelve el número de milisegundos desde que la placa
Arduino empezó a ejecutar el programa actual. Este número
se desbordará (volverá a cero), después de
aproximadamente 50 días.

Parámetros
Ninguno

Retornos
Número de milisegundos desde que el programa se inició
(long sin signo)

108
Nota:
Tenga en cuenta que el valor de retorno para millis () es un
long sin signo, pueden producirse errores lógicos si un
programador intenta hacer operaciones aritméticas con
tipos de datos más pequeños, como de tipo int. Incluso los
log con signo pueden producir errores como que su valor
máximo sea la mitad que la de su contraparte sin signo.

Ejemplo
unsigned long time;

void setup(){

Serial.begin(9600);

void loop(){

Serial.print("Time: ");

time = millis();

//prints time since program started

Serial.println(time);

// wait a second so as not to send massive amounts of data

delay(1000);

pulsein()

109
Descripción
Lee un pulso (HIGHo LOW) en un pin. Por ejemplo, si el valor es
alto, pulseIn () espera a que el pin pase a nivel HIGH, se inicia el tiempo, espera
a que el pin pase a nivel LOW y para el cronómetro. Devuelve la longitud del
impulso en microsegundos o 0 si no se recibe un pulso completo dentro del
tiempo de espera.
La temporización de esta función se ha determinado empíricamente y
probablemente mostrará errores en los pulsos más cortos. Funciona en pulsos
de 10 microsegundos a 3 minutos de duración. Tenga en cuenta también que si
el pin ya está a nivel HIGH cuando la función es llamada, se espera que el pin
pase a nivelLOW y luego a nivel HIGH antes de que empiece a contar. Esta
rutina se puede utilizar sólo si se activan las interrupciones. Por otra parte la
resolución más alta se obtiene con intervalos cortos.

Sintaxis
pulseIn (pin, value)

pulseIn (pin, value, timeout)

Parámetros
pin: el número de pin en el que desea leer el pulso. (int)

value: tipo de pulso a leer: HIGH o LOW. (int)

timeout (opcional): el número de microsegundos que espera a que el pulso se

complete: la función devuelve 0 si el pulso completo no se recibe dentro del
tiempo de espera. Por defecto es de un segundo (unsigned long).
timeout, si se usa, es recomendable que sea, al menos, 1,3 veces sueperior a la
duración del pulso a medir. Por ejemplo, si se mide un pulso de duración 0,01
segundo, timeout deber ser al menos 13000.

110
Retornos
La longitud del pulso (en microsegundos) o 0 si el pulso no se completa dentro
del tiempo de espera (long sin signo)

Ejemplo
Este ejemplo muestra en el monitor serie la duración del impulso aplicado a la entrada 2 del Arduino.

A partir de la duración del impulso se calcula la frecuencia y el número de pulsos por segundo.

El pulso puede provenir de un generador de pulsos en general o también se puede generar con otra
placa Arduino mediante un sketch que simule un tren de pulsos.

float Pulso;
float Tiempo = 0;
float Frecuencia = 0;
int NumeroPulsos = 0;
void setup ()
{
Serial.begin (9600);
}

void loop ()
{
Pulso = pulseIn (2, HIGH, 15000);
Tiempo = Pulso / 1000000;
if (Tiempo > 0.001)
{
Serial.print ("Duracion del pulso: ");
Serial.print (Tiempo);
Serial.println (" segundos");
Serial.println (" ");
}

Frecuencia = 1 / Tiempo;
Serial.print ("Frecuencia: ");
Serial.print (Frecuencia);
Serial.println (" Hz");
Serial.println (" ");

NumeroPulsos = Frecuencia * 60;

Serial.print ("Numero de pulsos/segundo: ");
Serial.println (NumeroPulsos);
Serial.println (" ");
Serial.println (" ");

111
delay (1000);
}

shiftIn()

Descripción
Desplaza un byte de datos un bit cada vez. Comienza a
partir del bit más significativo (más a la izquierda) o menos
significativo (más a la derecha). Para cada bit, el pin de reloj
pasa a nivel alto, el siguiente bit se lee de la línea de datos
y, a continuación el pin de reloj pasa a nivel bajo.
Si vamos a interactuar con un dispositivo que está
sincronizado por flancos de subida, necesitamos
asegurarnos de que el pin de reloj está en estado bajo antes
de la primera llamada a shiftIn() con una llamada a
digitalWrite (pinReloj, LOW).
Nota: esta es una aplicación de software; Arduino también
proporciona una librería SPI que utiliza la implementación
de hardware, que es más rápido, pero sólo funciona en pines
específicos.
Sintaxis

byte incoming = shiftIn(dataPin, clockPin, bitOrder)

Parámetros

112
dataPin: el pin en el que entra cada bit (int)
clockPin: el pin que cambia cuando se hace una lectura
con dataPin
bitOrder: la dirección en que se desplazan los bits de
entrada; MSBFIRST or LSBFIRST.

(Primero el Bit Más Significativo, o, Primero el Bit Menos

Significativo)

Retornos
el valor leido (byte)

shiftIn()

Descripción
Desplaza un byte de datos un bit cada vez. Comienza a
partir del bit más significativo (más a la izquierda) o menos
significativo (más a la derecha). Para cada bit, el pin de reloj
pasa a nivel alto, el siguiente bit se lee de la línea de datos
y, a continuación el pin de reloj pasa a nivel bajo.
Si vamos a interactuar con un dispositivo que está
sincronizado por flancos de subida, necesitamos
asegurarnos de que el pin de reloj está en estado bajo antes
de la primera llamada a shiftIn() con una llamada a
digitalWrite (pinReloj, LOW).
Nota: esta es una aplicación de software; Arduino también
proporciona una librería SPI que utiliza la implementación
113
de hardware, que es más rápido, pero sólo funciona en pines
específicos.
Sintaxis

byte incoming = shiftIn(dataPin, clockPin, bitOrder)

Parámetros

dataPin: el pin en el que entra cada bit (int)

clockPin: el pin que cambia cuando se hace una lectura
con dataPin
bitOrder: la dirección en que se desplazan los bits de
entrada; MSBFIRST or LSBFIRST.

(Primero el Bit Más Significativo, o, Primero el Bit Menos

Significativo)

Retornos
el valor leido (byte)

tone()

114
Description
Genera en un pin una onda cuadrada de la frecuencia
especificada (y ciclo de trabajo del 50%). Se puede
especificar una duración, de lo contrario la onda continúa
hasta una llamada a noTone(). El pin puede ser conectado a
un zumbador piezoeléctrico o a un altavoz para reproducir
tonos.
Sólo un tono puede ser generado a la vez. Si un tono ya se
está reproduciendo en un pin diferente, la llamada a tono ()
no tendrá ningún efecto. Si el tono se está reproduciendo en
el mismo pin, la llamada ajustará su frecuencia.
El uso de la función tone () interferirá con la salida PWM
en los pines 3 y 11 (en las placas distintas de la Mega).
Frecuencia Mín. Frecuencia Máx
Placa
(Hz) (Hz)

Uno, Mega, Leonardo y otras placas 31 65535

AVR
Gemma No implementado No implementado
Zero 41 275000
Due No implementado No implementado

Para detalles técnicos ver las notas Brett Hagman's.

NOTA: Si desea reproducir tonos diferentes en varios
pines, es necesario llamar noTone () en un pin antes de
llamar a tone () en el siguiente pin.

Sintaxis
tone(pin, frequency)
tone(pin, frequency, duration)

115
 Parámetros
pin: el pin en el que se quiere generar el tono
frequency: la frecuencia del tono en hertzios - int sin signo
duration: la duración del tono en milisegundos (opcional)
- long sin signo

Retornos
Ninguno

analogWriteResolution()

Descripción
analogWriteResolution()es una extensión de Analog API
para los Arduino Due y Zero.
analogWriteResolution() configura la resolución de la
función analogWrite(). Esta resolución es, por defecto, de 8
bits (valores entre 0 y 255) para compatibilidad con las
placas basadas en AVR.
El Due tiene las siguientes capacidades de hardware:
 - 12 pines que, por defecto, son PWM de 8-bit, al igual que
las placas basadas en AVR. Esta resolución se puede
cambia a 12-bit .
 - 2 pins con DAC (Convertidoa Digital a Analógico) de 12-
bit

116
 Cambiando la resolución de escritura a 12, se puede utilizar
analogWrite () con valores entre 0 y 4095 para explotar la
resolución completa del DAC o para ajustar la señal de
PWM sin darse la vuelta (rolling over).
ElZero tiene las siguientes capacidades hardware:
 - 10 pines que, por defecto, son PWM de 8-bit, igual que las
placas basadas en AVR. Esta resolución se puede cambiar
a 12-bit.
 - 1 pin conDAC (Convertidor Digital a Analógico) de 10-
bit .

Cambiando la resolución de escritura a 10, se puede utilizar

analogWrite () con valores entre 0 y 1023 para explotar la
resolución completa del DAC

Sintaxis
analogWriteResolution(bits)

Parámetros
bits: determina la resolución (en bits) de los valores
utilizados en la función analogWrite (). El valor puede
oscilar entre 1 y 32. Si se selecciona una resolución más alta
o más baja que las capacidades del hardware de la placa, el
valor utilizado en analogWrite () será truncado si es
demasiado alto o rellenado con ceros si es demasiado bajo.
Véase la nota a continuación para más detalles.

Retornos
Ninguno.

117
Nota
Si se establece el valor analogWriteResolution () a un valor
más alto que las capacidades de la placa, el Arduino,
descartará los bits adicionales. Por ejemplo: el uso de la Due
con analogWriteResolution (16) en un pin DAC de 12 bits,
sólo los primeros 12 bits de los valores pasados a
analogWrite () se utilizan y se descartarán los últimos 4 bits.
Si se establece el valor analogWriteResolution () a un valor
inferior a las capacidades de la placa, las partes que faltan
serán rellenadas con ceros para completar el tamaño del
hardware requerido. Por ejemplo: el uso de la Due con
analogWriteResolution (8) en un pin DAC de 12 bits, el
Arduino sumará 4 bits cero al valor de 8 bits utilizado en
analogWrite () para obtener los 12 bits requeridos.
Example
void setup(){
// abre la conexión serie
Serial.begin(9600);
// configura los pines digitales como salidas
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
}

void loop(){
// lee la entrada A0 y la mapea al pin PWM
// con un LED conectado
int sensorVal = analogRead(A0);
Serial.print("Analog Read) : ");
Serial.print(sensorVal);

// la resolución PWM por defecto

analogWriteResolution(8);
analogWrite(11, map(sensorVal, 0, 1023, 0 ,255));
Serial.print(" , valor PWM de 8-bit: ");

Serial.print(map(sensorVal, 0, 1023, 0 ,255));

// cambia la resolución PWM a 12 bits

118
 // la resolución de 12 bit solo es soportada
// por el Due
analogWriteResolution(12);
analogWrite(12, map(sensorVal, 0, 1023, 0, 4095));
Serial.print(" , 12-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0, 4095));

// cambia la resolución PWM a 4 bits

analogWriteResolution(4);
analogWrite(13, map(sensorVal, 0, 1023, 0, 127));
Serial.print(", 4-bit PWM value : ");
Serial.println(map(sensorVal, 0, 1023, 0, 127));

delay(5);
}

analogReadResolution()

Description
analogReadResolution() es una extensión de la Analog API
para los Arduino Due y Zero.
Configura el tamaño (en bits) del valor devuelto por
analogRead (). Su valor predeterminado es 10 bits
(devuelve valores entre 0 y 1023) para la compatibilidad
con placas basadas AVR.
El Due y el Zero tienen capacidades ADC de 12 bits a las
que se puede acceder cambiando la resolución a 12. Esto
devolverá los valores de analogRead () entre 0 y 4095.

Sintaxis
analogReadResolution(bits)

Parámetross
bits: determina la resolución (en bits) del valor devuelto por
la función () analogRead. Puede establecer este entre 1 y 32.
Se pueden ajustar resoluciones superiores a 12 pero los
valores devueltos por analogRead () sufrirán
119
una aproximación. Véase la nota a continuación para más
detalles.

Retornos
Ningubo.

Nota
Si se establece el valor de analogReadResolution () a un
valor más alto que las capacidades de la placa, el Arduino
sólo informará en su mayor resolución rellenando los bits
extra con ceros.
Por ejemplo: el uso de la Due o la Zero con
analogReadResolution (16) le dará un número aproximado
de 16 bits con los primeros 12 bits que contienen la lectura
ADC real y los últimos 4 bits rellenados con ceros.
Si se establece el valor analogReadResolution () a un valor
inferior a las capacidades de la placa, se descartarán los bits
menos significativos adicionales leídos de la ADC.
El uso de una resolución de 16 bits (o cualquier resolución
mayor que las capacidades reales del hardware) le permite
escribir sketchs que manejan automáticamente los
dispositivos con una resolución ADC mayor cuando éstos
estén disponibles en las placas futuras sin cambiar una sola
línea de código.

120
Ejemplo

void setup() {
// abre la comunicación serie
Serial.begin(9600);
}

void loop() {
// lee la entrada A0 con resolución por defecto (10 bits)
// y envía la salida al monitor serie
analogReadResolution(10);
Serial.print("ADC 10-bit (default) : ");
Serial.print(analogRead(A0));

// camabia la resolución a 12 bits y lee A0

analogReadResolution(12);
Serial.print(", 12-bit : ");
Serial.print(analogRead(A0));

// cambia la resolución a 16 bits y lee A0

analogReadResolution(16);
Serial.print(", 16-bit : ");
Serial.print(analogRead(A0));

// cambia la resolución a 8 bits y lee A0

analogReadResolution(8);
Serial.print(", 8-bit : ");
Serial.println(analogRead(A0));

// una pequeña temporización para no saturar la conexión serie

delay(100);
}

analogWrite

Descripción
Escribe un valor en un pin analógico (onda PWM). Se
puede utilizar para encender un LED con luminosidad
variable o accionar un motor a diferentes velocidades.
Después de llamar a analogWrite (), el pin va a generar una
onda cuadrada constante del ciclo de trabajo especificado
hasta la siguiente llamada a analogWrite () (o una llamada
a digitalRead () o digitalWrite () en el mismo pin). La

121
frecuencia de la señal PWM en la mayoría de los pines es
de aproximadamente 490 Hz. En las placas Uno y similares,
los pines 5 y 6 tienen una frecuencia de aproximadamente
980 Hz. Los pines 3 y 11 en el Leonardo también se
ejecutan a 980 Hz.
En la mayoría de las placas Arduino (aquellos con los
ATmega168 o ATmega328), esta función se puede utilizar
en los pines 3, 5, 6, 9, 10, y 11. En el Arduino Mega,
funciona en los pines 2 a 13 y 44 a 46. Las placas Arduino
más antiguas con un ATmega8 sólo admiten analogWrite ()
en los pines 9, 10 y 11.
En el Arduino Due analogWrite () funciona en los pines 2
a 13, más en los pines DAC0 y DAC1. A diferencia de los
pines PWM, DAC0 y DAC1 son convertidores Digitales a
Analógicos, y actúan como verdaderas salidas analógicas.
No es necesario llamar a pinMode () para configurar el pin
como salida antes de llamar analogWrite ().
La función analogWrite no tiene nada que ver con los pines
analógicos o la función analogRead.

Sintaxis
analogWrite(pin, value)

Parámetros
pin: el pin a escribir.
value: el ciclo de trabajo: entre 0 (siemprea apagado) y255
(siempre encendido).

122
Retornos
Ninguno

Notas y Problemas conocidos

Las salidas PWM generadas en los pines 5 y 6 tendrán
ciclos de trabajo más altos de lo esperado. Esto es debido a
las interacciones con las funciones millis () y delay (), que
comparten el mismo temporizador interno utilizado para
generar dichas salidas PWM. Esto se notará sobre todo en
entornos de pequeño ciclo de trabajo (por ejemplo 0 - 10) y
puede dar lugar a que un valor de 0 apague completamente
la salida en los pines 5 y 6.

Ejemplo
Establece la salida de un LED para que sea proporcional al
valor leido de un potenciómetro.
int ledPin = 9; // LED conectado al pin 9

int analogPin = 3; // potenciómetro conectado al pin analógico 3

int val = 0; // variable para almacenar el valor leido

void setup()

{ pinMode(ledPin, OUTPUT); // configura el pin como salida}

void loop(){val = analogRead(analogPin); // lee el pin de

entradaanalogWrite(ledPin, val / 4); // analogRead valores desde 0 a1023, analogWrite valores

desde 0 a 255}

123
analogRead()

Descripción
Lee el valor del pin analógico especificado. La placa
Arduino contiene 6 canales (8 canales en el Mini yNano, 16
en el Mega), analógicos con convertidor analógico a digital
de 10-bit. Esto significa que mapeará tensiones de entrada
entre 0 y 5 voltios en valores enteros entre 0 y 1023. Esto
produce una resolución entre las lecturas de: 5 voltios /
1024 unidades = 0.0049 voltios (4,9 mV) por unidad. El
rango de entrada y la resolución se pueden cambiar
con analogReference().
Se tarda unos 100 microsegundos (0.0001 s) para leer una
entrada analógica, por lo que la velocidad de lectura
máxima es de alrededor de 10.000 veces por segundo.

Sintaxis
analogRead(pin)

Parámetros
pin: el número de pin de la entrada analógica a leer (0 a5 en
la mayoría de las placas, 0 a 7 en el Mini y Nano, 0 a 15 en
el Mega)

Retornos
int (0 to 1023)

124
Nota
Si el pin de entrada analógica no está conectado (al aire o
flotante), el valor devuelto por analogRead () fluctuará en
base a una serie de factores (por ejemplo, los valores de las
otras entradas analógicas, lo cerca que tu mano est.e a la
placa, etc.).

Ejemplo
int analogPin = 3; // potenciómetro (terminal centrall) conectado al pin analógico 3
// terminales exteriores a +5 V y a masa
int val = 0; // variable para almacenar el valor leido

void setup()
{
Serial.begin(9600); // configuración serie
}

void loop()
{
val = analogRead(analogPin); // lee el pin de entrada
Serial.println(val); // imprime el valor
}

shiftOut()

125
Descripción

Desplaza hacia la salida un byte de datos un bit a cada

vez. Comienza a partir del bit más significativo (más a la
izquierda) o menos significativo (más a la derecha). Cada
bit se escribe a su vez en un pin de datos, después de lo
cual un pulso de reloj se activa (pasa a nivel alto, y a
continuación, a nivel bajo) para indicar que el bit está
disponible.

Nota: si estamos conectados con un dispositivo que está

sincronizado por flancos de subida, necesitamos
asegurarnos de que el pin de reloj está a nivel bajo antes
de llamar a shiftOut (), por ejemplo, con una llamada a
digitalWrite (pinReloj, LOW).

Esta es una implementación de software; véase también

la biblioteca SPI, que proporciona una implementación
de hardware que es más rápida, pero sólo funciona en
pines específicos.

Sintaxis

shiftOut(dataPin, clockPin, bitOrder, value)

Parámetros

dataPin: el pin por el que sale cada bit (int)

clockPin: el pin que cambia cada vez que dataPin ha sido

establecido a su valor correcto (int)
bitOrder: dirección de desplazamiento de los
bits; MSBFIRST o LSBFIRST.
126
(Primero el Bit Más Significativo, o, Primero el Bit Menos
Significativo)

value: los datos que se desplazan a la salida. (byte)

Retornos

Ninguno

Note

Los dataPin y clockPin deben estar ya configurados como

salida conto pinMode().

shiftOut actualmente escribe en la salida 1 byte (8 bits)

por lo que requiere una operación de dos pasos para
valores de salida mayores que 255.
// Hacer esto para MSBFIRST serie
int data = 500;
// desplaza a la salida el byte alto
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));
// desplaza a la salida el byte bajo
shiftOut(dataPin, clock, MSBFIRST, data);

// O hacer esto para LSBFIRST serie

data = 500;
// desplaza a la salida el byte bajo
shiftOut(dataPin, clock, LSBFIRST, data);
// desplaza a la salida el byte alto
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));

Ejemplo

Para acompañamiento del circuito, ver el tutorial para control de un Registro

de Desplazamiento 74HC595.
//**************************************************************//
// Name : shiftOutCode, Hello World //
// Author : Carlyn Maw,Tom Igoe //

127
 // Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//****************************************************************

// Pin conectado ato ST_CP del 74HC595

int latchPin = 8;
//Pin conectado a SH_CP del 74HC595
int clockPin = 12;
////Pin conectado a DS del 74HC595
int dataPin = 11;

void setup() {
// configurar pines de salida que ya están direccionados en el bucle principal
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}

void loop() {
//count up routine
for (int j = 0; j < 256; j++) {
// pone a masa latchPin y lo mantiene a nivel bajo durante la transmisión
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, LSBFIRST, j);
// devuelve el latch pin a nivel alto indicando al chipque
// ya no necesita escuchar la información
digitalWrite(latchPin, HIGH);
delay(1000);
}
}

Stream
Stream es la clase base para secuencias basadas en caracteres y binarios. No se llama
directamente, sino que se invoca cada vez que se utiliza una función que depende de
él.
Stream define las funciones de lectura en Arduino. Al utilizar cualquier funcionalidad
básica que utiliza un read () o método similar, se puede suponer con seguridad que se
llama a la clase Stream. Para funciones como printf (), Stream hereda la clase de
impresión.
Algunas de las bibliotecas que dependen de Stream incluyen:

 Serial
 Wire
 Ethernet Client
 Ethernet Server
 SD

128
 Funciones

 available()
 read()
 flush()
 find()
 findUntil()
 peek()
 readBytes()
 readBytesUntil()
 readString()
 readStringUntil()
 parseInt()
 parsefloat()
 setTimeout()

Serial
Se utiliza para la comunicación entre la placa Arduino y un ordenador u otros
dispositivos. Todas las placas Arduino tienen al menos un puerto serie
(también conocido como un UART o USART): Serial. Se comunica por los
pines digitales 0 (RX) y 1 (TX), así como con el ordenador a través de USB.
Por lo tanto, si utiliza estas funciones, no se puede también utilizar pines0 y 1
para entrada o salida digital.
Puede utilizar el monitor serie incorporado del entorno Arduino para
comunicarse con una placa Arduino. Haga clic en el botón del monitor serie en
la barra de herramientas y seleccione la misma velocidad de transmisión
utilizada en la llamada a begin().
El Arduino Mega tiene tres puertos serie adicionales: Serial1 en los pines 19
(RX) y 18 (TX), Serial2 en los pines 17 (RX) y 16 (TV), Serial 3 en los pines 15
(RX) y 14 (TX). Para usar estos pines para comunicarse con el ordenador
personal, necesitará un adaptador adicional de USB a serie, ya que no están
conectados a un adaptador de USB a serie de la Mega. Para utilizarlos para
comunicarse con un dispositivo serie TTL externo, conecte el pin TX al pin RX
del dispositivo, el RX al pin TX del dispositivo, y la masa de su Mega a tierra del
dispositivo. (No conecte estos pines directamente a un puerto serie RS232, ya
que operan a +/- 12V y pueden dañar la placa Arduino.)

El Arduino Due tiene tres puertos serie TTL a 3.3V adicionales: Serial1 en los
pines 19 (RX) y 18 (TX); Serial2 en los pines 17 (RX) y 16 (TV), Serial 3 en los
pines 15 (RX) y 14 (TX). Los pines 0 y 1 también están conectados a los pines
correspondientes del chip ATmega16U2 USB-a-TTL Serial, que está conectado
con el puerto de depuración USB. Además, hay un puerto serie USB nativo en
el chip SAM3X, SerialUSB '.
La placa Arduino Leonardo utiliza Serial1 para comunicarse a través de TTL (5
V) serie en los pines 0 (RX) y 1 (TX). Serial está reservado para la comunicación

129
USB CDC. Para obtener más información, consulte la página introducción del
Leonardo y la página de hardware.

noInterrupts()
Descripción
Deshabilita las interrupciones (que después se pueden rehabilitar con Interrupts()). Las
interrupciones permiten que ciertas tareas importantes que suceden en segundo plano sean
activadas por defecto. Algunas funciones no trabajarán mientras las interrupciones están
deshabilitadas, y las comunicaciones entrantes pueden ser ignoradas. Las interrupciones pueden
alterar ligeramente la sincronización de código, sin embargo, y pueden ser desactivadas de los
sectores especialmente críticos del código.

Parámetros

Ninguno

Retornos

Ninguno

Ejemplo
void setup() {}

void loop()

noInterrupts();

// critica, aquí el código sensible al tiempo

interrupts();

interrupts()
130
Descripción
Vuelve a habilitar las interrupciones (después de que han sido desactivadas por noInterrupts ()).
Las interrupciones permiten que ciertas tareas importantes que suceden en segundo plano sean
activadas por defecto. Algunas funciones no trabajarán mientras las interrupciones están
deshabilitadas, y las comunicaciones entrantes pueden ser ignoradas. Las interrupciones pueden
alterar ligeramente la sincronización de código, sin embargo, y pueden ser desactivadas de los
sectores especialmente críticos del código.

Parámetros

Ninguno

Retornos

Ninguno

Ejemplo
void setup() {}

void loop()

noInterrupts();

// critica, aquí el código sensible al tiempo

interrupts();

// el resto del código aquí

detachInterrupt()
Descripción

Desconecta la interrupción dada.

131
 Sintaxis

detachInterrupt(interrupt)
detachInterrupt(digitalPinToInterrupt(pin));
detachInterrupt(pin) (solo Arduino Due, Zero)

Parámetros

 interrupt: el número de interrupción a deshabilitar (ver attachInterrupt() para más detalles).

 pin: el número de pin de la interrupción a deshabilitar (solo Arduino Due)

attachInterrupt()

Descripción
Pines digitales con Interrupción

El primer parámetro para attachInterrupt es el número de interrupción. Normalmente

debería utilizar digitalPinToInterrupt(pin) para traducir el pin digital real al número de

interrupción específica. Por ejemplo, si se conecta al pin3, utilice digitalPinToInterrupt(3)

como el primer parámetro para attachInterrupt.

Placa Pin Digital Utilizable para Interrupciones
Uno, Nano, Mini, otras placas 328 2, 3
Mega, Mega2560, MegaADK 2, 3, 18, 19, 20, 21
Micro, Leonardo, otras 32u4 0, 1, 2, 3, 7
Zero todos los pines digitales, excepto 4
MKR1000 Rev.1 0, 1, 4, 5, 6, 7, 8, 9, A1, A2
Due todos los pines digitales

Nota
Dentro de la función de Interrupción, delay () no funcionará y el valor devuelto
por Millis () no aumentará. Los datos serie recibidos, mientras que la función está activa
se pueden perder. Usted debe declarar como volátile cualquier variable que se
modifique dentro de la función de Interrupción. Vea la sección de ISR a continuación
para obtener más información.

132
Uo de las Interrupciones
Las interrupciones son útiles para hacer que las cosas sucedan de forma automática en

los programas de los microcontroladores, y pueden ayudar a resolver los problemas de

tiempo. Buenas prácticas para el uso de una interrupción pueden incluir la lectura de un

codificador rotatorio (encoder) o la monitorización de la entrada del usuario.

Si usted quiere asegurarse de que un programa siempre captura los pulsos de un

encoder rotativo, de modo que no se pierda un solo pulso, sería muy difícil de escribir

un programa que hiciera cualquier otra cosa, ya que el programa tendría que sondear

constantemente las líneas del sensor codificador, con el fin de capturar los pulsos

cuando ocurrieran. Otros sensores tienen una interfaz similar dinámica también, como

tratar de leer un sensor de sonido que está tratando de capturar un clic, o un sensor de

infrarrojos tipo ranura (foto-interruptor) que intenta coger una caida de la moneda. En

todas estas situaciones, el uso de una interrupción puede liberar al microcontrolador

para que haga algún otro trabajo realizado mientras no pierde la entrada.

Acerca de la Rutina del Servicio de Interrupciones

Las ISR son tipos especiales de funciones que tienen algunas limitaciones únicas que
la mayoría de las otras funciones no tienen. Una ISR no puede tener ningún parámetro,
y no debe devolver nada.
En general, una ISR debe ser lo más corta y más rápida posible. Si el programa utiliza
varias ISR, sólo se puede ejecutar una a la vez, las otras interrupciones serán
ejecutadas después de que la actual termine en un orden que depende de la prioridad
que tienen. Millis () se basa en las interrupciones de cómputo, por lo que nunca se
incrementará en el interior de una ISR. Delay () requiere interrupciones para trabajar, no
va a funcionar si se le llama en el interior de una ISR. micros () funciona al principio,
pero va a empezar a comportarse de forma errática después de 1-2 ms.
delayMicroseconds () no utiliza ningún contador, por lo que funcionará con normalidad.

Por lo general las variables globales se utilizan para transmitir datos entre una ISR y el

programa principal. Para asegurarse de que las variables compartidas entre una ISR y

el programa principal se actualizan correctamente, declararla comovolatile.

Para obtener más información sobre las interrupciones, consulte las notas de Nick

Gammon's.

133
Sintaxis
attachInterrupt(digitalPinToInterrupt(pin), ISR, mode); (recomendado)

attachInterrupt(interrupt, ISR, mode); (no recomendado)

attachInterrupt(pin, ISR, mode) ; (no
recomendado solo Arduino, Zero, MKR1000)

Parámetros
interrupt: el número de interrupción (int)

pin: el número de pin (solo Arduino Due, Zeo, MKR1000)

la ISR llamada cuando sucede la interrupción; esta función no debe tener

USR: parámetros ni devolver nada. Esta función a veces se denomina Rutina del
Servicio de Interrupciones.

define cuando debe ser disparada la interrupción. Existen cuatro constantes

mode:
predefinidas como valores válidos:

LOW dispara la interruoción cuando el pin está a nivel bajo.

CHANGE dispara la interrupción cuando el pin cambia su valor.

RISING dispara la interrupción cuando el pin pasa de nivel bajo a nivel alto.

FALLING dispara la interrupción cuando el pin pasa de nivel alto a nivel bajo.

HIGH dispara la interrupción cuando el pin esta a

La placa Due también permite:
nivel alto

Retornos

Ninguno

Ejemplo
int pin = 13;
volatile int state = LOW;void setup()
{
pinMode(pin, OUTPUT);
attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);}

134
void loop()
{
digitalWrite(pin, state);
}
void blink()
{
state = !state;
}

Números de Interrupciones
Normalmente debería utilizar digitalPinToInterrupt (pin), en lugar poner directamente un
número de interrumpción en su programa. Los pines específicos con interrupciones, y
su correlación con las interrupciones número varía en cada tipo de tarjeta. El uso directo
de números de interrupción puede parecer simple, pero puede causar problemas de
compatibilidad cuando su programa se ejecuta en una placa diferente.
Sin embargo, la mayoría de los programas a menudo tienen números de interrupción
directos. Suelen utilizarse el número 0 (para el pin digital 2) o el número 1 (para el pin
digital 3). La siguiente tabla muestra los pines de interrupción disponibles en varias
placas.

Placa int.0 int.1 int.2 int.3 int.4 int.5

Uno, Ethernet 2 3

Mega 2560 2 3 21 20 19 18

basada en 32u4 (por ejemplo, Leonardo, Micro) 3 2 0 1 7

Due y Zero (ver a continuación)

La placa Arduino Zero le permite agregar una función de interrupción en todos los pines

disponibles, excepto para el pin 4. Puede especificar directamente el número de pines

en attachInterrupt (). La placa Arduino Due tiene potentes capacidades de interrupción

que le permiten agregar una función de interrupción en todo pines disponibles. Se puede

especificar directamente el número de pin en attachInterrupt ().

bit()
Descripción

Calcula el valor del bit especificado (el bit 0 es 1, el bit 1 es 2, el bit 2 es 4, etc.).

135
Sintaxis

bit(n)

Parámetros

n: el bit cuyo valor se quiere calcular

Retornos

el valor del bit

bitClear()
Descripción

Borra (escribe un 0) en un bit de una variable numérica.

Sintaxis

bitClear(x, n)

Parámetros

x: la variable numérica cuyo bit se quiere borrar

n: el bit a borrar, comenzando por 0 del bit menos significativo (más a la derecha)

Retornos

Ninguno

bitSet()
Descripción

Activa (escribe una 1)en un bit de una variable numérica.

136
Sintaxis

bitSet (x, n)

Parámetros

x: la variable numérica cuyo bit se quiere activar

n: el bit a activar, empezando por 0 del bit menos significativo (más a la derecha)

Retornos

Ninguno

bitWrite()
Descripción

Escribe un bit en una variable numérica.

Sintaxis

bitWrite (x, n, b)

Parámetros

x: la variable numérica en la que se escribe

n: número de bit a escribir, comenzando en 0 del bit menos significatico(más a la derecha)

b: el valor del bit a escribir (0 o 1)

Retornos

Ninguno

bitRead()

137
Descripción

Lee un bit de un número.

Sintaxis

bitRead (x, n)

Parámetros

x: el número del que se quiere leer

n: el bit a leer, empezando por 0 del bit menos significativo (más a la derecha)

Retornos

el valor del bit (0 o 1).

highByte()
Descripción

Extrae el byte de orden superior (más a la izquierda) de una palabra (o el segundo byte más

bajo de un tipo de datos más grande.

Sintaxis

highByte (x)

Parámetros

x: un valor de cualquier tipo

Retornos

byte

lowByte()

138
Descripción
Extrae el byte de orden inferior (más a la derecha) de una variable (por
ejemplo de una palabra (word)).

Sintaxis
lowByte (x)

Parameters
x: un valor de cualquier tipo

Retornos
byte

randomSeed()

Descripción
randomSeed() inicializa el generador de números pseudo aleatorios,
haciendo que se inicie en un punto arbitrario en su secuencia aleatoria.
Esta secuencia, aunque muy larga, y al azar, es siempre la misma.

Si es importante que la secuencia de valores generados por random()

difiera, en sucesivas ejecuciones de un programa, use randomSeed()
para inicializar el generador de números aleatorios con una entrada
bastante aletoria, similar a analogRead() con e pin desconectado.

A la inversa, ocasionalmente puede ser útil usar secuencias pseudo

aleatorias que se repinta exactamente. Esto de puede hacer llamando
a randomSeed() con un número fijo, antes de iniciar la secuencia
aleatoria.

139
Parámetros
long, pasa un número para generar la semilla (int).

Retornos
Ninguno

Ejemplo
long randNumber;
void setup()

{
Serial.begin(9600);
randomSeed(analogRead(0));
}
void loop()

{
randNumber = random(300);
Serial.println(randNumber);
delay(50);
}

random()

Descrición
La función random() genera números pseudo aleatorios.

Sintaxis
random(max)
random(min, max)

Parámetros
min - el límite inferior del valor aleatorio, incluso este (opcional)

max - el límite superior del valor aleatorio, incluso este

140
Retornos
un número aleatorio entre min and max-1 (long)

Nota:
Si es importante que una secuencia de valores generados por ramdom() pueda variar, en
posteriores ejecuciones de un programa, utilice ramdomSeed () para inicializar el generador de
números aleatorios con una entrada bastante aleatoria, como analogRead () en un pin
desconectado .
A la inversa, puede ser ocasionalmente útil el uso de secuencias pseudoaleatorias que se
repiten exactamente. Esto se puede conseguir llamando a tandomSeed () con un número fijo,
antes de iniciar la secuencia aleatoria.

Ejemplo
long randNumber;

void setup(){

Serial.begin(9600);

// si el pin de entrada analógica 0 está desconectado, el ruido analógico

// hará la llamada a randomSeed () para generar diferentes

// números de semilla cada vez que se ejecuta el programa.

// RandomSeed () A continuación, mezclará la función aleatoria.

randomSeed(analogRead(0));

void loop() {

// imprime un número aleatorio de 0 a 299

141
 randNumber = random(300);

Serial.println(randNumber);

// imprime un numero aleatorio de10 a19

randNumber = random(10, 20);

Serial.println(randNumber);

delay(50);

isHexadecimaDigit()

Todos los operadores de caracteres.

__________________________________________
_____________
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

142
Retornos
True o false.
__________________________________________
____________
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
__________________________________________
____________
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________

143
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

144
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

145
Retornos
True o false.
__________________________________________
____________
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________

146
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

Parámetros
thisChar: el caracter a ser analizado

Retornos
True o false.
__________________________________________
____________
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dígito hexadecimal válido.

147
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
__________________________________________
____________

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {

// Abre la comunicación serie y espera a que se abra el puerto:

Serial.begin(9600);

while (!Serial) {

; // espera a que el puerto esté conecrado. Solo necesario para el puerto USB nativo

// envía un intro

Serial.println("Envia algún byte y yo voy a contar todo lo que pueda sobre él");

Serial.println();

void loop() {

// recibe lo bytes entrantes:

148
if (Serial.available() > 0) {

int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");

Serial.write(thisChar);

Serial.print("\' Valor ASCII: ");

Serial.println(thisChar);

// analiza lo enviado

if (isAlphaNumeric(thisChar)) {

Serial.println("es alfanumérico");

if (isAlpha(thisChar)) {

Serial.println("es alfabético");

if (isAscii(thisChar)) {

Serial.println("es un carácrer ASCII");

if (isWhitespace(thisChar)) {

Serial.println("es un espacio en blanco");

if (isControl(thisChar)) {

Serial.println("es un carácter de control");

if (isDigit(thisChar)) {

Serial.println("es un dígito numérico");

if (isGraph(thisChar)) {

Serial.println("Es un carácter imprimible que no es un espacio en blanco");

if (isLowerCase(thisChar)) {

Serial.println("es un carácter en minúscula");

149
 }

if (isPrintable(thisChar)) {

Serial.println("es un carácter imprimible");

if (isPunct(thisChar)) {

Serial.println("es un caracter de puntuzación");

if (isSpace(thisChar)) {

Serial.println("es un carácter de espaciciado");

if (isUpperCase(thisChar)) {

Serial.println("en un carácter en mayúscula");

if (isHexadecimalDigit(thisChar)) {

Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f, o A - F)");

// añadir algún espacio y perdir otro carácter

Serial.println();

Serial.println("Dame otro byte:");

Serial.println();

isUppercase()

Todos los operadores de caracteres.

_______________________________________________
_______

150
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

Retornos
True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

151
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

Parámetros
thisChar: el carácter a ser analizado

152
Retornos
True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

153
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

154
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

Parámetros
thisChar: el caracter a ser analizado

155
Retornos
True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dñigito hexadecimal válido.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario para el
puerto USB nativo
}

156
 // envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}
if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un espacio
en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {

157
 Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f,
o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isSpace()

Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

Retornos
True o false.
_______________________________________________
_______

158
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

159
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

Parámetros
thisChar: el carácter a ser analizado

160
Retornos
True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

161
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

162
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

Parámetros
thisChar: el caracter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dñigito hexadecimal válido.

Parámetros
thisChar: el carácter a ser analizado

163
Retornos
True o false.
_______________________________________________
_______

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario para el
puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");

164
 }
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}
if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un espacio
en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f,
o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isPunct()

165
Todos los operadores de caracteres.
_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

Retornos
True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______

166
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

167
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

168
Retornos
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

169
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

170
Parámetros
thisChar: el caracter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dñigito hexadecimal válido.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:

171
 Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario para el
puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}
if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un espacio
en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");

172
 }
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f,
o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isPunct()

Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

173
Retornos
True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

174
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

175
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

176
Retornos
True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

177
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

Parámetros
thisChar: el caracter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dñigito hexadecimal válido.

178
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario para el
puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");

179
 Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}
if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un espacio
en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f,
o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

180
isPrintable()

Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

Retornos
True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______
181
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

182
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

183
Retornos
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

184
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

185
Parámetros
thisChar: el caracter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dñigito hexadecimal válido.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:

186
 Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario para el
puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}
if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un espacio
en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");

187
 }
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f,
o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isLowercase()

Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

188
Retornos
True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

189
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

190
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

191
Retornos
True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

192
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

Parámetros
thisChar: el caracter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dñigito hexadecimal válido.

193
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario para el
puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");

194
 Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}
if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un espacio
en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f,
o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

195
isDigit()

196
Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción

Analiza si char es un carácter alfanumérico.

Parámetros

thisChar: el carácter a ser analizado.

Retornos

True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción

Analiza si char es un carácter alfabético.

Parámetros

thisChar: el carácter a ser analizado

Retonos

True o false.
_______________________________________________
_______

197
isAscii(thisChar)

Descripción

Analiza si char es un carácter ASCII.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción

Analiza si char es un carácter un espacio en blanco.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción

Analiza si char es un carácter de control.

198
Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción

Analiza si char es un dígito.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos
199
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción

Analiza si char es un carácter en minúsculas .

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPunct(thisChar)

200
Descripción

Analiza si char es un carácter de puntuación.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción

Analiza si char es un carácter espaciador.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción

Analiza si char es un carácter en mayúsculas.

Parámetros
201
thisChar: el caracter a ser analizado
Retornos

True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción

Analiza si char es un dñigito hexadecimal válido.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
Ejemplos

202
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario
para el puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}

203
 if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un
espacio en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a
- f, o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isWhitespace()

204
Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción

Analiza si char es un carácter alfanumérico.

Parámetros

thisChar: el carácter a ser analizado.

Retornos

True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción

Analiza si char es un carácter alfabético.

Parámetros

thisChar: el carácter a ser analizado

Retonos

True o false.
_______________________________________________
_______

205
isAscii(thisChar)

Descripción

Analiza si char es un carácter ASCII.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción

Analiza si char es un carácter un espacio en blanco.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción

Analiza si char es un carácter de control.

206
Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción

Analiza si char es un dígito.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos
207
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción

Analiza si char es un carácter en minúsculas .

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPunct(thisChar)

208
Descripción

Analiza si char es un carácter de puntuación.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción

Analiza si char es un carácter espaciador.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción

Analiza si char es un carácter en mayúsculas.

Parámetros
209
thisChar: el caracter a ser analizado
Retornos

True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción

Analiza si char es un dñigito hexadecimal válido.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
Ejemplos

210
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario
para el puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}

211
 if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un
espacio en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a
- f, o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isControl()

212
Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción

Analiza si char es un carácter alfanumérico.

Parámetros

thisChar: el carácter a ser analizado.

Retornos

True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción

Analiza si char es un carácter alfabético.

Parámetros

thisChar: el carácter a ser analizado

Retonos

True o false.
_______________________________________________
_______

213
isAscii(thisChar)

Descripción

Analiza si char es un carácter ASCII.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción

Analiza si char es un carácter un espacio en blanco.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción

Analiza si char es un carácter de control.

214
Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción

Analiza si char es un dígito.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos
215
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción

Analiza si char es un carácter en minúsculas .

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPunct(thisChar)

216
Descripción

Analiza si char es un carácter de puntuación.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción

Analiza si char es un carácter espaciador.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción

Analiza si char es un carácter en mayúsculas.

Parámetros
217
thisChar: el caracter a ser analizado
Retornos

True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción

Analiza si char es un dñigito hexadecimal válido.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
Ejemplos

218
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario
para el puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}

219
 if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un
espacio en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a
- f, o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isAlpha()

220
Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción

Analiza si char es un carácter alfanumérico.

Parámetros

thisChar: el carácter a ser analizado.

Retornos

True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción

Analiza si char es un carácter alfabético.

Parámetros

thisChar: el carácter a ser analizado

Retonos

True o false.
_______________________________________________
_______

221
isAscii(thisChar)

Descripción

Analiza si char es un carácter ASCII.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción

Analiza si char es un carácter un espacio en blanco.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción

Analiza si char es un carácter de control.

222
Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción

Analiza si char es un dígito.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos
223
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción

Analiza si char es un carácter en minúsculas .

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPunct(thisChar)

224
Descripción

Analiza si char es un carácter de puntuación.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción

Analiza si char es un carácter espaciador.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción

Analiza si char es un carácter en mayúsculas.

Parámetros
225
thisChar: el caracter a ser analizado
Retornos

True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción

Analiza si char es un dñigito hexadecimal válido.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
Ejemplos

226
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario
para el puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}

227
 if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un
espacio en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a
- f, o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isAlphaNumeric()

228
Todos los operadores de caracteres.

_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción

Analiza si char es un carácter alfanumérico.

Parámetros

thisChar: el carácter a ser analizado.

Retornos

True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción

Analiza si char es un carácter alfabético.

Parámetros

thisChar: el carácter a ser analizado

Retonos

True o false.
_______________________________________________
_______

229
isAscii(thisChar)

Descripción

Analiza si char es un carácter ASCII.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción

Analiza si char es un carácter un espacio en blanco.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción

Analiza si char es un carácter de control.

230
Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción

Analiza si char es un dígito.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos
231
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción

Analiza si char es un carácter en minúsculas .

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción

Analiza si char es un carácter imprimible.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isPunct(thisChar)

232
Descripción

Analiza si char es un carácter de puntuación.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción

Analiza si char es un carácter espaciador.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción

Analiza si char es un carácter en mayúsculas.

Parámetros
233
thisChar: el caracter a ser analizado
Retornos

True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción

Analiza si char es un dñigito hexadecimal válido.

Parámetros

thisChar: el carácter a ser analizado

Retornos

True o false.
_______________________________________________
_______
Ejemplos

234
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:
Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario
para el puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}

235
 if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un
espacio en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");
}
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a
- f, o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

isAscii()

Todos los operadores de caracteres.

_______________________________________________
_______

236
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

Retornos
True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado
237
Retornos
True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.

isGraph()

238
Todos los operadores de caracteres.
_______________________________________________
_______
isAlphaNumeric(thisChar)

Descripción
Analiza si char es un carácter alfanumérico.

Parámetros
thisChar: el carácter a ser analizado.

Retornos
True o false.
_______________________________________________
_______
isAlpha(thisChar)

Descripción
Analiza si char es un carácter alfabético.

Parámetros
thisChar: el carácter a ser analizado

Retonos
True o false.
_______________________________________________
_______

239
isAscii(thisChar)

Descripción
Analiza si char es un carácter ASCII.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isWhitespace(thisChar)

Descripción
Analiza si char es un carácter un espacio en blanco.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isControl(thisChar)

Descripción
Analiza si char es un carácter de control.

240
Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isDigit(thisChar)

Descripción
Analiza si char es un dígito.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isGraph(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

241
Retornos
True o false.
_______________________________________________
_______
isLowerCase(thisChar)

Descripción
Analiza si char es un carácter en minúsculas .

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isPrintable(thisChar)

Descripción
Analiza si char es un carácter imprimible.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

242
isPunct(thisChar)

Descripción
Analiza si char es un carácter de puntuación.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isSpace(thisChar)

Descripción
Analiza si char es un carácter espaciador.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isUpperCase(thisChar)

Descripción
Analiza si char es un carácter en mayúsculas.

243
Parámetros
thisChar: el caracter a ser analizado

Retornos
True o false.
_______________________________________________
_______
isHexadecimalDigit(thisChar)

Descripción
Analiza si char es un dñigito hexadecimal válido.

Parámetros
thisChar: el carácter a ser analizado

Retornos
True o false.
_______________________________________________
_______

Ejemplos
/*
Operadores de Análisis de caracteres

Ejemplos de uso de Operadores de Análisis de caracteres

Enviar cualquier byte y el programa informará sobre el

creado 29 Noviembre 2010

modificado 2 Apbril 2012
`por Tom Igoe

Este código es de dominio público.

*/

void setup() {
// Abre la comunicación serie y espera a que se abra el puerto:

244
 Serial.begin(9600);
while (!Serial) {
; // espera a que el puerto esté conecrado. Solo necesario para el
puerto USB nativo
}

// envía un intro
Serial.println("Enviar algún byte y yo voy a contar todo lo que
pueda sobre él");
Serial.println();
}

void loop() {
// recibe lo bytes entrantes:
if (Serial.available() > 0) {
int thisChar = Serial.read();

// dice lo que fué enviado:

Serial.print("Me has enviado: \'");
Serial.write(thisChar);
Serial.print("\' Valor ASCII: ");
Serial.println(thisChar);

// analiza lo enviado
if (isAlphaNumeric(thisChar)) {
Serial.println("es alfanumérico");
}
if (isAlpha(thisChar)) {
Serial.println("es alfabético");
}
if (isAscii(thisChar)) {
Serial.println("es un carácrer ASCII");
}
if (isWhitespace(thisChar)) {
Serial.println("es un espacio en blanco");
}
if (isControl(thisChar)) {
Serial.println("es un carácter de control");
}
if (isDigit(thisChar)) {
Serial.println("es un dígito numérico");
}
if (isGraph(thisChar)) {
Serial.println("Es un carácter imprimible que no es un espacio
en blanco");
}
if (isLowerCase(thisChar)) {
Serial.println("es un carácter en minúscula");
}
if (isPrintable(thisChar)) {
Serial.println("es un carácter imprimible");

245
 }
if (isPunct(thisChar)) {
Serial.println("es un caracter de puntuzación");
}
if (isSpace(thisChar)) {
Serial.println("es un carácter de espaciciado");
}
if (isUpperCase(thisChar)) {
Serial.println("en un carácter en mayúscula");
}
if (isHexadecimalDigit(thisChar)) {
Serial.println("es un dñigito hexadecimal válido (0 - 9, a - f,
o A - F)");
}

// añadir algún espacio y perdir otro carácter

Serial.println();
Serial.println("Dame otro byte:");
Serial.println();
}
}

tan()

Descripción
Calcula la tangente de un ángulo (en radianes). El resultado está comprendido entre negativo

infinito e infinito.

Parámetros
rad: el ángulo en radianes (float)

Retornos
La tangente del ángulo (double)

cos()
Descripción
Calcula el coseno de un ángulo (en radianes). El resultado está comprendido entre -1 y 1.

246
Parámetros
rad: el ángulo en radianes (float)

Retornos
El coseno del ángulo ("double")

sin()
Descripción
Calcula el seno de un ángulo (en radianes). El resultado está
comprendido entre -1 y 1.

Parámetros
rad: en ángulo en radianes (float)

Retornos
El seno del ángulo (double)

Bibliotecas Mouse y Keyboard

Estas bibliotecas del núcleo permiten a una placa basada en 32u4 o a placas Due y

Zero aparecer como un ratón y / o teclado nativo de un ordenador conectado.

Unas palabras de advertencia sobre el uso de las bibliotecas de ratón y el teclado:

Si el Ratón o el Teclado están funcionando constantemente, será difícil programar su

placa. Con funciones tales como Mouse.move () y Keyboard.print () usted puede

mover el cursor o enviar pulsaciones de teclas a un ordenador conectado y esta función

sólo debe ser llamada cuando esté listo para manejarlos. Se recomienda el uso de un

sistema de control para activar esta funcionalidad, como un interruptor o solamente

responder a la entrada específica que pueda controlar.

247
 Ratón
Las funciones del Ratón permiten a un Leonardo, Micro, o Due controlar el movimiento

del cursor en un ordenador conectado. Cuando se actualiza la posición del cursor,

siempre es relativa a la posición anterior del cursor.

 Mouse.begin()
 Mouse.click()
 Mouse.end()
 Mouse.move()
 Mouse.press()
 Mouse.release()
 Mouse.isPressed()

Teclado
Las funciones del Teclado permiten a un Leonardo, Micro, o Due enviar pulsaciones de teclas a

un ordenador conectado.

Nota: No todos los posibles caracteres ASCII, en particular los de no impresión, pueden
ser enviados con la biblioteca del teclado. La biblioteca es compatible con el uso de las
teclas modificadoras. Las teclas modifcadoras cambian el comportamiento de otra tecla
cuando se pulsa al mismo tiempo. . Ver aquí más información sobre las teclas
soportadas y su uso.

 Keyboard.begin()
 Keyboard.end()
 Keyboard.press()
 Keyboard.print()
 Keyboard.println()
 Keyboard.release()
 Keyboard.releaseAll()
 Keyboard.write()

Ejemplos
 KeyboardAndMouseControl: Demuestra los comandos de Ratón y el Teclado en un
programa.
 KeyboardMessage: Envía una cadena de texto cuando se presiona un pulsador.
 KeyboardLogout : Cierra la sesión del usuario actual con los comandos de teclado
 KeyboardSerial: Lee un byte desde el puerto serie, y devuelve una pulsación de tecla.
 KeyboardReprogram : abre una nueva ventana en el IDE de Arduino y reprograma el
tablero con un programa simple de intermitencia
 ButtonMouseControl: Control del movimiento del cursor con 5 pulsadores.
 JoystickMouseControl: Controla el movimiento del cursor de un ordenador con un Joystick
cuando se pulsa un botón.

248
 int sin signo

Descripción
En el Arduino Uno y otras placas basadas en el ATMEGA, los int sin signo
(entero sin signo) son lo mismo que los int en que almacenan un valor de
2 bytes. En lugar de almacenar números negativos estos solo almacenan
valores positivos, en el rango de 0 a 65,535 (2^16) - 1).
El Due almacena un valor de 4 bytes (32-bit), en un rango de 0 a
4,294,967,295 (2^32 - 1).
La diferencia entre los enteros sin signo y enteros con signo, radica en la
forma en que el bit más alto, a veces llamado bit de "signo", se interpreta.
En el tipo int Arduino (con signo), si el bit es un "1", el número se interpreta
como un número negativo, y los otros 15 bits se interpretan
como complemento matemático a 2.

Ejemplo
unsigned int ledPin = 13;

Sintasix
unsigned int var = val;

 var - el nombre de la variable entera

 val - el valor que se asigna a la variable

Consejo de codificación

Cuando las variables exceden de su máxima capacidad se "dan la

vuelta" y vuelven a su valor más bajo si se están incrementando, o a su
valor más alto si se están decrementando.
unsigned int x

x = 0;

x = x - 1; // x contiene ahora 65535 - rolls over dirección

negativa

x = x + 1; // x contiene ahora 0 - rolls over

249
Referencia del Lenguaje
Los programas Arduino pueden dividirse en tres partes;
estructura, valores (variables y constantes) y funciones.
ESTRUCTURA
setup()
loop()

Estructuras de control
if
if...else
for
switch case
while
do... while
break
continue
return
goto

Más de sintaxis
; (punto y coma)
{} (llaves)
// (comentario 1 línea)
/* */ (comentario multi-línea)
#define
#include

Comparadores aritméticos
= (operador de asignación)
+ (suma)
- (resta)
* (multiplicación)
/ (división)
% (módulo)

Operadores de comparación

= = (igual a)
!= (no igual a)
< (menor que)
> (mayor que)
<= (menor que o igual a)
>= (mayor que o igual a)

Operadores Booleanos
&& (and)
|| (or)
! (not)

250
Operadores por Acceso por Puntero
* dereference operator
& reference operator
Operadores Bit a Bit
& (and bit a bit)
| (or bit a bit)
^ (xor bit a bit)
~ (not bit a bit)
<< (desplazamiento de bit a la izquierda)
>> (desplazamiento de bit a la derecha)

Operadores compuestos
++ (incremento)
-- (decremento)
+= (suma compuesta)
-=(resta compuesta)
*=(multiplicación compuesta)
/= (división compuesta)
%= (módulo compuesto)
&= (and bit a bit compuesto)
|= (or bit a bit compuesto)

251