by

Ya
ko
19
76
id
en
ti.
io
Arduino:2020Guía para principiantesde
programaciónen Arduinopasoapaso
Victor Hernandez
© Copyright 2020 - Todos los derechos reservados

Te gustaría compartir este libro con otra persona, por favor compra una copia de opcional para cada receptor.
Gracias por respetar el largo trabajo de este autor. De lo contrario, la transmisión, duplicación o reproducción de
cualquiera de las siguientes obras incluyendo información específica será considerado un acto ilegal irrespetuoso de
ello ya se ha hecho electrónicamente o impreso. Esto se extiende a crear una copia secundaria o terciaria de la obra o
una copia grabada y sólo se permite con consentimiento expreso del publicador. Todo derecho adicional reservado.

Contenido

Descripción general ......................................................................................................................................4

Descripción de la placa.................................................................................................................................8
Instalación ..................................................................................................................................................12
Estructura del programa ............................................................................................................................19
Tipos de datos ............................................................................................................................................21
Variables y constantes ...............................................................................................................................25
Operadores.................................................................................................................................................26
Declaraciones de control............................................................................................................................32
Bucles..........................................................................................................................................................33
Funciones....................................................................................................................................................35
Strings.........................................................................................................................................................37
Objeto String ..............................................................................................................................................43
Hora ............................................................................................................................................................45
Matrices......................................................................................................................................................46
Funciones de E / S.......................................................................................................................................51
Función avanzada de E / S..........................................................................................................................55
Funciones de caracteres.............................................................................................................................56
Biblioteca de Matemáticas ........................................................................................................................63
Funciones trigonométricas.........................................................................................................................64
Due & Zero..................................................................................................................................................65
Modulación de ancho de pulso..................................................................................................................68
Números aleatorios....................................................................................................................................70
Interrupciones............................................................................................................................................72
Comunicación.............................................................................................................................................75
Circuito Inter Integrado..............................................................................................................................78
Interfaz periférica en serie.........................................................................................................................82
LED parpadeante........................................................................................................................................85
LED de desvanecimiento............................................................................................................................88
Lectura de voltaje analógico......................................................................................................................92
Gráfico de barras LED.................................................................................................................................95
Salida del teclado .......................................................................................................................................99
Mensaje de teclado..................................................................................................................................105
Control del botón del mouse...................................................................................................................107
Teclado serial............................................................................................................................................111
Sensor de humedad..................................................................................................................................114
Sensor de temperatura............................................................................................................................119
Detector / sensor de agua........................................................................................................................122
Sensor PIR.................................................................................................................................................125
Sensor ultrasónico....................................................................................................................................130
Interruptor de conexión...........................................................................................................................134
Motor DC ..................................................................................................................................................137
Servomotor...............................................................................................................................................145
Motor paso a paso....................................................................................................................................151
Biblioteca de tonos...................................................................................................................................154
Comunicación inalámbrica.......................................................................................................................159
Comunicación de red................................................................................................................................164

Descripción general

Arduino esuna plataformaprototipo(decódigoabierto)basadaen unhardwareysoftwarefácil de usar. Consiste en una

placa de circuito, que puede programarse (denominado microcontrolador) y un software listo para usar llamado
Arduino IDE (Integrated Development Environment), que se utiliza para escribir y cargarel código de la
computadora en la placa física.

Las características clave son:

•Las placas Arduino pueden leer señales de entrada analógicas o digitales de diferentes sensores y convertirlas en
una salida, como activar un motor, encender / apagar el LED, conectarse a la nube y muchas otras acciones.

• Puede controlar las funciones de su placa enviando un conjunto de instrucciones al microcontrolador de la placa a
través de Arduino IDE (denominado software de carga).

•A diferencia de la mayoría de las placas de circuito programables anteriores, Arduino no necesita una pieza
adicional de hardware (llamado programador) para cargar un nuevo código en la placa. Simplemente puede usar un
cable USB.

•Además,elIDEdeArduinoutilizaunaversiónsimplificadadeC++,loquefacilitaaprender a programar.
•Finalmente, Arduino proporciona un factor de forma estándar que divide las funciones del microcontrolador en un
paquete más accesible.
Tipos de placas
Hay varios tipos de placas Arduino disponibles en función de los diferentes microcontroladores utilizados. Sin
embargo, todas las placas Arduino tienen una cosa en común: se programan a través del IDE de Arduino.

Las diferencias se basan en la cantidad de entradas y salidas (la cantidad de sensores, LED y botones que puede usar
en una sola placa), la velocidad, el voltaje de operación, el factor de forma, etc. Algunas placas están diseñadas para
integrarse y no tienen programación interfaz (hardware), que necesitaría comprar por separado. Algunos pueden
funcionar directamente desde una batería de 3.7V, otros necesitan al menos 5V.

Aquí hay una lista de diferentes placas Arduino disponibles.

Placas Arduino basadas en microcontrolador ATMEGA328

Nombre de la placa Voltaje de operación

Velocidad E / S Entradas PWM UART Interfaz de de reloj digital analógicas programación

Arduino Uno R3 5V 16MHz 14 6 6 6 6 USB a través 1 de
ATMega16U2

Arduino Uno R3 SMD

5V 16MHz 14 6 6 6 6 USB a través 1 de

ATMega16U2
Tablero rojo
5V 16MHz 14 6 6 6 6

1
USB a través de FTDI

Arduino Pro 3.3v / 8 MHz

3.3V 8MHz 14 6 6 6 6 Encabezado 1 compatible con FTDI

Arduino Pro 5V / 16MHz

5V 16MHz 14 6 6 6 6 Encabezado

1 compatible con FTDI Arduino

mini 05 5V 16MHz 14

Encabezado 8 6 6 1 compatible con FTDI

Arduino
Pro mini 3.3V 8MHz 14
3.3v /
8mhz
Encabezado compatible8 6 6 1 con FTDI
Arduino
Pro mini 5V 16MHz 14
5v /
16mhz
Encabezado compatible8 6 6 1 con FTDI
Arduino
Ethernet 5V 16MHz 14 Encabezado 6 6 6 6 1 compatible con FTDI
Arduino
3.3V 8MHz 14Fio
Encabezado 8 6 6 1 compatible con FTDI

LilyPad
Arduino 3.3V 8MHz 14
328 placa
principal

Encabezado compatible6 6 6 6 1 con FTDI

LilyPad
Arduino 3.3V 8MHz 9 9
tablero
simple
Encabezado 4 4

5500
compatible con FTDI

Placas Arduino basadas en microcontrolador ATMEGA32u4 Nombre de la placa Voltaje de operación Velocidad E /
S Entradas

de reloj digital analógicas PWM UART Interfaz de programación

Arduino Leonardo 5V 16MHz 20 12 7 71 USB nativo

Pro micro 5V /
16MHz

5V 16MHz 14 6 6 6 6 USB nativo 1

Pro micro
3.3V /
8MHz

5V 16MHz 14 6 6 6 6 USB nativo 1

LilyPad Arduino USB

3.3V 8MHz 14 6 6 6 6 USB nativo 1

Placas Arduino basadas en microcontrolador ATMEGA2560

Nombre Voltaje de de la operación placa

Velocidad de reloj E / S Entradas digital analógicas PWM UART Interfaz de programación

Arduino
Mega 5V
2560 R3

16MHz 54 dieciséis 14 4 4

USB a través de
ATMega16U2B

Mega
Pro 3.3V 3.3V 8MHz

54 dieciséis 14 4 4 Encabezado compatible con FTDI

Mega

Pro 5V 5V 16MHz 54 dieciséis 14 4 4 Encabezado compatible con FTDI

Mega
Pro Mini 3.3V 8MHz 54 dieciséis 14 4 4

3.3V
Encabezado compatible con FTDI

Placas Arduino basadas en el microcontrolador AT91SAM3X8E

Nombre Voltaje de de la operación placa

Velocidad E / S Entradas PWM UART Interfaz de de reloj digital analógicas programación

Arduino
Mega 3.3V
2560 R3
84MHz 54 12 12 4 4 USB nativo

Descripción de la placa

En este capítulo, aprenderemos sobre los diferentes componentes en la placa Arduino. Estudiaremos la placa
Arduino UNO porque es la placa más popular de la familia de placas Arduino. Además, es la mejor placa para
comenzar con la electrónica y la codificación. Algunas placas se ven un poco diferentes de las que se muestran a
continuación, pero la mayoría de los Arduinos tienen en común la mayoría de estos componentes.
by
Ya
ko
19
76
id
en
ti.
io
USB de alimentación

La placa Arduino puede alimentarse mediante el cable USB de su computadora. Todo lo que necesita hacer es
conectar el cable USB a la conexión USB (1).

Poder (barril Jack)

Las placas Arduino se pueden alimentar directamente de la fuente de alimentación de CA conectándola al Jack de
barril (2).

Regulador de voltaje

La función del regulador de voltaje es controlar el voltaje dado a la placa Arduino y estabilizar los voltajes de CC
utilizados por el procesador y otros elementos.

Oscilador de cristal

El oscilador de cristal ayuda a Arduino a lidiar con problemas de tiempo. ¿Cómo calcula Arduino el tiempo? La
respuesta es, usando el osciladordecristal. Elnúmero impresoenlapartesuperior delcristalArduino es 16,000H9H. Nos
dice que la frecuencia es de 16,000,000 Hertz o 16 MHz.

Arduino Reset

Puede restablecer su placa Arduino, es decir, iniciar su programa desde el principio. Puede restablecer la placa UNO
de dos maneras. Primero, usando el botón de reinicio (17) en el tablero. En segundo lugar, puede conectar un botón
de reinicio externo al pin Arduino etiquetado como RESET (5).

Pines (3.3, 5, GND, Vin)

• 3.3V (6) - Suministro de 3.3 voltios de salida
• 5V (7) - Suministro de 5 voltios de salida

•La mayoría de los componentes utilizados con la placa Arduino funciona bien con 3,3 voltios y 5 voltios.
•GND (8) (Tierra): hay varios pines GND en el Arduino, cualquiera de los cuales puede usarse para conectar a tierra
su circuito.

•Vin (9): este pin también se puede utilizar para alimentar la placa Arduinodesde unafuente de alimentación externa,
comola fuentede alimentación de CA.

Clavijas analógicas

La placa Arduino UNO tiene seis pines de entrada analógica A0 a A5. Estos
pinespuedenleerlaseñaldeunsensoranalógicocomoelsensordehumedad o el sensor de temperatura y convertirlo en un
valor digital que pueda leer el microprocesador.

Microcontrolador principal

Cada placa Arduino tiene su propio microcontrolador (11). Puedes asumirlo comoelcerebrodetutablero.
ElICprincipal(circuitointegrado)enelArduino es ligeramente diferente de placa a placa. Los microcontroladores son
generalmente de la compañía ATMEL. Debe saber qué IC tiene su placa antes de cargar un nuevo programa desde el
IDE de Arduino. Esta información está disponible en la parte superior del IC. Para obtener más detalles sobre la
construcción y las funciones de IC, puede consultar la hoja de datos.

Pin ICSP

Principalmente, ICSP (12) es un AVR, un pequeño encabezado de programación para Arduino que consiste en
MOSI, MISO, SCK, RESET, VCC y GND. A menudo se le conoce como SPI (interfaz periférica en serie), que
podría considerarse como una "expansión" de la salida. En realidad, está esclavizando el dispositivo de salida al
maestro del bus SPI.

Indicador LED de encendido

Este LED debería encenderse cuando conecte su Arduino a una fuente de alimentación para indicar que su placa está
encendida correctamente. Si esta luz no se enciende, entonces hay algo mal con la conexión.

LED TX y RX
En su placa, encontrará dos etiquetas: TX (transmitir) y RX (recibir). Aparecen en dos lugares en el tablero de
Arduino UNO. Primero, en los pines digitales 0 y 1, para indicar los pines responsables de la comunicación en serie.
Segundo,elledTXyRX(13). ElLEDTXparpadeacondiferentevelocidad mientras envía los datos en serie. La velocidad
del parpadeo depende de la velocidad en baudios utilizada por la placa. RX parpadea durante el proceso de
recepción.

E / S digital

La placa Arduino UNO tiene 14 pines de E / S digitales (15) (de los cuales 6 proporcionan salida PWM (modulación
de ancho de pulso). Estos pines se pueden configurar para funcionar como pines digitales de entrada para leer
valores lógicos (0 o 1) o como digitales pines de salida para controlar
diferentesmóduloscomoLED,relés,etc.Lospinesetiquetados"~"se pueden usar para generar PWM.

AREF

AREF significa referencia analógica. A veces, se utiliza para establecer un voltaje de referencia externo (entre 0 y 5
voltios) como límite superior para los pines de entrada analógica.

Instalación

Después de conocer las partes principales de la placa Arduino UNO, estamos listos para aprender cómo configurar
Arduino IDE. Una vez que aprendamos esto, estaremos listos para cargar nuestro programa en la placa Arduino.

En esta sección, aprenderemos en pasos sencillos cómo configurar Arduino IDE en nuestra computadora y preparar
la placa para recibir el programa a través del cable USB.

Paso 1 : primero debe tener su placa Arduino (puede elegir su placa favorita) y un cable USB. En caso de que use
Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560 o Diecimila, necesitará un cable USB estándar
(enchufe A a enchufe B), del tipo que conectaría a una impresora USB como se muestra en la siguiente imagen.

En caso de que use Arduino Nano, necesitará un cable A a Mini-B, como se muestra
en la siguiente imagen.
Paso 2: descargue el software Arduino IDE.

Puede obtener diferentes versiones de Arduino IDE desdela páginade descargas en el sitio web oficial de Arduino.
Debe seleccionar su software, que es compatible con su sistema operativo (Windows, IOS o Linux). Una vez
completada la descarga del archivo, descomprima el archivo.
 Paso 3 - Enciende tu tablero.

Arduino Uno, Mega, Duemilanove y Arduino Nano obtienen energía automáticamente de la conexión USB a la
computadora o de una fuente de alimentación externa. Si está utilizando un Arduino Diecimila, debe asegurarse de
que la placa esté configurada para extraer energía de la conexión USB. La fuente de alimentación se selecciona con
un puente, una pequeña pieza de plástico que se ajusta a dos de los tres pines entre el USB y las tomas de
alimentación. Verifique que esté en los dos pines más cercanos al puerto USB.

Conecte la placa Arduino a su computadora con el cable USB. El LED de alimentación verde (etiquetado PWR)
debería iluminarse.
Paso 4: inicia Arduino IDE.

Después de descargar su software Arduino IDE, debe descomprimir la carpeta. Dentro de la carpeta, puede encontrar
el icono de la aplicación con una etiqueta de infinito (application.exe). Haga doble clic en el icono para iniciar el
IDE.
Paso 5: abre tu primer proyecto.
Una vez que se inicia el software, tiene dos opciones:
• Crea un nuevo proyecto.
• Abrir un ejemplo de proyecto existente.

Para crear un nuevo proyecto, seleccione Archivo → Nuevo .

Para abrir un ejemplo de proyecto existente, seleccione Archivo → Ejemplo → Conceptos básicos → Parpadeo.

Aquí, estamos seleccionando solo uno de los ejemplos con el nombre Blink . Enciende y apaga el LED con cierto
retraso de tiempo. Puede seleccionar cualquier otro ejemplo de la lista.

Paso 6: selecciona tu placa Arduino.

Para evitar cualquier error al cargar su programa en la placa, debe seleccionar el nombre correcto de la placa
Arduino, que coincide con la placa conectada a su computadora.

Vaya a Herramientas → Tablero y seleccione su tablero.

Aquí, hemos seleccionado la placa Arduino Uno de acuerdo con nuestro libro, pero debe seleccionar el nombre que
coincida con la placa que está utilizando.

Paso 7: selecciona tu puerto serie.

Seleccione el dispositivo en serie de la placa Arduino. Vaya al menú Herramientas → Puerto serie . Es probable que
sea COM3 o superior (COM1 y COM2 generalmente están reservados para puertos seriales de hardware). Para
averiguarlo, puede desconectar su placa Arduino y volver a abrir el menú, la entrada que desaparece debe ser de la
placa Arduino. Vuelva a conectar la placa y seleccione ese puerto serie.
Paso 8: sube el programa a tu tablero.

Antesde explicar cómo podemoscargar nuestro programa en el tablero, debemos demostrar la función de cada
símbolo que aparece en la barra de herramientas Arduino IDE.

A - Se usa para verificar si hay algún error de compilación.

B : se utiliza para cargar un programa en la placa Arduino.
C : acceso directo utilizado para crear un nuevo boceto.
D : se utiliza para abrir directamente uno de los bocetos de ejemplo.
E : se utiliza para guardar su boceto.

F : monitor serie utilizado para recibir datos en serie de la placa y enviar los datos en serie a la placa.
Ahora, simplemente haga clic en el botón "Cargar" en el entorno. Espera unos segundos verá los LED RX y TX en
el tablero, parpadeando. Si la carga se realiza correctamente, aparecerá el mensaje "Carga finalizada" en la barra de
estado.

Nota : si tiene un Arduino Mini, NG u otra placa, debe presionar el botónde reinicio físicamente en la placa,
inmediatamente antes de hacer clic en el botón de carga en el software Arduino. Estructura del programa

En este capítulo, estudiaremos en profundidad la estructura del programa Arduino y aprenderemos más
terminologías nuevas utilizadas en el mundo Arduino. El software Arduino esdecódigoabierto.
ElcódigofuenteparaelentornoJavasepublicabajolaGPLylasbibliotecas de microcontroladores C / C ++ están bajo la
LGPL.

Boceto : la primera nueva terminología es el programa Arduino llamado " boceto ". Estructura

Los programas de Arduino se pueden dividir en tres partes principales: Estructura, Valores (variables y constantes) y
Funciones . En este libro, aprenderemos sobre el programa de software Arduino, paso a paso, y cómo podemos
escribir el programa sin ningún error de sintaxis o compilación.

Comencemos con la Estructura . La estructuradelsoftware consta de dosfunciones principales: • Función de

configuración ()
• Función Loop ()

Void setup ( ) {
}

•PROPÓSITO : se llama a la función de configuración () cuando se inicia un boceto. Úselo para inicializar las
variables, modos de pin, comenzar a usar bibliotecas, etc. La función de configuración solo se ejecutará una vez,
después de cada encendido o reinicio de la placa Arduino.
• ENTRADA -
• SALIDA -
• VUELTA -

Void Loop ( ) {
}

•PROPÓSITO :despuésdecrearunafunciónde configuración() ,queinicializa yestablece los valores iniciales, la

función de bucle () hace exactamente lo que sugiere su nombre y realiza bucles consecutivos, permitiendo que su
programa cambie y responda. Úselo para controlar activamente la placa Arduino.

• ENTRADA -
• SALIDA -
• VUELTA -

Tipos de datos

Los tipos de datos en C se refieren a un sistema extenso utilizado para declarar variables o funciones de diferentes
tipos. El tipo de una variable determina cuánto espacio ocupa en el almacenamiento y cómo se interpreta el patrón
de bits almacenado.

La siguiente tabla proporciona todos los tipos de datos que usará durante la programación de Arduino.
void Boolean char Unsigned byte int Unsigned int word char
long Unsigned short float double array String-char Stringlong array object
void
La palabra clave void se usa solo en declaraciones de funciones. Indica que se espera que la función no devuelva
información a la función desde la que se llamó.
Ejemplo

Void Loop ( ) {
// rest of the code
}
Booleano

Un booleano tiene unode dos valores, verdadero o falso. Cada variablebooleana ocupa un byte de memoria.
Ejemplo
boolean val = false ; // declaration of variable with type boolean and initialize it with false boolean state = true ; //
declaration of variable with type boolean and initialize it with true Char

Untipodedatosqueocupa unbytedememoriaque almacenaun valordecarácter. Losliterales de caracteres se escriben

entre comillas simples como esta: 'A' y para varios caracteres, las cadenas usan comillas dobles: "ABC".

Sin embargo, los caracteres se almacenan como números. Puede ver la codificación específica en el gráfico ASCII .
Esto significa que es posible realizar operaciones aritméticas en caracteres, en las que se utiliza el valor ASCII del
carácter. Por ejemplo, 'A' + 1 tiene el valor 66, ya que el valor ASCII de la letra mayúscula A es 65.

Ejemplo
Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a

Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97
unsigned char

Unsigned char es un tipo de datos sin signo que ocupa un byte de memoria. El tipo de datos char sin signo codifica
números del 0 al 255.
Ejemplo

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y
byte
Un byte almacena un número sin signo de 8 bits, de 0 a 255.
Ejemplo

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

Los enteros son el tipo de datos principal para el almacenamiento de números. int almacena un valor de 16 bits (2
bytes). Esto produce un rango de -32,768 a 32,767 (valor mínimo de -2 ^ 15 y un valor máximo de (2 ^ 15) - 1).

El tamaño int varía de una tabla a otra. En Arduino Due, por ejemplo, un int almacena un valor de 32 bits(4 bytes).
Estoproduce un rango de -2,147,483,648 a 2,147,483,647 (valor mínimo de
-2 ^ 31 y un valor máximo de (2 ^ 31) - 1).

Ejemplo
int counter = 32 ;// declaration of variable with type int and initialize it with 32 Unsigned int

Losintssinsigno(enterossinsigno)sonlo mismoqueint en laformaen quealmacenanun valor de 2 bytes. Sin embargo,

en lugar de almacenar números negativos, solo almacenan valores positivos, produciendo un rango útil de 0 a 65.535
(2 ^ 16) - 1). El Due almacena un valor de 4 bytes (32 bits), que varía de 0 a 4,294,967,295 (2 ^ 32 - 1).

Ejemplo

Unsigned int counter = 60 ; // declaration of variable with

type unsigned int and initialize it with 60
Word

En el Uno y otros tableros basados en ATMEGA, una palabra almacena un número sin signo de 16 bits. En Due and
Zero, almacena un número sin signo de 32 bits.
Ejemplo
word w = 1000 ;//declaration of variable with type word and initialize it with 1000 Long
Las variables largas son variables de tamaño extendido para el almacenamiento de números y almacenan 32 bits (4
bytes), de -2,147,483,648 a 2,147,483,647.
Ejemplo
Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346 unsigned long

Las variables largas sin signo son variables de tamaño extendido para almacenar números y almacenar 32 bits (4
bytes). A diferencia de los largos estándar, los largos sin signo no almacenarán números negativos, haciendo su
rango de 0 a 4,294,967,295 (2 ^ 32 - 1).

Ejemplo

Unsigned Long velocity = 101006 ;// declaration of variable with

type Unsigned Long and initialize it with 101006
short

Un corto es un tipo de datos de 16 bits. En todos los Arduinos (basados en ATMega y ARM), un short almacena un
valor de 16 bits (2 bytes). Esto produce un rango de -32,768 a 32,767 (valor mínimo de -2 ^ 15 y un valor máximo
de (2 ^ 15) - 1).

Ejemplo
short val = 13 ;//declaration of variable with type short and initialize it with 13 float

El tipode datospara el número de coma flotante es un númeroquetiene un punto decimal. Los números de punto
flotante a menudo seusan para aproximar los valores analógicos ycontinuos porque tienen una resolución mayor que
los enteros.

Los números de coma flotante pueden ser tan grandes como 3.4028235E + 38 y tan bajos como
-3.4028235E + 38. Se almacenan como 32 bits (4 bytes) de información.
Ejemplo
float num = 1.352;//declaration of variable with type float and initialize it with 1.352 doble

En el Uno y otras placas basadas en ATMEGA, el número de coma flotante de doble precisión ocupa cuatro bytes.
Es decir, la implementación doble es exactamente lamisma que la flotante, singananciaenprecisión. EnelArduino
Due,losdoblestienenunaprecisiónde8bytes(64bits).

Ejemplo

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352 Variables y constantes

Antes de comenzar a explicar los tipos de variables, un tema muy importante que debemos asegurarnos, usted
comprende completamente que se llama alcance variable . ¿Qué es el alcance variable?

Las variables en lenguaje de programación C, que usa Arduino, tienen una propiedad llamada alcance. Un ámbito es
una región del programa y hay tres lugares donde se pueden declarar variables. Ellos son

•Dentro de una función o un bloque, que se llama variables locales .

•En la definición de parámetros de función, que se llama parámetros formales . • Fuera de todas las funciones, que
se llama variables globales .

Variables Locales
Las variables que se declarandentrode una funcióno bloqueson variableslocales. Solo pueden ser utilizados por las
declaraciones que están dentro de esa función o bloque de código. No se sabe que las variables locales funcionen
fuera de las suyas. El siguiente es el ejemplo usando variables locales:

Void setup () {
}

Void loop () {
int x , y ;
int z ; Local variable declaration
x = 0;
y = 0; actual initialization
z = 10;

}
Variables globales
Lasvariablesglobalessedefinenfueradetodaslasfunciones,generalmente enlapartesuperior del programa. Las variables
globales mantendrán su valor durante toda la vida de su programa. Se puedeacceder auna variable global mediante
cualquierfunción. Esdecir, una variableglobal está disponible para su uso en todo su programa después de su
declaración.
El siguiente ejemplo utiliza variables globales y locales:
Int T , S ;
float c = 0 ; Global variable declaration
Void setup () {
}

Void loop () {
int x , y ;
int z ; Local variable declaration x = 0;
y = 0; actual initialization z = 10;

}
Operadores

Un operador es un símbolo que le dice al compilador que realice funciones matemáticas o lógicas específicas. El
lenguaje C es rico en operadores integrados y proporciona los siguientes tipos de operadores:
• Operadores aritméticos
• Operadores de comparación
• Operadores booleanos

• Operadores bit a bit

• Operadores compuestos

Operadores aritméticos
Suponga que la variable A contiene 10 y la variable B contiene 20 y luego Mostrar ejemplo

Nombre del operador Operador Descripción Ejemplo simple

operador de asignación

Almacena el valor a la derecha = del signo igual en la variable a A = B

la izquierda del signo igual.

adición +

Agrega dos operandos

A + B dará 30

sustracción
-
Resta el segundo operando del A - B dará primero -10
multiplicación * *

Multiplica ambos operandos

A * B dará 200

división / /
Dividir numerador por B / A denominador dará 2
módulo %
Operador de módulo y resto B% A después de una división entera dará 0
Operadores de comparación operador simple igual a Comprueba si el valor de dos operandos es (A == B) == igual o
no, en caso afirmativo, la condición no es se vuelve verdadera. cierto
no igual a Comprueba si el valor de dos operandos es(A! = B) es! = igual o no, si los valores no son iguales, ciertoentonces la condición
se vuelve verdadera.
menos que Comprueba si el valor del operando
izquierdo es menor que el valor del (A <B) es< operando derecho, en caso afirmativo, la cierto condición se vuelve verdadera.

mas grande que

Comprueba si el valor del operando
izquierdo es mayor que el valor del (A> B) no> operando derecho, en caso afirmativo, la es cierto condición se vuelve

verdadera.
Menos que o igual a
Comprueba si el valor del operando
izquierdo es menor o igual que el valor del (A <= B) es<= operando derecho, en caso afirmativo, la cierto
condición se vuelve verdadera.
Mayor qué o igual a
Comprueba si el valor del operando(A> = B) > = izquierdo es mayor o igual que el valor delno esoperando derecho, en caso
afirmativo, la cierto
condición se vuelve verdadera.
Operadores booleanos operador simple

Llamado operador lógico AND. Si ambos y && operandos son distintos de cero, entonces la
condición se vuelve verdadera.
(A y B) es cierto
Llamado Lógico O Operador. Si alguno de los o || dos operandos es distinto de cero, entonces la
condición se vuelve verdadera.
(A || B) es cierto

Llamado operador lógico NO. Se usa para invertir el estado lógico de su operando. Si una no
!

condición es verdadera, entonces el operador ! (A y B) es falso

lógico NO hará falso.

Operadores bit a bit Suponga que la variable A tiene 60 y la variable B tiene 13, entonces Mostrar ejemplo

Nombre del Operador operador simple Descripción Ejemplo

y Y El operador binario AND copia un poco al resultado si existe en ambos

operandos.
(A y B) dará 12, que es 0000 1100

o El | El operador binario O copia un bit si existe en cualquiera de los operandos (A | B) dará 61, que es 0011 1101
xor El operador binario XOR copia el bit si (A ^ B) dará

^ está establecido en un operando pero 49, que es no en ambos. 0011 0001

no El operador de complemento de (~ A) dará ~ binarios es unario y tiene el efecto de 60, que es "voltear" los bits.
1100 0011
desplazarse a la izquierda

desplazarse a la derecha
Operador binario de desplazamiento a
la izquierda. El valor de los operandos Un << 2

<<
de la izquierda se mueve hacia la dará 240, izquierda por la cantidad de bits que es 1111 especificados por el
operando de la 0000 derecha.

Operador binario de desplazamiento a

la derecha. El valor de los operandosA >> 2 dará >> de la izquierda se mueve hacia la15, que esderecha por la cantidad de bits 0000
1111
especificados por el operando de la derecha.

Operadores compuestos Suponga que la variable A contiene 10 y la variable B contiene 20 y luego Mostrar ejemplo

Nombre del Operador operador simple Descripción Ejemplo

incremento ++ Operador de incremento, aumenta elA ++ dará 11valor entero en uno
decremento -

Operador de disminución, disminuyeA-- dará 9el valor entero en uno

adición
compuesta Añadir operador de asignación

AND. Agrega el operando derecho al+ = operando izquierdo y asigna el

resultado al operando izquierdo B + = A es

equivalente a B = B + A

resta
compuesta Restar operador de asignación AND. Resta el operando derecho del- = operando izquierdo y asigna el
resultado al operando izquierdo B - = A es
equivalente a B = B - A

multiplicación compuesta Operador de multiplicación Y asignación. Multiplica el operando

* = derecho con el operando izquierdo y asigna el resultado al operando izquierdo

B * = A es
equivalente a B = B * A

división
compuesta Dividir Y operador de
asignación. Divide el operando

/ = izquierdo con el operando derecho y asigna el resultado al operando izquierdo

B / = A es
equivalente a B = B / A

io
módulo

ti.
compuesto Operador de módulo Y
asignación. Toma módulo usando dos% = operandos y asigna el resultado al

en
operando izquierdo
B% = A es
equivalente a B = B% A

compuesto bit a bit o id

76
|=
OR y operador de asignación incluidos a nivel de bit
A | = 2 es lo mismo que A = A | 2
19

compuesto bit a bit y

& = Operador de asignación Y bit a bit A & = 2 es lo mismo que A = A & 2

ko

Declaraciones de control

Las estructuras de toma de decisiones requieren que el programador especifique una o más condiciones para ser
Ya

evaluadas o probadas por el programa. Debe estar junto con una declaración o declaraciones que se ejecutarán si se
determina que la condición es verdadera, y opcionalmente, otras declaraciones que se ejecutarán si se determina que
la condición es falsa.
by

A continuación se presenta la forma general de una estructura de toma dedecisiones típica que se encuentra en la
mayoría de los lenguajes de programación:
 Las declaraciones de control son elementos en el código fuente que
controlan el flujo de ejecución del programa. Ellos son
NO. Declaración de control y descripción
Ifdeclaración
1Toma una expresión entre paréntesis y una declaración o bloque de declaraciones. Si la expresión es verdadera, la
declaración o el bloque de declaraciones se ejecuta de lo contrario, estas declaraciones se omiten.

if ... else declaración

2 Una instrucción if puede ser seguida por una instrucción else opcional, que se ejecuta cuando la expresión es falsa.

if ...else if ... else declaración

3 La instrucción if puede ser seguida por una instrucción opcional else if ... else , que es muy útil para probar varias

condiciones usando la instrucción if ... else if.

Switch case declaración

4 Similar a las declaraciones if, switch ... case controla el flujo de programas al permitir que los programadores
especifiquen diferentes códigos que deben ejecutarse en diversas condiciones.

5Operador condicional? :
El operador condicional? : es el único operador ternario en C.
Bucles
Loslenguajesdeprogramaciónproporcionandiversasestructurasdecontrolquepermitenrutas de ejecución más
complicadas.

Una declaración de bucle nos permite ejecutar una declaración o grupo de declaraciones varias veces y la siguiente
es la forma general de una declaración de bucle en la mayoría de los lenguajes de programación:
El lenguaje de programación C proporciona los siguientes tipos de bucles para manejar los requisitos de bucle.

NO. Bucle y descripción

whilebucle

1 Mientras que los bucles se repetirán continuamente e infinitamente, hasta que la expresión dentro del paréntesis, ()
se vuelva falsa. Algo debe cambiar la variable probada, o el ciclo while nunca saldrá.

do... while bucle

2 El bucle do ... while es similar al bucle while. En el bucle while, la condición de continuacióndel bucle se prueba
al comienzo delbucle antes de realizar el cuerpo del bucle.

for bucle

3 Un bucle for ejecuta declaraciones un número predeterminado de veces. La expresión de control para el bucle se
inicializa, se prueba y se manipula completamente dentro del paréntesis del bucle for.

Bucle anidado
4 El lenguaje C le permite usar un ciclo dentro de otro ciclo. El siguiente ejemplo ilustra el concepto.

Bucle infinito
5 Es el ciclo que no tiene condición de terminación, por lo que el ciclo se vuelve infinito.

Funciones

Las funciones permiten estructurar los programas en segmentos de código para realizar tareas individuales. El caso
típico para crear una función es cuando uno necesita realizar la misma acción varias veces en un programa.

La estandarización de fragmentos de código en funciones tiene varias ventajas: • Las funciones ayudan al
programador a mantenerse organizado. A menudo esto ayuda a conceptualizar el programa.
• Las funciones codifican una acción en un lugar para que la función solo deba pensarse y depurarse una vez.
• Esto también reduce las posibilidades de errores en la modificación, si el código necesita ser cambiado.
• Las funciones hacen que todo el boceto sea más pequeño y compacto porque las secciones de código se reutilizan
muchas veces.
• Facilitan la reutilización del código en otros programas al hacerlo modular, y el uso de funciones a menudo hace
que el código sea más legible.
Hay dos funciones requeridas en un boceto Arduino o un programa, es decir, setup () y loop (). Se deben crear otras
funciones fuera de los corchetes de estas dos funciones.

La sintaxis más común para definir una función es:

Declaración de funciones
Una función se declara fuera de cualquier otra función, encima o debajo de la función de bucle. Podemos declarar la
función de dos maneras diferentes:

La primera forma es simplemente escribir la parte de la función llamada prototipo de función sobre la función de
bucle, que consiste en:

• Tipo de retorno de función

• Nombre de la función
• Tipo de argumento de función, no es necesario escribir el nombre del argumento

El prototipo de la función debe ir seguido de un punto y coma (;).

El siguiente ejemplo muestra la demostración de la declaración de función utilizando el primer método.
Ejemplo

int sum_func (int x, int y) // function declaration {

int z = 0;
z = x+y ;
return z; // return the value

}
void setup () {
Statements // group of statements }

Void loop () {
int result = 0 ;
result = Sum_func (5,6) ; // function call

}
La segunda parte, que se denomina definición o declaración de función, debe declararse debajo de la función de
bucle, que consiste en:

• Tipo de retorno de función

• Nombre de la función
• Tipo de argumento de función, aquí debe agregar el nombre del argumento

•El cuerpo de la función (declaraciones dentro de la función que se ejecutan cuando se llama a la función)
El siguiente ejemplo demuestra la declaración de función utilizando el segundo método. Ejemplo
int sum_func (int , int ) ; // function prototype
void setup () {
Statements // group of statements }

Void loop () {
int result = 0 ;
result = Sum_func (5,6) ; // function call

int sum_func (int x, int y) // function declaration {

int z = 0;
z = x+y ;
return z; // return the value

}
El segundo método simplemente declara la función sobre la función de bucle. Strings

Lascadenasseutilizanparaalmacenartexto. Sepueden usarparamostrartextoenunapantalla LCD o en la ventana del

monitor serie Arduino IDE. Las cadenas también son útiles para almacenar la entrada del usuario. Por ejemplo, los
caracteres que un usuario escribe en un teclado conectado al Arduino.

Hay dos tipos de cadenas en la programación de Arduino:

• Matrices de caracteres, que son las mismas que las cadenas utilizadas en la programación en C.
• La cadena de Arduino, que nos permite usar un objeto de cadena en un boceto. En este capítulo, aprenderemos
cadenas, objetos y el uso de cadenas en bocetos de Arduino. Al final del capítulo, aprenderá qué tipo de cadena usar
en un boceto.
Matrices de caracteres de cadena

El primer tipo de cadena que aprenderemos es la cadena que es una serie de caracteres del tipo char . En el capítulo
anterior, aprendimos qué es una matriz; una serie consecutiva del mismo tipo de variable almacenada en la memoria.
Una cadena esuna matriz de variables char.

Una cadena es una matriz especial que tiene un elemento adicional al final de la cadena, que siempre tiene el valor 0
(cero). Esto se conoce como una "cadena terminada en nulo".
Ejemplo de matriz de caracteres de cadena
Este ejemplo mostrará cómo hacer una cadena e imprimirla en la ventana del monitor en serie. Ejemplo

void setup() {
char my_str[6]; // an array big enough for a 5 character string
Serial.begin(9600);
my_str[0] = 'H'; // the string consists of 5 characters
my_str[1] = 'e';
my_str[2] = 'l';
my_str[3] = 'l';
my_str[4] = 'o';
my_str[5] = 0; // 6th array element is a null terminator
Serial.println(my_str);

}
void loop() {
}

El siguiente ejemplo muestra de qué está compuesta una cadena; una matriz de caracteres con caracteres imprimibles
y 0 como último elemento de la matriz para mostrar que aquí es donde termina la cadena. La cadena se puede
imprimir en la ventana del monitor serie Arduino IDE utilizando Serial.println () y pasando el nombre de la cadena.
Este mismo ejemplo se puede escribir de una manera más conveniente como se muestra a continuación:

Ejemplo

void setup() {
char my_str[] = "Hello";
Serial.begin(9600);
Serial.println(my_str);

}
void loop() {
}

En este boceto, el compilador calcula el tamaño de la matriz de cadenas y también termina automáticamente la
cadena con un cero. Una matriz que tiene seis elementos de longitud y consta de cinco caracteres seguidos de un
cero se crea exactamente de la misma manera que en el boceto anterior.

Manipulación de matrices de cadenas

Podemos alterar una matriz de cadenas dentro de un boceto como se muestra en el siguiente boceto.
Ejemplo

void setup() {
char like[] = "I like coffee and cake"; // create a string
Serial.begin(9600);
// (1) print the string
Serial.println(like);
// (2) delete part of the string
like[13] = 0;
Serial.println(like);
// (3) substitute a word into the string
like[13] = ' '; // replace the null terminator with a space
like[18] = 't'; // insert the new word
like[19] = 'e';
like[20] = 'a';
like[21] = 0; // terminate the string
Serial.println(like);
}
void loop() {
}
Resultado

I like coffee and cake

I like coffee
I like coffee and tea

El boceto funciona de la siguiente manera.

Crear e imprimir la cadena

Enelbocetoanterior,secreaunanuevacadena yluegoseimprimeparamostrarlaen laventana del Monitor de serie.

Acortando la cuerda

La cadena se acorta reemplazando el decimocuarto carácter de la cadena con un cero de terminación nulo(2). Este es
el elemento número13 en el conjunto de cadenas contando desde 0.

Cuando se imprime la cadena, todos los caracteres se imprimen hasta el nuevo cero de terminación nulo. Los otros
personajes no desaparecen; todavía existen en la memoria y la matriz de cadenas sigue siendo del mismo tamaño. La
única diferencia esque cualquier función que funcione con cadenas solo verá la cadena hasta el primer terminador
nulo.

Cambiar una palabra en la cadena

Finalmente, el boceto reemplaza la palabra "pastel" con "té" (3). Primero tiene que reemplazar el terminador nulo en
like [13] con un espacio para que la cadena se restaure al formato creado originalmente.

Los nuevos caracteres sobrescriben "cak" de la palabra "pastel" con lapalabra "té". Esto sehace sobrescribiendo
caracteres individuales. La 'e' de "pastel" se reemplaza con un nuevo carácter de terminación nula.
Elresultadoesquelacadena está realmenteterminada con doscaracteres nulos, el original al final de la cadena y el
nuevo que reemplaza la 'e' en "torta". Esto no hace
ningunadiferenciacuandoseimprimelanuevacadenaporquelafunciónqueimprimelacadena deja de imprimir los
caracteres de la cadena cuando encuentra el primer terminador nulo.

Funciones para manipular matrices de cadenas

El bocetoanteriormanipuló lacadena deformamanualaccediendo a caracteres individuales en la cadena. Para facilitar

la manipulación de matrices de cadenas, puede escribir sus propias funciones para hacerlo, o utilizar algunas de las
funciones de cadena de la biblioteca de lenguaje C.

A continuación se muestra la lista Funciones para manipular matrices de cadenas El siguiente boceto utiliza algunas
funciones de cadena C.
Ejemplo

void setup() {
char str[] = "This is my string"; // create a string
char out_str[40]; // output from string functions placed here int num; // general purpose integer
Serial.begin(9600);

// (1) print the string Serial.println(str);

// (2) get the length of the string (excludes null terminator) num = strlen(str);
Serial.print("String length is: ");
Serial.println(num);

// (3) get the length of the array (includes null terminator) num = sizeof(str); // sizeof() is not a C string function
Serial.print("Size of the array: ");
Serial.println(num);

// (4) copy a string strcpy(out_str, str); Serial.println(out_str);

// (5) add a string to the end of a string (append) strcat(out_str, " sketch.");
Serial.println(out_str);
num = strlen(out_str);
Serial.print("String length is: ");
Serial.println(num);
num = sizeof(out_str);
Serial.print("Size of the array out_str[]: "); Serial.println(num);

}
void loop() {
}
Resultado

This is my string
String length is: 17
Size of the array: 18 This is my string
This is my string sketch. String length is: 25
Size of the array out_str[]: 40

El boceto funciona de la siguiente manera.

Imprimir la cadena

La cadena recién creada se imprime en la ventana Serial Monitor como se hizo en bocetos anteriores.
Obtener la longitud de la cuerda
La función strlen () se usa para obtener la longitudde la cadena. La longitudde la cadena es solo para los caracteres
imprimibles y no incluye el terminador nulo.

La cadena contiene 17 caracteres, por lo que vemos 17 impresos en la ventana Serial Monitor. Obtenga la longitud
de la matriz

El operador sizeof () se usa para obtener la longitud de la matriz que contiene la cadena. La longitud incluye el
terminador nulo, por lo que la longitud es uno más que la longitud de la cadena.

sizeof () parece una función, pero técnicamente es un operador. No es parte de la biblioteca de cadenas C, pero se
utilizó en el boceto para mostrar la diferencia entre el tamaño de la matriz y el tamaño de la cadena (o longitud de la
cadena).

Copiar una cadena

La función strcpy () se usa para copiar la cadena str [] a la matriz out_num []. La función strcpy () copia la segunda
cadena que se le pasó a la primera cadena. Ahora existe una copia de la cadena en la matriz out_num [], pero solo
ocupa 18 elementos de la matriz, por lo que todavía tenemos 22 elementos de caracteres libres en la matriz. Estos
elementos libres se encuentran después de la cadena en la memoria.

La cadena se copió a la matriz para que tengamos espacio adicional en la matriz para usar en la siguiente parte del
boceto, que es agregar una cadena al final de una cadena. Agregar una cadena a una cadena (concatenar)

El boceto une una cadena con otra, lo que se conoce como concatenación. Esto se hace usando la función strcat ().
La función strcat () coloca la segunda cadena que se le pasa al final de la primera cadena que se le pasa.

Despuésdelaconcatenación,lalongituddelacadenaseimprimeparamostrarlanuevalongitud de la cadena. La longitud de

la matriz se imprime para mostrar que tenemos una cadena de 25 caracteres en una matriz de 40 elementos.

Recuerde que la cadena larga de 25 caracteres ocupa 26 caracteres de la matriz debido a que el cero termina en cero.
Array Bounds
Cuando se trabaja con cadenas y matrices, es muy importante trabajar dentro de los límites de las cadenas o
matrices. En el boceto de ejemplo, se creó una matriz, que tenía 40 caracteres de largo, para asignar la memoria que
podría usarse para manipular cadenas.

Si la matriz se hizo demasiado pequeña e intentamos copiar una cadena que es más grande que la matriz, la cadena
se copiará sobre el final de la matriz. La memoria más allá del final de la matriz podría contener otros datos
importantes utilizados en el boceto, que luego serían sobrescritos por nuestra cadena. Si la memoria más allá del
final de la cadena se desborda, podría bloquear el boceto o provocar un comportamiento inesperado.

Objeto String
El segundo tipo de cadena utilizada en la programación de Arduino es el objeto de cadena. ¿Qué es un objeto?

Un objeto es una construcción que contiene datos y funciones. Un objeto String se puede crear como una variable y
se le puede asignar un valor o cadena. El objeto String contiene funciones (que se denominan "métodos" en la
programación orientada a objetos (OOP)) que operan en los datos de cadena contenidos en el objeto String.

El siguiente bosquejo y explicación aclarará qué es un objeto y cómo se usa el objeto String. Ejemplo

void setup() {
String my_str = "This is my string.";
Serial.begin(9600);

// (1) print the string Serial.println(my_str);

// (2) change the string to upper-case my_str.toUpperCase();

Serial.println(my_str);

// (3) overwrite the string my_str = "My new string."; Serial.println(my_str);

// (4) replace a word in the string

my_str.replace("string", "Arduino sketch"); Serial.println(my_str);

// (5) get the length of the string Serial.print("String length is: "); Serial.println(my_str.length());

}
void loop() {
}
Resultado

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

Se crea un objeto de cadena y se le asigna un valor (o cadena) en la parte superior del boceto. String my_str = "This
is my string." ;
Esto crea un objeto String con el nombre my_str y le da un valor de "Esta es mi cadena".

Esto se puede comparar con la creación de una variable y asignarle un valor como un número entero:

int my_var = 102;

El boceto funciona de la siguiente manera.
Imprimir la cadena

La cadena se puede imprimir en la ventana del Monitor de serie como una cadena de matriz de caracteres.
Convertir la cadena a mayúsculas
El objeto de cadena my_str que se creó tiene una serie de funciones o métodos que se pueden operar en él. Estos
métodos se invocan usando el nombre de los objetos seguido del operador de punto (.) Y luego el nombre de la
función a usar.

my_str.toUpperCase();

La función toUpperCase () opera en la cadena contenida en el objeto my_str que es de tipo String y convierte los
datos de cadena (o texto) que el objeto contiene en mayúsculas. Puede encontrar una lista de las funciones que
contiene la clase String en la referencia de Arduino String. Técnicamente, String se llama una clase y se usa para
crear objetos String.

Sobrescribir una cadena

Eloperadordeasignaciónseusaparaasignarunanuevacadenaalobjeto my_str quereemplaza la cadena anterior

my_str = "My new string." ;

El operador de asignación no se puede usar en cadenas de matriz de caracteres, sino que solo funciona en objetos de
cadena.

Reemplazar una palabra en la cadena

La función replace () se usa para reemplazar la primera cadena que le pasó por la segunda cadena que le pasó.
replace () es otra función integrada en la clase String y, por lo tanto, está disponible para usar en el objeto String
my_str.

Obteniendo la longitud de la cuerda

Obtener la longitud de la cadena se hace fácilmente usando length (). En el boceto de ejemplo, el resultado devuelto
por length () se pasa directamente a Serial.println () sin usar una variable intermedia.

Cuándo usar un objeto de cadena

Un objeto de cadena es mucho más fácil de usar que una matriz de caracteres de cadena. El objeto tiene funciones
integradas que pueden realizar una serie de operaciones en cadenas.

La principal desventaja de usar el objeto String es que usa mucha memoria y puede usar rápidamente la memoria
RAM de Arduinos, lo que puede causar que Arduino se cuelgue, se bloquee o se comporte de forma inesperada. Si
un boceto en un Arduino es pequeño y limita el uso de objetos, entonces no debería haber problemas.

Las cadenas de matriz de caracteres son más difíciles de usar y es posible que deba escribir sus propias funciones
para operar con este tipo de cadenas. La ventaja es que tiene control sobre el tamaño de las matrices de cadenas que
realiza, por lo que puede mantener las matrices pequeñas para ahorrar memoria.

Debe asegurarse de no escribir más allá del final de los límites de la matriz con las matrices de cadenas. El objeto
String no tiene este problema y se encargará de los límites de la cadena,
siemprequehayasuficientememoriaparaquefuncione. ElobjetoStringpuedeintentarescribir en la memoria que no
existe cuando se queda sin memoria, pero nunca escribirá sobre el final de la cadena en la que está operando.

Donde se usan cuerdas

En este capítulo estudiamos las cadenas, cómo se comportan en la memoria y sus operaciones.

Los usos prácticos de las cadenas se tratarán en la siguiente parte de este curso cuando estudiemos cómo obtener la
entrada del usuario desde la ventana del Monitor de serie y guardar la entrada en una cadena.

Hora
Arduino proporciona cuatro funciones diferentes de manipulación de tiempo. Ellos son
No. Función descriptiva
función delay ()
1 La forma en que funciona la función delay () es bastante simple. Acepta un único argumento entero (o número).
Este número representa el tiempo (medido en milisegundos).

función delayMicroseconds ()
2 La función delayMicroseconds () acepta un único argumento entero (o número). Hay mil microsegundos en un

milisegundo y un millón de microsegundos en un segundo.

función millis ()
3 Esta función se utiliza para devolver el número de milisegundos en el momento, la placa Arduino comienza a

ejecutar el programa actual.

función micros ()

4 4 La función micros ()devuelve el númerode microsegundosdesdeel momento en que la placa Arduino comienza a
ejecutar el programa actual. Este número se desborda, es decir, vuelve a cero después de aproximadamente 70
minutos.

Matrices

Una matriz es un grupo consecutivo de ubicaciones de memoria que son del mismo tipo. Para referirnos a una
ubicación o elemento particular en la matriz, especificamos el nombre de la matriz y el número de posición del
elemento particular en la matriz.

La ilustración que se muestra a continuación muestra una matriz entera llamada Cque contiene 11 elementos. Usted
hace referencia a cualquiera de estos elementos dando el nombre de la matriz seguido del número de posición del
elemento particular entre corchetes ([]).El número de posición se denomina más formalmente subíndice o índice
(este número especifica el número de elementos desde el comienzo de la matriz). El primer elemento tiene subíndice
0 (cero) y a veces se le llama el elemento ceros.

Por lo tanto, los elementos de la matriz C son C [0] (pronunciado "C sub cero"), C [1], C [2] y así sucesivamente. El
subíndice más alto en la matriz C es 10, que es 1 menos que el número de elementos en la matriz (11). Los nombres
de matriz siguen las mismas convenciones que otros nombres de variables.
Un subíndice debe ser un entero o una expresión entera (usando cualquier tipo integral). Si un programa usa una
expresión como subíndice, entonces el programa evalúa la expresión para determinarelsubíndice.
Porejemplo,sisuponemosquelavariableaesiguala5yquelavariable b es igual a 6, entonces la declaración agrega 2 al
elemento de matriz C [11].

Un nombre de matriz con subíndice es un valor l, se puede usar en el lado izquierdo de una asignación, al igual que
los nombres de variables sin matriz.

Examinemos la matriz C en la figura dada, más de cerca. El nombre de toda la matriz es C. Sus 11 elementos se
denominan C [0] a C [10]. El valor de C [0] es -45, el valor de C [1] es 6, el valor de C [2] es 0, el valor de C [7] es
62 y el valor de C [10] es 78)

Para imprimir la suma de los valores contenidos en los primeros tres elementos de la matriz C, escribiríamos:

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );
Para dividir el valor de C [6] entre 2 y asignar el resultado a la variable x, escribiríamos:

x = C[ 6 ] / 2;
Declarar matrices
Las matrices ocupan espacio en la memoria. Para especificar el tipo de elementos y el número de elementos
requeridos por una matriz, use una declaración de la forma:
type arrayName [ arraySize ] ;

El compilador reserva la cantidad adecuada de memoria. (Recuerde que una declaración, que reserva memoria, se
conoce más propiamente como definición). El arraySize debe ser una constante entera mayor que cero. Por ejemplo,
para decirle al compilador que reserve 11 elementos para la matriz de enteros C, use la declaración:

int C[ 12 ]; // C is an array of 12 integers

Se puede declarar que las matrices contienen valores de cualquier tipo de datos sin referencia. Por ejemplo, se puede
usar una matriz de cadenas de tipo para almacenar cadenas de caracteres.

Ejemplos de uso de matrices

Esta sección ofrece muchos ejemplos que demuestran cómo declarar, inicializar y manipular matrices.
Ejemplo 1: declarar una matriz y usar un bucle para inicializar los elementos de la matriz

El programa declara una matriz de enteros de 10 elementos n . Las líneas a – b usan una instrucción For para
inicializar los elementos de la matriz a ceros. Al igual que otras variables automáticas, las matrices automáticas no
se inicializan implícitamente a cero. La primera declaración de salida (línea c) muestra los encabezados de columna
para las columnas impresas en la declaración posterior (líneas d – e), que imprime la matriz en formato tabular.

Ejemplo
int n[ 10 ] ; // n is an array of 10 integers
void setup () {
}

void loop () {
for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 { n[ i ] = 0; // set element at location i to 0
Serial.print (i) ;
Serial.print (‘\r’) ;

}
for ( int j = 0; j < 10; ++j ) // output each array element's value { Serial.print (n[j]) ;
Serial.print (‘\r’) ;
}
}

Resultado : producirá el siguiente resultado:

Element Value

00
30
40
50
60
70
80
90

Ejemplo 2: Inicializar una matriz en una declaración con una lista de inicializadores

Los elementos de una matriz también se pueden inicializar en la declaración de la matriz siguiendo elnombredela
matriz conun signo igual a y una lista de inicializadores separadospor comas delimitados por llaves. El programa
utiliza una lista de inicializadores para inicializar una matriz entera con 10 valores (línea a) e imprime la matriz en
formato tabular (líneas b – c).

Ejemplo
// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;
void setup () {
}

void loop () {
for ( int i = 0; i < 10; ++i ) {
Serial.print (i) ;
Serial.print (‘\r’) ;

}
for ( int j = 0; j < 10; ++j ) // output each array element's value { Serial.print (n[j]) ;
Serial.print (‘\r’) ;
}
}

Resultado : producirá el siguiente resultado:

Element Value
2 64
3 18
4 95
5 14
6 90
7 70
8 60
9 37

Ejemplo 3: Sumar los elementos de una matriz

A menudo, los elementos de una matriz representan una serie de valores que se utilizarán en un cálculo. Por
ejemplo, si los elementos de una matriz representan las calificaciones del examen, un profesor puede desear sumar
los elementos de la matriz y usar esa suma para calcular el promedio de la clase para el examen. El programa suma
los valores contenidos en la matriz de enteros de 10 elementos a .

Ejemplo

const int arraySize = 10; // constant variable indicating size of array

int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
// sum contents of array a
for ( int i = 0; i < arraySize; ++i )
total += a[ i ];
Serial.print (“Total of array elements : ”) ;
Serial.print(total) ;
}

Resultado : producirá el siguiente resultado: Total of array elements: 849

Las matrices son importantes para Arduino y deberían necesitar mucha más atención. Los siguientes conceptos
importantes relacionados con la matriz deberían ser claros para un Arduino:

NO. Concepto y descripción

1 Pasar matrices a funciones
Para pasarun argumentode matriz aunafunción,especifiqueel nombrede la matriz sin corchetes.
2 Matrices multidimensionales Lasmatricescondosdimensiones(esdecir,subíndices)amenudo representan tablas de
valores que consisten en información organizada en filas y columnas.
Funciones de E / S

Los pines de la placa Arduino se pueden configurar como entradas o salidas. Explicaremos el funcionamiento de los
pines en esos modos. Es importante tener en cuenta que la mayoría de los pines analógicos Arduino se pueden
configurar y usar exactamente de la misma manera que los pines digitales.

Pines configurados como ENTRADA

Los pines Arduino están configurados por defecto como entradas, por lo que no es necesario declararlos
explícitamente como entradas con pinMode () cuando los está utilizando como entradas. Se dice que los pines
configurados de esta manera están en un estado de alta impedancia. Los pines de entrada hacen demandas
extremadamente pequeñas en el circuito que están muestreando, equivalente a una resistencia en serie de 100
megaohmios delante del pin.

Esto significa que se necesita muy poca corriente para cambiar el pin de entrada de un estado a otro. Esto hace que
los pines sean útiles para tareas tales como implementar un sensor táctil capacitivo o leer un LED como fotodiodo.

Los pines configurados como pinMode (pin, INPUT) sin nada conectado a ellos, o con cables conectados aellosque
no están conectados aotros circuitos,informan cambios aparentemente aleatorios en el estado del pin, captando ruido
eléctrico del entorno o acoplando capacitivamente el estado de un pin cercano.

Resistencias Pull-up

Las resistencias pull-up a menudo son útiles para dirigir un pin de entrada a un estado conocido si no hay entrada
presente. Esto se puede hacer agregando una resistencia pull-up (a + 5V), o una resistencia pull-down (resistencia a
tierra) en la entrada. Una resistencia de 10K es un buen valor para una resistencia pull-up o pull-down.

Uso de la resistencia pull-up incorporada con pines configurados como entrada

Hay 20,000 resistencias pull-up integradas en el chip Atmega a las que se puede acceder desde el software. Se
accede a estas resistencias pull-up incorporadas configurando el pinMode () como INPUT_PULLUP. Esto invierte
efectivamente el comportamiento del modo ENTRADA, donde ALTO significa que el sensor está APAGADO y
BAJO significa que el sensor está ENCENDIDO. El valor de este pull-up depende del microcontrolador utilizado.
En la mayoría de las placas basadas en AVR, el valor está garantizado entre 20kΩ y 50kΩ. En el Arduino Due, está
entre 50kΩ y 150kΩ. Para conocer el valor exacto, consulte la hoja de datos del microcontrolador en su placa.

Al conectar un sensor a un pin configurado con INPUT_PULLUP, el otro extremo debe estar conectado a tierra. En
el caso de un interruptor simple, esto hace que el pin lea ALTO cuando el interruptor está abierto y BAJO cuando se
presiona el interruptor. Las resistencias pull-up proporcionan suficiente corriente para encender un LED débilmente
conectado a un pin configurado como entrada. Si los LED en un proyecto parecen estar funcionando, pero muy
tenuemente, esto es probablemente lo que está sucediendo.

Los mismos registros (ubicaciones de memoria de chip interno) que controlan si un pin es ALTO o BAJO controlan
las resistencias pull-up. En consecuencia, un pin que está configurado para tenerresistenciaspull-
upactivadascuandoelpinestáenmodoINPUT,tendráelpinconfigurado como HIGH si el pin se cambia a un modo
OUTPUT con pinMode (). Esto también funciona en la otra dirección, y un pin de salida que se deja en estado
ALTO tendrá la resistencia pull-up configurada si se cambia a una entrada con pinMode ().

Ejemplo

pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor

pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor
Pines configurados como SALIDA

Se dice que los pines configurados como SALIDA con pinMode () están en un estado de baja impedancia.Esto
significaquepuedenproporcionarunacantidadsustancialdecorrienteaotros circuitos. Los pines Atmega pueden generar
(proporcionar corriente positiva) o hundirse (proporcionar corriente negativa) hasta 40 mA (miliamperios) de
corriente a otros dispositivos / circuitos. Esto es suficiente corriente para iluminar un LED (no olvide la resistencia
en serie) o hacer funcionar muchos sensores, pero no suficiente corriente para hacer funcionar relés, solenoides o
motores.

Intentar ejecutar dispositivos de alta corriente desde los pines de salida, puede dañar o destruir los transistores de
salida en el pin, o dañar todo el chip Atmega. A menudo, esto da como resultado un pin "muerto" en el
microcontrolador, pero los chips restantes aún funcionan adecuadamente. Por esta razón, es una buena idea conectar
los pines de SALIDA a otros dispositivos a través de resistencias de 470Ω o 1k, a menos que se requiera la máxima
corriente extraída de los pines para una aplicación en particular.
Función pinMode ()

La función pinMode () se utiliza para configurar un pin específico para que se comporte como entrada o como
salida. Es posible habilitar las resistencias pull-up internas con el modo INPUT_PULLUP. Además, el modo INPUT
inhabilita explícitamente los pull-ups internos.

Sintaxis de la función pinMode ()

Void setup () {
pinMode (pin , mode);
}

• pin : el número del pin cuyo modo desea establecer • modo - INPUT, OUTPUT o INPUT_PULLUP. Ejemplo

int button = 5 ; // button connected to pin 5 int LED = 6; // LED connected to pin 6

void setup () {
pinMode(button , INPUT_PULLUP);
// set the digital pin as input with pull-up resistor pinMode(button , OUTPUT); // set the digital pin as output

}
void setup () {

If (digitalRead(button ) == LOW) // if button pressed {

digitalWrite(LED,HIGH); // turn on led
delay(500); // delay for 500 ms
digitalWrite(LED,LOW); // turn off led
delay(500); // delay for 500 ms

}
}
Función digitalWrite ()

La función digitalWrite () se usa para escribir un valor ALTO o BAJO en un pin digital. Si el pin se ha configurado
como una SALIDA con pinMode () , su voltaje se establecerá en el valor correspondiente: 5V (o 3.3V en placas de
3.3V) para ALTO, 0V (tierra) para BAJO. Si el pin está configurado como ENTRADA, digitalWrite () habilitará
(ALTO) o deshabilitará (BAJO) el pullup interno en el pin de entrada. Se recomienda establecer pinMode () en
INPUT_PULLUP para habilitar la resistencia pull-up interna.

Si no configura el pinMode ()en OUTPUT y conecta un LED a un pin, cuando llame a digitalWrite (HIGH), el LED
puede aparecer apagado. Sin establecer explícitamente pinMode (), digitalWrite ()habráhabilitadolaresistenciapull-
upinterna,queactúa comounagranresistencialimitadora de corriente.
Sintaxis de la función digitalWrite ()

Void loop() {
digitalWrite (pin ,value);
}

•pin : el número del pin cuyo modo desea establecer • valor : ALTO o BAJO.
Ejemplo
int LED = 6; // LED connected to pin 6

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

void setup () {
digitalWrite(LED,HIGH); // turn on led
delay(500); // delay for 500 ms
digitalWrite(LED,LOW); // turn off led
delay(500); // delay for 500 ms

}
función analogRead ()

Arduino puede detectar si hay un voltaje aplicado a uno de sus pines e informarlo a través de la función digitalRead
(). Hay una diferencia entre un sensor de encendido / apagado (que detecta la presencia de un objeto) y un sensor
analógico, cuyo valor cambia continuamente. Para leer este tipo de sensor, necesitamos un tipo diferente de pin.

En la parte inferior derecha de la placa Arduino, verá seis pines marcados como "Entrada analógica". Estos pines
especiales nosolo indican si hay unvoltaje aplicadoa ellos, sino también su valor. Al usar la función analogRead () ,
podemos leer el voltaje aplicado a uno de los pines.

Esta funcióndevuelveunnúmeroentre0 y 1023,que representa voltajesentre0y5voltios. Por ejemplo, si hay un voltaje

de 2.5 V aplicado al pin número 0, analogRead (0) devuelve 512. Sintaxis de la función analogRead ()
analogRead(pin);
• pin : el número del pin de entrada analógica para leer (0 a 5 en la mayoría de las placas, 0 a 7 en el Mini y Nano, 0
a 15 en el Mega)
Ejemplo

int analogPin = 3;//potentiometer wiper (middle terminal)

// connected to analog pin 3
int val = 0; // variable to store the value read
void setup() {
Serial.begin(9600); // setup serial }

void loop() {
val = analogRead(analogPin); // read the input pin Serial.println(val); // debug value

}
Función avanzada de E / S
En este capítulo, aprenderemos algunas funciones avanzadas de entrada y salida.
Función analogReference ()

Configura el voltaje de referencia utilizado para la entrada analógica (es decir, el valor utilizado como la parte
superior del rango de entrada). Las opciones son:
• PREDETERMINADO : la referencia analógica predeterminada de 5 voltios (en placas Arduino de 5 V) o 3,3
voltios (en placas Arduino de 3,3 V)
• INTERNO :una referencia incorporada,iguala1.1voltiosenelATmega168 oATmega328 y 2.56 voltios en el

io
ATmega8 (no disponible en el Arduino Mega)

ti.
•INTERNAL1V1 : una referencia incorporada de 1.1V (solo Arduino Mega) • INTERNAL2V56 : una referencia
incorporada de 2.56V (solo Arduino Mega) • EXTERNO : el voltaje aplicado al pin AREF (solo de 0 a 5 V) se
utiliza como referencia

en
analogReference () Función Sintaxis
analogReference (type);
id
tipo : puede usar cualquier tipo de seguimiento (PREDETERMINADO, INTERNO, INTERNO1V1,
INTERNO2V56, EXTERNO)
76
No utilice nada menos de 0 V o más de 5 V para voltaje de referencia externo en el pin AREF. Si está utilizando una
referencia externa enel pin AREF, debe establecer lareferencia analógica en EXTERNA antes de llamar a la función
analogRead () . De lo contrario, acortará el voltaje de referencia activo (generado internamente) y el pin AREF,
19

posiblemente dañando el microcontrolador en su placa Arduino.

ko
Ya
by

Alternativamente, puede conectar el voltaje de referencia externo al pin AREF a través de una resistencia de 5K, lo
que le permite cambiar entre voltajes de referencia externos e internos.

Tenga en cuenta que la resistencia alterará el voltaje que se utiliza como referencia porque hay una resistencia
interna de 32K en el pin AREF. Los dos actúan como un divisor de voltaje. Por ejemplo, 2.5V aplicado a través de
la resistencia producirá 2.5 * 32 / (32 + 5) = ~ 2.2V en el pin AREF.

Ejemplo
int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 int val = 0; // variable to store
the read value

void setup() {
Serial.begin(9600); // setup serial
analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only)

// is used as the reference.

}

void loop() {
val = analogRead(analogPin); // read the input pin
Serial.println(val); // debug value

}
Funciones de caracteres

Todos los datos se ingresan en las computadorascomo caracteres, que incluyen letras, dígitos y varios símbolos
especiales. En esta sección, discutimos las capacidades de C ++ para examinar y manipular caracteres individuales.

La biblioteca de manejo de caracteres incluye varias funciones que realizan pruebas y manipulaciones útiles de datos
de caracteres. Cada función recibe un carácter, representado como int, o EOF como argumento. Los personajes a
menudo se manipulan como enteros. Recuerde que EOF normalmente tiene el valor –1 y que algunas arquitecturas
de hardware no permiten almacenar valores negativos en variables char. Por lo tanto, las funciones de manejo de
caracteres manipulan caracteres como enteros.

La siguiente tabla resume las funciones de la biblioteca de manejo de caracteres. Cuando utilice funciones de la
biblioteca de manejo de caracteres, incluya el encabezado <cctype> .
No. Prototipo y Descripción
1 int isdigit (int c)
Devuelve 1 si c es un dígito y 0 en caso contrario.
2 int isalpha (int c)
Devuelve 1 si c es una letra y 0 en caso contrario.
3 int isalnum (int c)
Devuelve 1 si c es un dígito o una letra y 0 en caso contrario.
int isxdigit (int c)
Devuelve 1 si c es un carácter de dígito hexadecimal y 0 en caso contrario.4
(Consulte el Apéndice D, Sistemas de números, para obtener una explicación detallada de los números binarios,
octales, decimales y hexadecimales).
5 int islower (int c)
Devuelve 1 si c es una letra minúscula y 0 en caso contrario.
6 int isupper (int c)
Devuelve 1 si c es una letra mayúscula; 0 de lo contrario. int isspace (int c)
Devuelve 1 si c es un carácter de espacio en blanco: nueva línea ('\ n'), espacio7
(''), avance de formulario ('\ f'), retorno de carro ('\ r'), pestaña horizontal ('\ t') o pestaña vertical ('\ v') - y 0 en caso
contrario.
int iscntrl (int c)

Devuelve 1 si c es un carácter de control, como nueva línea ('\ n'), avance de 8

formulario ('\ f'), retorno de carro ('\ r'), pestaña horizontal ('\ t'), pestaña vertical (' \ v '), alerta (' \ a ') o retroceso (' \
b '), y 0 en caso contrario.

int ispunct (int c)

9 Devuelve 1 si c es un carácter de impresión distinto de un espacio, un dígito o una letra y 0 en caso contrario.
int isprint (int c)
10 Devuelve 1 si c es un carácter de impresión que incluye espacio ('') y 0 en caso contrario.

int isgraph (int c)

11 Devuelve 1 si c es un carácter de impresión distinto del espacio ('') y 0 en caso contrario.

Ejemplos

El siguiente ejemplo demuestra el uso de las funciones isdigit, isalpha, isalnum e isxdigit . La función isdigit
determina si su argumento es un dígito (0–9). La función isalpha determina si su argumento es una letra mayúscula
(AZ) o una letra minúscula (a – z). La función isalnum determina si su argumento es una letra mayúscula, minúscula
o un dígito. La función isxdigit determina si su argumento es un dígito hexadecimal (A – F, a – f, 0–9).

Ejemplo 1

void setup () {
Serial.begin (9600);
Serial.print ("According to isdigit:\r");
Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
Serial.print (" digit\r" );
Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ; Serial.print (" digit\r");
Serial.print ("\rAccording to isalpha:\r" ); Serial.print (isalpha('A' ) ?"A is a": "A is not a"); Serial.print (" letter\r");
Serial.print (isalpha('A' ) ?"b is a": "b is not a"); Serial.print (" letter\r");
Serial.print (isalpha('A') ?"& is a": "& is not a"); Serial.print (" letter\r");
Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a"); Serial.print (" letter\r");
Serial.print ("\rAccording to isalnum:\r"); Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

Serial .print (" digit or a letter\r" );

Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ; Serial.print (" digit or a letter\r");
Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" ); Serial.print (" digit or a letter\r");
Serial.print ("\rAccording to isxdigit:\r"); Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" ); Serial.print ("
hexadecimal digit\r" );
Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ; Serial.print (" hexadecimal digit\r" );
Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

Serial .print (" hexadecimal digit\r" );

Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" ); Serial.print (" hexadecimal digit\r" );
Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");

}
void loop () {
}
Resultado

According to isdigit: 8 is a digit

# is not a digit
According to isalpha: A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum: A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter According to isxdigit:
F is a hexadecimal digit J is not a hexadecimal digit 7 is a hexadecimal digit

$ is not a hexadecimal digit

f is a hexadecimal digit
Usamos el operador condicional (? :) con cada función para determinar si la cadena "es un" o la cadena "no es un"
debe imprimirse en la salida para cada carácter probado. Por ejemplo, la línea a indica que si '8' es un dígito, es
decir, si isdigit devuelve un valor verdadero (distinto de cero), se imprime la cadena "8 es a". Si '8' no es un dígito
(es decir, si isdigit devuelve 0), se imprime la cadena "8 no es a".

Ejemplo 2

El siguiente ejemplo demuestra el uso de las funciones islower e isupper . La función islower determina si su
argumento es una letra minúscula (a – z). La función isupper determina si su argumento es una letra mayúscula (A –
Z).

int thisChar = 0xA0;

void setup () {
Serial.begin (9600);
Serial.print ("According to islower:\r") ; Serial.print (islower( 'p' ) ? "p is a" : "p is not a" ); Serial.print ( " lowercase
letter\r" );
Serial.print ( islower( 'P') ? "P is a" : "P is not a") ; Serial.print ("lowercase letter\r");
Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" ); Serial.print ( " lowercase letter\r" );
Serial.print ( islower( '!' )? "! is a" : "! is not a") ; Serial.print ("lowercase letter\r");

Serial .print ("\rAccording to isupper:\r") ; Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" ); Serial.print ( "
uppercase letter\r" );
Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ; Serial.print ( " uppercase letter\r" );
Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" ); Serial.print ( " uppercase letter\r" );
Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ; Serial.print ("uppercase letter\r ");

}
void setup () {
}
Resultado

According to islower: p is a lowercase letter P is not a lowercase letter 5 is not a lowercase letter ! is not a lowercase
letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter
Ejemplo 3

El siguiente ejemplo demuestra el uso de las funciones isspace, iscntrl, ispunct, isprint e isgraph .

•La función isspace determina si su argumento es un carácter de espacio en blanco, como

espacio(''),avancedeformulario('\f'),nuevalínea('\n'),retornodecarro('\r'),pestaña horizontal ('\ t') o pestaña vertical ('\
v').

•La función iscntrl determina si su argumento es un carácter de control, como tabulación horizontal ('\ t'), tabulación
vertical ('\ v'), avance de formulario ('\ f'), alerta ('\ a'), retroceso ( '\ b'), retorno de carro ('\ r') o nueva línea ('\ n').

• La función ispunct determina si su argumento esun carácter de impresión que no sea un espacio, dígito o letra,
como $, #, (,), [,], {,},;,: o%.
• La función isprint determina si su argumento es un carácter que se puede mostrar en la pantalla (incluido el carácter
de espacio).
• La función isgraph prueba los mismos caracteres que isprint, pero el carácter de espacio no está incluido.

void setup () {
Serial.begin (9600);
Serial.print ( " According to isspace:\rNewline ") ; Serial.print (isspace( '\n' )? " is a" : " is not a" ); Serial.print ( "
whitespace character\rHorizontal tab") ; Serial.print (isspace( '\t' )? " is a" : " is not a" ); Serial.print ( " whitespace
character\n") ;
Serial.print (isspace('%')? " % is a" : " % is not a" );

Serial .print ( " \rAccording to iscntrl:\rNewline") ; Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ; Serial.print ("
control character\r");
Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" ); Serial.print (" control character\r");
Serial.print ("\rAccording to ispunct:\r"); Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ; Serial.print (" punctuation
character\r"); Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ; Serial.print ("punctuation character\r"); Serial.print
(ispunct('#' ) ?"# is a" : "# is not a" ) ; Serial.print ("punctuation character\r");

Serial .print ( "\r According to isprint:\r"); Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" ); Serial.print (" printing
character\rAlert "); Serial.print (isprint('\a' ) ?" is a" : " is not a" ); Serial.print (" printing character\rSpace ");
Serial.print (isprint(' ' ) ?" is a" : " is not a" ); Serial.print (" printing character\r");

Serial .print ("\r According to isgraph:\r");

Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" ); Serial.print ("printing character other than a space\rSpace ");
Serial.print (isgraph (' ') ?" is a" : " is not a" );
Serial.print ("printing character other than a space ");

}
void loop () {
}
Resultado

According to isspace:
Newline is a whitespace character Horizontal tab is a whitespace character % is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

Biblioteca de Matemáticas
LabibliotecaArduinoMath (math.h)incluyevariasfuncionesmatemáticasútilespara manipular números de punto
flotante.

Macros de biblioteca
Las siguientes son las macros definidas en el encabezado math.h
A continuación se muestra la lista de macros definidas en el encabezado math.h

Funciones de biblioteca
Las siguientes funciones se definen en el encabezado math.h
A continuación se muestra la lista de funciones definidas en el encabezado math.h Ejemplo
El siguiente ejemplo muestra cómo usar las funciones más comunes de la biblioteca math.h:
double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
Serial.begin(9600);
Serial.print("cos num = ");
Serial.println (cos (double__x) ); // returns cosine of x
Serial.print("absolute value of num = ");
Serial.println (fabs (double__x) ); // absolute value of a float Serial.print("floating point modulo = ");
Serial.println (fmod (double__x, double__y)); // floating point modulo Serial.print("sine of num = ");
Serial.println (sin (double__x) ) ;// returns sine of x
Serial.print("square root of num : ");

Serial .println ( sqrt (double__x) );// returns square root of x

Serial.print("tangent of num : ");
Serial.println ( tan (double__x) ); // returns tangent of x
Serial.print("exponential value of num : ");
Serial.println ( exp (double__x) ); // function returns the exponential value of x. Serial.print("cos num : ");

Serial .println (atan (double__x) ); // arc tangent of x

Serial.print("tangent of num : ");
Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x Serial.print("arc tangent of num : ");
Serial.println (log (double__x) ) ; // natural logarithm of x Serial.print("cos num : ");
Serial.println ( log10 (double__x)); // logarithm of x to base 10. Serial.print("logarithm of num to base 10 : ");
Serial.println (pow (double__x, double__y) );// x to power of y Serial.print("power of num : ");
Serial.println (square (double__x)); // square of x

}
void loop() {
}
Resultado

cos num = 0.10

absolute value of num = 45.45 floating point modulo =15.25 sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf power of num : 2065.70

Funciones trigonométricas

Debe utilizar la trigonometría prácticamente como calcular la distancia para el objeto en movimiento o la velocidad
angular. Arduino proporciona funciones trigonométricas tradicionales (sin, cos, tan, asin, acos, atan) que pueden
resumirse escribiendo sus prototipos. Math.h contiene el prototipo de la función de trigonometría.
Sintaxis exacta trigonométrica

double sin(double x); //returns sine of x radians

double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x double asin(double x); //returns A, the
angle corresponding to sin (A) = x double atan(double x); //returns A, the angle corresponding to tan (A) = x
Ejemplo

double sine = sin(2); // approximately 0.90929737091

double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868

Due & Zero

ElArduinoDueesunaplacademicrocontroladorbasadaenlaCPUAtmelSAM3X8EARMCortexM3. Es la primera placa
Arduino basada en un microcontrolador de núcleo ARM de 32 bits. Características importantes
• Tiene 54 pines de entrada / salida digital (de los cuales 12 se pueden usar como salidas PWM)

• 12 entradas analógicas
• 4 UART (puertos seriales de hardware)
• Reloj de 84 MHz, una conexión compatible con USB OTG
• 2 DAC (digital a analógico), 2 TWI, un conector de alimentación, un encabezado SPI, un

encabezado JTAG
• Botón de reinicio y un botón de borrado
Características de la Junta Arduino Due

Voltaje operativo velocidad de la CPU

Entrada / IO / EEPROM SRAM Flash USB UART salida PWM [KB] [KB] [KB]
analógica digital

3,3
voltios 84 Mhz 12/2 54/12 - 96 512 2 4 4 micro
Comunicación

• 4 UART de hardware
• 2 I2C
• 1 interfaz CAN (protocolo de comunicación automotriz)
• 1 SPI
• 1 interfaz JTAG (10 pines)
• 1 host USB (como Leonardo)
• 1 puerto de programación

A diferencia de la mayoría de las placas Arduino, la placa ArduinoDue funciona a 3.3V. El voltaje máximo que los
pines de E / S pueden tolerar es 3.3V. La aplicación de voltajes superiores a 3,3 V a cualquier pin de E / S podría
dañar la placa.
La placa contiene todo lo necesario para soportar el microcontrolador. Simplemente puede conectarlo a una
computadora con un cable micro-USB o alimentarlo con un adaptador de CA a CC o una batería para comenzar. El
Due es compatible con todos los escudos Arduino que funcionan a 3.3V.

Arduino Zero

Zero es una extensión simple y potente de 32 bits de la plataforma establecida por la ONU. La placa Zero expande la
familia al proporcionar un mayor rendimiento, permitiendo una variedad de oportunidades de proyectos
paradispositivos,y actúa comouna gran herramienta educativa para aprender sobre el desarrollo de aplicaciones de
32 bits.

Las características importantes son:

• Las aplicaciones Zero abarcan desde dispositivos IoT inteligentes, tecnología portátil, automatización de alta
tecnología, hasta robótica loca.
• La placafunciona con laMCU SAMD21 de Atmel,que cuenta con un núcleo ARM Cortex® M0 + de 32 bits.

•Una de sus características más importantes es el depurador incorporado de Atmel (EDBG), que proporciona una
interfaz de depuración completa sin la necesidad de hardware adicional, lo que aumenta significativamente la
facilidad de uso para la depuración de software.

•EDBG también admite un puerto COM virtual que se puede usar para la programación del dispositivo y del
cargador de arranque.
Características de la placa Arduino Zero
Voltaje velocidad operativo de la CPU

Entrada / IO / EEPROM SRAM Flash USB UART salida PWM [KB] [KB] [KB]
analógica digital
3,3 voltios 48 Mhz 6/1 14/10 - 32 256 2 2 micro

A diferencia de la mayoría de las placas Arduino y Genuino, la Zero funciona a 3.3V. El voltaje máximo que los
pines de E / S pueden tolerar es 3.3V. La aplicación de voltajes superiores a 3,3 V a cualquier pin de E / S podría
dañar la placa.

La placa contiene todo lo necesario para soportar el microcontrolador. Simplemente puede conectarlo a una
computadora con un cable micro-USB o alimentarlo con un adaptador de CA a CC o una batería para comenzar. El
Zero es compatible con todos los escudos que funcionan a 3.3V.

Modulación de ancho de pulso

La modulación de anchode pulso o PWM esuna técnica común utilizada para variar el ancho de los pulsos en un tren
de pulsos. PWM tiene muchas aplicaciones, como el control de servos y controladores de velocidad, lo que limita la
potencia efectiva de motores y LED.

Principio Básico de PWM

La modulación de ancho de pulso es básicamente una onda cuadrada con un tiempo variable alto y bajo. Una señal
PWM básica se muestra en la siguiente figura.

Hay varios términos asociados con PWM:

• On-Time : la duración de la señal horaria es alta.
• Tiempo de apagado : la duración de la señal de tiempo es baja.

•Período : se representa como la suma del tiempo de encendido y apagado de la señal PWM.
•Ciclo de trabajo : se representa como el porcentaje de señal de tiempo que permanece encendida durante el período
de la señal PWM.

Período
Como se muestra en la figura, Tondenota el tiempo de encendido y Toffdenota el tiempo de apagado de la señal. El
período es la suma de los tiempos de encendido y apagado y se calcula como se muestra en la siguiente ecuación:

$$ T_ {total} = T_ {on} + T_ {off} $$

Ciclo de trabajo

El ciclo de trabajo se calcula como la puntualidad del período de tiempo. Usando el período calculado
anteriormente, el ciclo de trabajo se calcula como:

$$ D = \ frac {T_ {on}} {T_ {on} + T_ {off}} = \ frac {T_ {on}} {T_ {total}} $$
Función analogWrite ()

La función analogWrite () escribe un valor analógico (onda PWM) en un pin. Se puede usar para encender un LED
con brillo variable o conducir un motor a varias velocidades. Después de una llamada de la función analogWrite (),
el pin generará una onda cuadrada constante del ciclo de trabajo especificado hasta la próxima llamada a
analogWrite () o una llamada a digitalRead () o digitalWrite () en el mismo pin. La frecuencia de la señal PWM en
la mayoría de los pines es de aproximadamente 490 Hz. En las tarjetas 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 funcionan a 980 Hz.

En la mayoría de las placas Arduino (aquellas con ATmega168 o ATmega328), esta función funciona en los pines 3,
5, 6, 9, 10 y 11. En el Arduino Mega, funciona en los pines 2 - 13 y 44 46. Arduino más antiguo Las placas con
ATmega8 solo admiten analogWrite () en los pines 9, 10 y 11.
El Arduino Due admite analogWrite () en los pines 2 a 13, y 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.

NonecesitallamarapinMode()paraestablecerelpincomosalidaantesdellamaraanalogWrite ().

Sintaxis de la función analogWrite ()

analogWrite ( pin , value ) ;
valor - el ciclo de trabajo: entre 0 (siempre apagado) y 255 (siempre encendido). Ejemplo

int ledPin = 9; // LED connected to digital pin 9

int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

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

void loop() {
val = analogRead(analogPin); // read the input pin
analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023,

// analogWrite values from 0 to 255

}
Números aleatorios
Para generar números aleatorios, puede usar las funciones de números aleatorios de Arduino. Tenemos dos
funciones:

•randomSeed (semilla) • aleatorio()

randomSeed (semilla)

La función randomSeed (seed) restablece el generador de números pseudoaleatorios de Arduino. Aunque la

distribución de los números devueltos por random () es esencialmente aleatoria, la secuencia es predecible. Debe
restablecer el generador a algún valor aleatorio. Si tiene un pin analógico desconectado, podría captar ruido aleatorio
del entorno circundante. Estas pueden ser ondas de radio, rayos cósmicos, interferencia electromagnética de
teléfonos celulares, luces fluorescentes, etc.

Ejemplo
randomSeed(analogRead(5)); // randomize using noise from analog pin 5
random( )

La función aleatoria genera números pseudoaleatorios. La siguiente es la sintaxis. Sintaxis de sentencias random ()
long random(max) // it generate random numbers from 0 to max

long random(min, max) // it generate random numbers from min to max Ejemplo
long randNumber;

void setup() {
Serial.begin(9600);
// if analog input pin 0 is unconnected, random analog // noise will cause the call to randomSeed() to generate //
different seed numbers each time the sketch runs. // randomSeed() will then shuffle the random function.
randomSeed(analogRead(0));

void loop() {
// print a random number from 0 to 299
Serial.print("random1=");
randNumber = random(300);
Serial.println(randNumber); // print a random number from 0to 299
Serial.print("random2=");
randNumber = random(10, 20);// print a random number from 10 to 19
Serial.println (randNumber);
delay(50);

}
Actualicemos ahora nuestro conocimiento sobre algunos de los conceptos básicos, como bits y bytes.

Bits
Un bit es solo un dígito binario.
• El sistema binario usa dos dígitos, 0 y 1.

• Similar al sistema de números decimales, en el que los dígitos de un número no tienen el mismo valor,la
'importancia' de un bitdependede suposición enel número binario. Por ejemplo, los dígitos en el número decimal 666
son iguales, pero tienen valores diferentes.

Bytes

Un byte consta de ocho bits.

• Si un bit es un dígito, es lógico que los bytes representen números.
• Todas las operaciones matemáticas se pueden realizar sobre ellos.
• Los dígitos en un byte tampoco tienen el mismo significado.
• El bit más a la izquierda tiene el mayor valor llamado el bit más significativo (MSB).

• El bit más a la derecha tiene el menor valor y, por lo tanto, se llama el bit menos significativo (LSB).

•Dado que ocho ceros y unos de un byte se pueden combinar de 256 maneras diferentes, el número decimal más
grande que se puede representar por un byte es 255 (una combinación representa un cero).
Interrupciones
Las interrupciones detienen el trabajo actual de Arduino, de modo que se puede hacer otro trabajo.

Supongaqueestásentadoencasa,conversandoconalguien. Derepentesuenaelteléfono. Deja de chatear y levanta el

teléfono para hablar con la persona que llama. Cuando haya terminado su conversación telefónica, vuelva a
conversar con la persona antes de que suene el teléfono.

Del mismo modo, puede pensar en la rutina principal como chatear con alguien, el timbre del teléfono hace que deje
de chatear. La rutina de servicio de interrupción es el proceso de hablar por teléfono. Cuando finaliza la
conversación telefónica, vuelve a su rutina principal de chat. Este ejemplo explica exactamente cómo una
interrupción hace que un procesador actúe.

El programa principal se está ejecutando y realizando alguna función en un circuito. Sin embargo, cuando ocurre
una interrupción, el programa principal se detiene mientras se lleva a cabo otra rutina. Cuando finaliza esta rutina, el
procesador vuelve a la rutina principal nuevamente.

Características importantes

Estas son algunas características importantes sobre las interrupciones:

•Las interrupciones pueden provenir de varias fuentes. En este caso, estamos utilizando una interrupción de
hardware que se desencadena por un cambio de estado en uno de los pines digitales.
•La mayoría de los diseños de Arduino tienen dos interrupciones de hardware (denominadas "interrupt0" e
"interrupt1") conectadas a los pines de E / S digitales 2 y 3, respectivamente.

• El Arduino Mega tiene seis interrupciones de hardware, incluidas las interrupciones adicionales ("interrupt2" hasta
"interrupt5") en los pines 21, 20, 19 y 18. • Puede definir una rutina utilizando una función especial llamada "Rutina
de servicio de interrupción" (generalmente conocida como ISR).
• Puede definir la rutina y especificar condiciones en el borde ascendente, el borde descendente o ambos. En estas
condiciones específicas, la interrupción sería atendida. • Es posible tener esa función ejecutada automáticamente,
cada vez que ocurre un evento en un pin de entrada.
Tipos de interrupciones
Hay dos tipos de interrupciones:
• Interrupciones de hardware : se producen en respuesta a un evento externo, como un pin de interrupción externo
que sube o baja.

•Interrupciones de software : se producen en respuesta a una instrucción enviada en software. El único tipo de
interrupción que admite el "lenguaje Arduino" es la función attachInterrupt ().

Usando interrupciones en Arduino

Las interrupciones son muy útiles en los programas de Arduino, ya que ayudan a resolver problemasdetiempo.
Unabuenaaplicación deuna interrupciónesleeruncodificadorrotatorio u observar una entrada del usuario. En general,
un ISR debe ser lo más corto y rápido posible. Si su boceto usa múltiples ISR, solo uno puede ejecutarse a la vez.
Otras interrupciones se ejecutarán después de que finalice la actual en un orden que depende de la prioridad que
tengan.

Típicamente, las variables globales se usan para pasar datos entre un ISR y el programa principal. Para asegurarse de
que las variables compartidas entre un ISR y el programa principal se actualicen correctamente, declare que son
volátiles.

adjuntar sintaxis de declaración

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board attachInterrupt(pin, ISR,

mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs;

//this function must take no parameters and return nothing.

//This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

Las siguientes tres constantes están predefinidas como valores válidos:

• BAJO para activar la interrupción siempre que el pin esté bajo.
• CAMBIAR para activar la interrupción siempre que el pin cambie de valor. • CAÍDA cada vez que el pasador va de
mayor a menor.

Ejemplo

int pin = 2; //define interrupt pin to 2

volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
pinMode(13, OUTPUT); //set pin 13 as output
attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE); //interrupt at pin 2 blink ISR when pin to change the
value

}
void loop() {
digitalWrite(13, state); //pin 13 equal the state value }

void blink() {
//ISR function
state = !state; //toggle the state when the interrupt occurs

}
Comunicación

Se han definido cientos de protocolos de comunicación para lograr este intercambio de datos. Cada protocolo se
puede clasificar en una de las dos categorías: paralelas o en serie. Comunicación paralela

La conexión en paraleloentre el Arduino y los periféricos através de puertos de entrada / salida es la solución ideal
para distancias más cortas de hasta varios metros. Sin embargo, en otros casos cuando es necesario establecer
comunicación entre dos dispositivos para distancias más largas, no es posible utilizar una conexión en paralelo. Las
interfaces paralelas transfieren múltiples bits al mismo tiempo. Por lo general, requieren buses de datos, que se
transmiten a través de ocho, dieciséiso más cables. Los datos se transfieren enondas enormes yestrepitosas de 1 y 0.

Ventajas y desventajas de la
comunicación paralela

La comunicación paralela ciertamente tiene sus ventajas. Es más rápido que el serial, directo y relativamente fácil de
implementar. Sin embargo, requiere muchos puertos y líneas de entrada / salida (E / S). Si alguna vez ha tenido que
mover un proyecto de un Arduino Uno básico a un Mega, sabe que las líneas de E / S en un microprocesador pueden
ser preciosas y pocas. Por lo tanto, preferimos la comunicación en serie, sacrificando la velocidad potencial para el
pin real estate.

Módulos de comunicación en serie

Hoy, la mayoría de las placas Arduino están construidas con varios sistemas diferentes para la comunicación en
serie como equipo estándar.

El uso de estos sistemas depende de los siguientes factores:

• ¿Con cuántos dispositivos tiene que intercambiar datos el microcontrolador? • ¿Qué tan rápido debe ser el
intercambio de datos?
• ¿Cuál es la distancia entre estos dispositivos?
• ¿Es necesario enviar y recibir datos simultáneamente?

Una de las cosas más importantes con respecto a la comunicación en serie es el Protocolo , que debe observarse
estrictamente. Es un conjunto de reglas, que deben aplicarse de manera que los dispositivos puedan interpretar
correctamente los datos que intercambian mutuamente. Afortunadamente, Arduinoseencarga automáticamentede
esto, demodo que el trabajo del programador / usuario se reduce a una simple escritura (datos a enviar) y lectura
(datos recibidos).

Tipos de comunicaciones en serie

La comunicación en serie se puede clasificar además como:
• Sincrónico : los dispositivos que están sincronizados usan el mismo reloj y su sincronización está sincronizada
entre sí.
• Asíncrono : losdispositivosqueson asíncronostienensuspropiosrelojesyseactivan por la salida del estado anterior.
Esfácilaveriguarsiundispositivoessíncronoono. Sisedaelmismorelojatodoslosdispositivos conectados, entonces son
síncronos. Si no hay línea de reloj, es asíncrona.
Por ejemplo, el módulo UART (Transmisor receptor asíncrono universal) es asíncrono.

El protocolo serie asíncrono tiene una serie de reglas integradas. Estas reglas no son más que mecanismos que
ayudan a garantizar transferencias de datos robustas y sin errores. Estos mecanismos, que obtenemos para evitar la
señal del reloj externo, son:

• Bits de sincronización • Bits de datos

• Bits de paridad
• Velocidad de transmisión

Bits de sincronización

io
Los bits de sincronización son dos o tres bits especiales transferidos con cada paquete de datos. Son el bit de inicio y

ti.
el bit de parada. Fieles a su nombre, estos bits marcan el comienzo y el final de un paquete respectivamente.
Siempre hay un solo bit de inicio, pero el número de bits de parada se puede configurar en uno o dos (aunque
normalmente se deja en uno).

en
El bit de inicio siempre se indica mediante una línea de datos inactiva que va de 1 a 0, mientras que los bits de
parada volverán a la transición al estado inactivo manteniendo la línea en 1.
id
76
Bits de datos

La cantidad de datos en cada paquete se puede establecer en cualquier tamaño de 5 a 9 bits. Ciertamente, el tamaño
19

de datos estándar es su byte básico de 8 bits, pero otros tamaños tienen sus usos. Un paquete de datos de 7 bits puede
ser más eficiente que 8, especialmente si solo está transfiriendo caracteres ASCII de 7 bits.

Bits de paridad
ko

El usuario puede seleccionar si debe haber un bit de paridad o no, y en caso afirmativo, si la paridad debe ser par o
impar. El bit de paridad es 0 si el número de 1 entre los bits de datos es par. Paridad impar es todo lo contrario.
Ya

Velocidad de transmisión

El término velocidad en baudios se utiliza para denotar el número de bits transferidos por segundo [bps]. Tenga en
by

cuenta que se refiere a bits, no a bytes. Por lo general, el protocolo requiere que cada byte se transfiera junto con
varios bits de control. Significa que un byte en el flujo de datos en serie puede consistir en 11 bits. Por ejemplo, si la
velocidad en baudios es de 300 bps, se pueden transferir un máximo de 37 y un mínimo de 27 bytes por segundo.

Arduino UART
El siguiente código hará que Arduino envíe hola mundo cuando se inicie.

void setup() {
Serial.begin(9600); //set up serial library baud rate to 9600
Serial.println("hello world"); //print hello world

}
void loop() {
}

Después de que el boceto de Arduino se haya cargado en Arduino, abra el monitor de serie
en la sección superior derecha del IDE de Arduino.
Escriba cualquiercosa en el cuadrosuperiordel Monitorserie y presione enviar o ingresaren su teclado. Esto enviará
una serie de bytes al Arduino.

El siguiente código devuelve lo que recibe como entrada.

El siguiente código hará que Arduino entregue la salida dependiendo de la entrada proporcionada.
void setup() {
Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
if(Serial.available()) //if number of bytes (characters) available for reading from { serial port
Serial.print("I received:"); //print I received
Serial.write(Serial.read()); //send what you read

}
}
Tenga en cuenta que Serial.print y Serial.println devolverán el código ASCII real, mientras que Serial.write
devolverá el texto real. Vea los códigos ASCII para más información. Circuito Inter Integrado

El circuito inter-integrado (I2C) es un sistema para el intercambio de datos en serie entre los microcontroladores y
loscircuitos integrados especializadosde unanueva generación. Seutiliza cuando la distancia entre ellos es corta (el
receptor y el transmisor suelen estar en la misma placa impresa). La conexión se establece a través de dos
conductores. Uno se usa para la transferencia de datos y el otro se usa para la sincronización (señal de reloj).

Como se ve en la siguiente figura, un dispositivo siempre es un maestro. Realiza el direccionamiento de un chip

esclavo antes de que comience la comunicación. De esta manera, un microcontrolador puede comunicarse con 112
dispositivos diferentes. La velocidad de transmisión suele ser de 100 Kb / s (modo estándar) o 10 Kb / s (modo de
velocidad de transmisión lenta). Recientemente aparecieron sistemas con una velocidad en baudios de 3.4 Mb / seg.
La distancia entre dispositivos, que se comunican a través de un bus I2C, está limitada a varios metros.

Tablero I2C Pins

El bus I2C consta de dos señales: SCL y SDA. SCL es la señal del reloj y SDA esla señal de datos. El maestro de
bus actual siempre genera la señal del reloj. Algunos dispositivos esclavos pueden forzar el reloj bajo a veces para
retrasar que el maestro envíe más datos (o para requerir más tiempo para preparar los datos antes de que el maestro
intente desconectarlo). Esto se conoce como "estiramiento del reloj".

Los siguientes son los pines para diferentes placas Arduino:

• Uno, Pro Mini A4 (SDA), A5 (SCL) • Mega, debido 20 (SDA), 21 (SCL) • Leonardo, Yun 2 (SDA), 3 (SCL)
Arduino I2C
Tenemosdosmodos,códigomaestroycódigoesclavo,paraconectardosplacasArduinousando I2C. Ellos son
• Transmisor maestro / receptor esclavo • Receptor maestro / transmisor esclavo

Transmisor maestro / receptor esclavo Veamos ahora qué es el transmisor maestro y el receptor esclavo.
Transmisor maestro

Las siguientes funciones se utilizan para inicializar la biblioteca Wire y unirse al bus I2C como maestro o esclavo.
Esto normalmente se llama solo una vez.
• Wire.begin (dirección) : la dirección es la dirección esclava de 7 bits en nuestro caso, ya que el maestro no está
especificado y se unirá al bus como maestro.
• Wire.beginTransmission (dirección) : comience una transmisión al dispositivo esclavo I2C con la dirección
indicada.
• Wire.write (valor) : pone en cola los bytes para la transmisión de un dispositivo maestro a esclavo (llamadas
intermedias a beginTransmission () y endTransmission ()).

•Wire.endTransmission () : finaliza una transmisión a un dispositivo esclavo que comenzó con beginTransmission ()
y transmite los bytes que se pusieron en cola mediante wire.write ().

Ejemplo
#include <Wire.h> //include wire library
void setup() //this will run only once { Wire.begin(); // join i2c bus as master
}
short age = 0;

void loop() {
Wire.beginTransmission(2);
// transmit to device #2
Wire.write("age is = ");
Wire.write(age); // sends one byte
Wire.endTransmission(); // stop transmitting
delay(1000);

}
Receptor esclavo

Se utilizan las siguientes funciones:

• Wire.begin (dirección) : la dirección es la dirección esclava de 7 bits.

• Wire.onReceive (controlador de datos recibidos) : función que se llamará cuando un dispositivo esclavo recibe
datos del maestro.
• Wire.available () : devuelve el número de bytes disponibles para recuperar con Wire.read (). Esto debería llamarse
dentro del controlador Wire.onReceive (). Ejemplo
#include <Wire.h> //include wire library

void setup() { //this will run only once

Wire.begin(2); // join i2c bus with address #2
Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing Serial.begin(9600); // start serial
for output to print what we receive

void loop() { delay(250);

}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) {

while (Wire.available()>1) // loop through all but the last { char c = Wire.read(); // receive byte as a character
Serial.print(c); // print the character

}
}

Receptor maestro / transmisor esclavo

Veamos ahora qué es el receptor maestro y el transmisor esclavo.
Master Receiver

El maestro, está programado para solicitar, y luego lee bytes de datos que se envían desde el esclavo Arduino con
dirección única.
Se utiliza la siguiente función:

Wire.requestFrom (dirección, número de bytes) : utilizado por el maestro para solicitar bytes de un dispositivo
esclavo. Los bytes se pueden recuperar con las funciones wire.available () y wire.read ().

Ejemplo

#include <Wire.h> //include wire library void setup() {

Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600); // start serial for output

void loop() {
Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
while (Wire.available()) // slave may send less than requested {

char c = Wire.read(); // receive a byte as character

Serial .print(c); // print the character

}
delay(500);

}
Transmisor esclavo
Se utiliza la siguiente función.
Wire.onRequest(controlador) :sellamaaunafuncióncuandounmaestrosolicitadatosdeeste dispositivo esclavo.
Ejemplo
#include <Wire.h>

void setup() {
Wire.begin(2); // join i2c bus with address #2
Wire.onRequest(requestEvent); // register event

}
Byte x = 0;

void loop() { delay(100);

}

// function that executes whenever data is requested by master // this function is registered as an event, see setup()

void requestEvent() {
Wire.write(x); // respond with message of 1 bytes as expected by master x++;

}
Interfaz periférica en serie

Un bus de interfaz periférica en serie (SPI) es un sistema de comunicación en serie, que utiliza hasta cuatro
conductores, comúnmente tres. Un conductor se usa para recibir datos, uno para enviar datos, uno para
sincronización y otro alternativamente para seleccionar un dispositivo para comunicarse. Es una conexión dúplex
completa, lo que significa que los datos se envían y reciben simultáneamente. La velocidad de transmisión máxima
es mayor que la del sistema de comunicación I2C.

Tablero SPI Pins

SPI utiliza los siguientes cuatro cables:
• SCK : este es el reloj serie controlado por el maestro.
• MOSI : esta es la salida maestra / entrada esclava controlada por el maestro. • MISO : esta es la entrada maestra /
salida esclava controlada por el maestro. • SS : este es el cable de selección de esclavos.
Se utilizan las siguientes funciones. Tienes que incluir el SPI.h.

•SPI.begin () : inicializa el bus SPI configurando SCK, MOSI y SS en las salidas, colocando SCK y MOSI bajo y
SS alto.

•SPI.setClockDivider (divisor) : para configurar el divisor de reloj SPI en relación con el reloj del sistema. En las
placas basadas en AVR, los divisores disponibles son 2, 4, 8, 16, 32, 64 o 128. La configuración predeterminada es
SPI_CLOCK_DIV4, que establece el reloj SPI en un cuarto de la frecuencia del reloj del sistema (5 Mhz para el
placas a 20 MHz).

•Divisor : puede ser (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16,

SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128). • SPI.transfer (val) : la transferencia SPI se
basa en un envío y recepción simultáneos: los datos recibidos se devuelven en recibidoVal.

•SPI.beginTransaction (SPISettings (speedMaximum, dataOrder, dataMode)) speedMaximum es el reloj, dataOrder

(MSBFIRST o LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 o SPI_MODE3).

Tenemos cuatro modos de operación en SPI de la siguiente manera:

• Modo 0 (predeterminado) : el reloj normalmente está bajo (CPOL = 0) y los datos se muestrean en la transición de
bajo a alto (borde delantero) (CPHA = 0). • Modo1
:elrelojnormalmenteesbajo(CPOL=0)ylosdatossemuestreanenlatransición de alto a bajo (borde posterior) (CPHA =
1).
• Modo2 :elrelojnormalmenteesalto(CPOL=1)ylosdatossemuestreanenlatransición de alto a bajo (borde de ataque)
(CPHA = 0).
• Modo3 :elrelojnormalmenteesalto(CPOL=1)ylosdatossemuestreanenlatransición de bajo a alto (borde posterior)
(CPHA = 1).
• SPI.attachInterrupt (controlador) : función que se llamará cuando un dispositivo esclavo recibe datos del maestro.
Ahora,conectaremosdosplacasArduinoUNOjuntas; unocomomaestroyelotrocomoesclavo.

• (SS): pin 10
• (MOSI): pin 11
• (MISO): pin 12
• (SCK): pin 13

El terreno es común. A continuación se muestra la representación esquemática de la conexión entre ambas placas:
Veamos ejemplos de SPI como maestro y SPI como esclavo. SPI como MAESTRO
Ejemplo

#include <SPI.h>

void setup (void) {

Serial.begin(115200); //set baud rate to 115200 for usart digitalWrite(SS, HIGH); // disable Slave Select
SPI.begin ();
SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8

void loop (void) {

char c;
digitalWrite(SS, LOW); // enable Slave Select // send test string
for (const char * p = "Hello, world!\r" ; c = *p; p++) {

SPI .transfer (c);

Serial.print(c);
}
digitalWrite(SS, HIGH); // disable Slave Select delay(2000);
}
SPI como ESCLAVO

Ejemplo

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {

Serial.begin (115200);
pinMode(MISO, OUTPUT); // have to send on master in so it set as output SPCR |= _BV(SPE); // turn on SPI in
slave mode
indx = 0; // buffer empty
process = false;
SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine {
byte c = SPDR; // read byte from SPI Data Register

if (indx < sizeof buff) {

buff [indx++] = c; // save data in the next index in the array buff if (c == '\r') //check for the end of the word
process = true;

}
}

void loop (void) {

if (process) {
process = false; //reset the process
Serial.println (buff); //print the array on serial monitor indx= 0; //reset button to zero

}
}
LED parpadeante

Los LED son luces pequeñas y potentes que se utilizan en muchas aplicaciones diferentes. Para comenzar,
trabajaremos para parpadear un LED, el Hello World de los microcontroladores. Es tan simple como encender y
apagar una luz. Establecer esta línea de base importante le dará una base sólida a medida que trabajemos hacia
experimentos que sean más complejos.

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas
• 1 × Arduino Uno R3
• 1 × LED
• 1 × resistencia de 330Ω
• 2 × puente

Procedimiento

Sigael diagramadelcircuito yconecte loscomponentesenlaplacadepruebascomo semuestra en la imagen a

continuación.
Nota : para averiguar la polaridad de un LED, mírelo detenidamente. La más corta de las dos patas, hacia el borde
plano de la bombilla, indica el terminal negativo.

Los componentes como las resistencias deben tener sus terminales dobladas en ángulos de 90 ° para que se ajusten
adecuadamente a los enchufes de la placa de pruebas. También puede cortar los terminales más cortos.
Bosquejo

Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
el nuevo archivo de boceto haciendo clic en Nuevo.
Código Arduino

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.

*/
// the setup function runs once when you press reset or power the board

void setup() { // initialize digital pin 13 as an output.

pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second

}
Código a tener en cuenta

pinMode(2,OUTPUT) : antesdepoderusar unodelospinesdeArduino,debe decirleaArduino Uno R3 si es una

ENTRADA o SALIDA. Utilizamos una "función" incorporada llamada pinMode () para hacer esto.

digitalWrite (2, HIGH) : cuando usa un pin como SALIDA, puede ordenar que sea HIGH (salida de 5 voltios) o
LOW (salida de 0 voltios).
Resultado
Debería ver que su LED se enciende y apaga. Si no se ve la salida requerida, asegúrese de haber ensamblado el
circuito correctamente, y verificado y cargado el código en su placa. LED de desvanecimiento

Este ejemplo demuestra el uso de la función analogWrite () para apagar un LED. AnalogWrite utiliza la modulación
de ancho de pulso (PWM), activando y desactivando un pin digital muy rápidamente con diferentes relaciones entre
encendido y apagado, para crear un efecto de desvanecimiento.

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas • 1 × Arduino Uno R3 • 1 × LED

• 1 × resistencia de 330Ω • 2 × puente

Procedimiento

Sigael diagramadelcircuito yconecte loscomponentesenlaplacadepruebascomo semuestra en la imagen a

continuación.
Nota : para averiguar la polaridad de un LED, mírelo detenidamente. La más corta de las dos patas, hacia el borde
plano de la bombilla, indica el terminal negativo.

Los componentes como las resistencias deben tener sus terminales dobladas en ángulos de 90 ° para que se ajusten
adecuadamente a los enchufes de la placa de pruebas. También puede cortar los terminales más cortos.
Bosquejo

Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
el nuevo archivo de boceto haciendo clic en Nuevo.
Código Arduino

/*
Fade
This example shows how to fade an LED on pin 9 using the analogWrite() function.

The analogWrite() function uses PWM, so if you want to change the pin you're using, be sure to use another PWM
capable pin. On most Arduino, the PWM pins are identified with a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.

*/

int led = 9; // the PWM pin the LED is attached to

int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by // the setup routine runs once when you press reset:

void setup() {
// declare pin 9 to be an output: pinMode(led, OUTPUT);

}
// the loop routine runs over and over again forever:

void loop() {
// set the brightness of pin 9:
analogWrite(led, brightness);
// change the brightness for next time through the loop:
brightness = brightness + fadeAmount;
// reverse the direction of the fading at the ends of the fade:
if (brightness == 0 || brightness == 255) {

fadeAmount = fadeAmount ;
}
// wait for 30 milliseconds to see the dimming effect
delay(300);

}
Código a tener en cuenta

Después de declarar el pin 9 como su pin LED, no hay nada que hacer en la función de configuración () de su
código. La función analogWrite () que usará en el bucle principal de su código requiere dos argumentos: uno, que le
dice a la función en qué pin escribir y el otro que indica qué valor PWM escribir.

Para apagar y encender el LED, aumente gradualmente los valores de PWM de 0 (completamente apagado) a 255
(completamente encendido), y luego nuevamente a 0, para completarelciclo.
Enelbocetoanterior,elvalorPWMseestableceusandounavariablellamada brillo. Cada vez a través del ciclo, aumenta
en el valor de la variable fadeAmount .

Si el brillo está en cualquier extremo de su valor (0 o 255), entonces fadeAmount se cambia a negativo. En otras
palabras, si fadeAmount es 5, entonces se establece en -5. Si es -5, entonces se establece en 5. La próxima vez a
través del bucle, este cambio hace que el brillo cambie también de dirección.

analogWrite() puedecambiar elvalorPWMmuyrápido, por lo que elretraso alfinaldelboceto controla la velocidad del
desvanecimiento. Intente cambiar el valor del retraso y vea cómo cambia el efecto de desvanecimiento.

Resultado
Debería ver que el brillo de su LED cambia gradualmente. Lectura de voltaje analógico

Este ejemplo le mostrará cómo leer una entrada analógica en el pin analógico 0. La entrada se convierte de
analogRead () a voltaje, y se imprime en el monitor en serie del software Arduino (IDE).

Componentes requeridos
Necesitará los siguientes componentes:
• 1 × placa de pruebas
• 1 × Arduino Uno R3
• 1 × 5K resistencia variable (potenciómetro)
• 2 × puente

Procedimiento
Sigael diagramadelcircuito yconecte loscomponentesenlaplacadepruebascomo semuestra en la imagen a
continuación.

Potenciómetro

Un potenciómetro (o olla) es un transductor electromecánico simple. Convierte el movimiento rotativo o lineal del
operador de entrada en un cambio de resistencia. Este cambio se usa (o puede usarse) para controlar cualquier cosa,
desde el volumen de un sistema de alta fidelidad hasta la dirección de un gran barco de contenedores.

La olla como la conocemos originalmente se conocía como un reóstato (esencialmente una resistencia bobinada
variable). La variedad de macetas disponibles ahora es bastante sorprendente, y puede ser muy difícil para el
principiante (en particular) determinar qué tipo es adecuado para una tarea determinada. Algunos tipos de macetas
diferentes, que se pueden usar para la misma tarea, dificultan el trabajo.
La imagen de la izquierda muestra el símbolo esquemático estándar de una olla. La imagen de la derecha es el
potenciómetro.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.
 io
ti.
en
id
76
19
ko
Ya
by

Código Arduino

/*
ReadAnalogVoltage
Reads an analog input on pin 0, converts it to voltage,
and prints the result to the serial monitor.
Graphical representation is available using serial plotter (Tools > Serial Plotter menu) Attach the center pin of a
potentiometer to pin A0, and the outside pins to +5V and ground.

*/
// the setup routine runs once when you press reset:

void setup() {
// initialize serial communication at 9600 bits per second: Serial.begin(9600);

}
// the loop routine runs over and over again forever:

void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);
// Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V): float voltage = sensorValue * (5.0 /
1023.0);
// print out the value you read:
Serial.println(voltage);

}
Código a tener en cuenta

En el programa o boceto que se proporciona a continuación, lo primero que debe hacer en la función de
configuración es comenzar las comunicaciones en serie, a 9600 bits por segundo, entre su placa y su computadora
con la línea:

Serial.begin(9600);

En el bucle principal de su código, debe establecer una variable para almacenar el valor de resistencia (que estará
entre 0 y 1023, perfecto para un tipo de datos int) proveniente de su potenciómetro:

int sensorValue = analogRead(A0);

Para cambiar los valores de 0-1023 a un rango que corresponde al voltaje, el pin está leyendo,
debecrearotravariable,unflotadoryhacerunpequeño cálculo. Paraescalarlosnúmerosentre 0.0 y 5.0, divida 5.0 por
1023.0 y multiplíquelo por sensorValue

float voltage= sensorValue * (5.0 / 1023.0);

Finalmente, necesita imprimir esta información en su ventana serial. Puede hacer esto con el comando Serial.println
() en su última línea de código:

Serial.println(voltage)
Ahora, abra Serial Monitor en el IDE de Arduino haciendo clic en el icono en el lado derecho de la barra verde
superior o presionando Ctrl + Shift + M.
 Resultado
Verá un flujo constante de números que van desde 0.0 a 5.0. A medida que gira el potenciómetro, los valores
cambiarán, correspondiente al voltaje en el pin A0.
Gráfico de barras LED

Este ejemplo muestra cómo leer una entrada analógica en el pin analógico 0, convertir los valores de analogRead ()
en voltaje e imprimirlos en el monitor en serie del software Arduino (IDE).

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas
• 1 × Arduino Uno R3
• 1 × 5k ohm resistencia variable (potenciómetro)
• 2 × puente
• 8 × LED o puede usar (pantalla de gráfico de barras LED como se muestra en la imagen a

continuación)
Procedimiento
Sigael diagramadelcircuito yconecte loscomponentesenlaplacadepruebascomo semuestra en la imagen a
continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo. Gráfico de barras LED de 10 segmentos

Estos LED de gráfico de barras de 10 segmentos tienen muchos usos. Con una huella compacta,
conexiónsimple,sonfácilesparaprototiposoproductosterminados. Esencialmente,son10LED azules individuales
alojados juntos, cada uno con una conexión de ánodo y cátodo individual.

También están disponibles en colores amarillo, rojo y verde.

Nota : el pin out en estos gráficos de barras puede variar de lo que aparece en la hoja de datos. Al girar el dispositivo
180 grados, se corregirá el cambio, haciendo que el pin 11 sea el primer pin en línea.

Código Arduino

/*
LED bar graph
Turns on a series of LEDs based on the value of an analog sensor.
This is a simple way to make a bar graph display.
Though this graph uses 8LEDs, you can use any number by
changing the LED count and the pins in the array.
This method can be used to control any series of digital
outputs that depends on an analog input.
*/

// these constants won't change:

const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
// loop over the pin array and set them all to output:
for (int thisLed = 0; thisLed < ledCount; thisLed++) {

pinMode(ledPins[thisLed], OUTPUT);
}
}

void loop() {
// read the potentiometer:
int sensorReading = analogRead(analogPin);
// map the result to a range from 0 to the number of LEDs:
int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
// loop over the LED array:
for (int thisLed = 0; thisLed < ledCount; thisLed++) {

// if the array element's index is less than ledLevel,

// turn the pin for this element on:
if (thisLed < ledLevel) {

digitalWrite (ledPins[thisLed], HIGH);

}else { // turn off all pins higher than the ledLevel:
digitalWrite(ledPins[thisLed], LOW);
}
}
}
Código a tener en cuenta

El boceto funciona así: primero, lees la entrada. Usted asigna el valor de entrada al rango de salida, en este caso,
diez LED. Luego configura un bucle for para iterar sobre las salidas. Si el número de salida en la serie es menor que
el rango de entrada asignado, lo enciende. Si no, lo apagas.

Resultado
Verá que el LED se ENCIENDE uno por uno cuando el valor de la lectura analógica aumenta y se APAGA uno por
uno mientras la lectura está disminuyendo.
Salida del teclado

Este ejemplo usa la biblioteca de Teclado para cerrar sesión de su sesión de usuario en su computadora cuando el
pin 2 del ARDUINO UNO se pone a tierra. El boceto simula la pulsación de teclas en secuencia de dos o tres teclas
al mismo tiempo y, después de un breve retraso, las libera.

Advertencia : cuando utiliza el comando Keyboard.print () , Arduino se hace cargo del teclado de su computadora.
Para asegurarse de no perder el control de su computadora mientras ejecuta un boceto con esta función, configure un
sistema de control confiable antes de llamar a Keyboard.print (). Este boceto está diseñado para enviar solo un
comando de teclado después de que un pin se haya tirado al suelo.

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas
• 1 × Arduino Leonardo, Micro, o placa de due • 1 × pulsador
• 1 × puente

Procedimiento
Siga el diagrama del circuito y conecte los componentes en el tablero como se muestra en la imagen a continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Para este ejemplo, debe usar Arduino IDE 1.6.7

Nota : debe incluir la biblioteca de teclado en su archivo de biblioteca Arduino. Copie y pegue el archivo de
biblioteca del teclado dentro del archivo con las bibliotecas de nombres (resaltadas) como se muestra en la siguiente
captura de pantalla.
Código Arduino

/*
Keyboard logout
This sketch demonstrates the Keyboard library. When you connect pin 2 to ground, it performs a logout. It uses
keyboard combinations to do this, as follows: On Windows, CTRL-ALT-DEL followed by ALT-l On Ubuntu,
CTRL-ALT-DEL, and ENTER
On OSX, CMD-SHIFT-q
To wake: Spacebar.
Circuit:
* Arduino Leonardo or Micro
* wire to connect D2 to ground.

*/

#define OSX 0
#define WINDOWS 1 #define UBUNTU 2

#include "Keyboard.h"
// change this to match your platform: int platform = WINDOWS;

void setup() {
// make pin 2 an input and turn on the // pullup resistor so it goes high unless // connected to ground:

pinMode(2, INPUT_PULLUP); Keyboard.begin();

}

void loop() {
while (digitalRead(2) == HIGH) { // do nothing until pin 2 goes low delay(500);

}
delay(1000);

switch (platform) {
case OSX:
Keyboard.press(KEY_LEFT_GUI);

// Shift-Q logs out:

Keyboard .press(KEY_LEFT_SHIFT); Keyboard.press('Q');

delay(100);

// enter:
Keyboard.write(KEY_RETURN); break;

case WINDOWS:
// CTRL-ALT-DEL:
Keyboard.press(KEY_LEFT_CTRL); Keyboard.press(KEY_LEFT_ALT); Keyboard.press(KEY_DELETE);
delay(100);
Keyboard.releaseAll();

//ALT-l:
delay(2000);
Keyboard.press(KEY_LEFT_ALT); Keyboard.press('l');
Keyboard.releaseAll();
break;

case UBUNTU:
// CTRL-ALT-DEL:
Keyboard.press(KEY_LEFT_CTRL); Keyboard.press(KEY_LEFT_ALT); Keyboard.press(KEY_DELETE);

delay(1000);
Keyboard.releaseAll();

// Enter to confirm logout: Keyboard.write(KEY_RETURN); break;

}
// do nothing: while (true); }
Keyboard.releaseAll();
// enter:

Keyboard .write(KEY_RETURN); break;

case WINDOWS:

// CTRL-ALT-DEL:
Keyboard.press(KEY_LEFT_CTRL); Keyboard.press(KEY_LEFT_ALT); Keyboard.press(KEY_DELETE);
delay(100);
Keyboard.releaseAll();

//ALT-l:
delay(2000);
Keyboard.press(KEY_LEFT_ALT); Keyboard.press('l');
Keyboard.releaseAll();
break;

case UBUNTU:
// CTRL-ALT-DEL:
Keyboard.press(KEY_LEFT_CTRL); Keyboard.press(KEY_LEFT_ALT); Keyboard.press(KEY_DELETE);
delay(1000);
Keyboard.releaseAll();

// Enter to confirm logout: Keyboard.write(KEY_RETURN); break;

// do nothing:
while (true);
}
Código a tener en cuenta

Antesdecargarel programa ensuplaca,asegúresede asignarelsistemaoperativo correctoque está utilizando actualmente

a la variable de plataforma.
Mientras se ejecuta el boceto, presionar el botón conectará el pin 2 al suelo y la placa enviará la secuencia de cierre
de sesión a la PC conectada por USB.
Resultado
Cuando conecta el pin 2 a tierra, realiza una operación de cierre de sesión.

Utiliza las siguientes combinaciones de teclado para cerrar sesión: • En Windows , CTRL-ALT-DEL seguido de
ALT-l
• En Ubuntu , CTRL-ALT-DEL y ENTER
• En OSX , CMD-SHIFT-q

Mensaje de teclado

En este ejemplo, cuando se presiona el botón, se envía una cadena de texto a la computadora como entrada de
teclado. La cadena informa el número de veces que se presiona el botón. Una vez que haya programado y conectado
el Leonardo, abra su editor de texto favorito para ver los resultados.

Advertencia :cuandoutilizael comando Keyboard.print() ,elArduinosehacecargodelteclado de su computadora. Para

asegurarse de no perder el control de su computadora mientras ejecuta un boceto con esta función, configure un
sistema de control confiable antes de llamar a Keyboard.print () . Estebocetoincluyeun botón para alternar el teclado,
de modo que solo se ejecute después de presionar el botón.

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas
• 1 × Arduino Leonardo, Micro, o placa de due • 1 × botón momentáneo
• Resistencia 1 × 10k ohm

Procedimiento
Sigael diagramadelcircuito yconecte loscomponentesenlaplacadepruebascomo semuestra en la imagen a
continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.
Código Arduino
/*
Keyboard Message test For the Arduino Leonardo and Micro,
Sends a text string when a button is pressed.
The circuit:
* pushbutton attached from pin 4 to +5V
* 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton int counter = 0; // button push counter

void setup() {
pinMode(buttonPin, INPUT); // make the pushButton pin an input: Keyboard.begin(); // initialize control over the
keyboard:

void loop() {
int buttonState = digitalRead(buttonPin); // read the pushbutton:
if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently

pressed: {
// increment the button counter
counter++;
// type out a message
Keyboard.print("You pressed the button ");
Keyboard.print(counter);
Keyboard.println(" times.");

}
// save the current button state for comparison next time:
previousButtonState = buttonState;

}
Código a tener en cuenta
Conecte una terminal del botón al pin 4 en Arduino. Conecte el otro pin a 5V. Use la resistencia como un pull-down,
proporcionando una referencia al suelo, uniéndola desde el pin 4 al suelo.

Una vez que haya programado su placa, desconecte el cable USB, abra un editor de texto y coloque el cursor de
texto en el área de escritura. Conecte la placa a su computadora a través de USB nuevamente y presione el botón
para escribir en el documento.

Resultado
Al usar cualquier editor de texto, mostrará el texto enviado a través de Arduino. Control del botón del mouse
Usando la biblioteca Mouse, puede controlar el cursor en pantalla de una computadora con un Arduino Leonardo,
Micro o Due.

Este ejemplo particular usa cinco botones para mover el cursor en pantalla. Cuatro de los botones son direccionales
(arriba, abajo, izquierda, derecha) y uno es para hacer clic con el botón izquierdo del mouse. El movimiento del
cursor desde Arduino es siempre relativo. Cada vez que se lee una entrada, la posición del cursorse actualiza en
relación con su posición actual.

Cadavezquesepresionaunodelosbotonesdireccionales,Arduinomoveráelmouse,asignando una entrada ALTA a un

rango de 5 en la dirección apropiada.
El quinto botón es para controlar el clic izquierdo del mouse. Cuando se suelta el botón, la computadora reconocerá
el evento.
Componentes requeridos
Necesitará los siguientes componentes:
• 1 × placa de pruebas
• 1 × Arduino Leonardo, Micro o Due board
• Resistencia de 5 × 10k ohmios
• 5 × botones momentáneos

Procedimiento
Siga el diagrama del circuito y conecte los componentes en el tablero como se muestra en la imagen a continuación.

Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo. Para este ejemplo, debe usar Arduino IDE 1.6.7
Código Arduino

/*
Button Mouse Control
For Leonardo and Due boards only .Controls the mouse from
five pushbuttons on an Arduino Leonardo, Micro or Due.
Hardware:
* 5 pushbuttons attached to D2, D3, D4, D5, D6
The mouse movement is always relative. This sketch reads
four pushbuttons, and uses them to set the movement of the mouse.
WARNING: When you use the Mouse.move() command, the Arduino takes over your mouse! Make sure you have
control before you use the mouse commands.

*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed int responseDelay = 10; // response
delay of the mouse, in ms

void setup() {
// initialize the buttons' inputs:
pinMode(upButton, INPUT);
pinMode(downButton, INPUT);
pinMode(leftButton, INPUT); pinMode(rightButton, INPUT); pinMode(mouseButton, INPUT); // initialize mouse
control: Mouse.begin();

void loop() {
// read the buttons:
int upState = digitalRead(upButton);
int downState = digitalRead(downButton);
int rightState = digitalRead(rightButton);
int leftState = digitalRead(leftButton);
int clickState = digitalRead(mouseButton);
// calculate the movement distance based on the button states: int xDistance = (leftState rightState) * range;
int yDistance = (upState downState) * range;
// if X or Y is non-zero, move:
if ((xDistance != 0) || (yDistance != 0)) {

Mouse.move(xDistance, yDistance, 0);

}

// if the mouse button is pressed:

if (clickState == HIGH) {
// if the mouse is not pressed, press it:
if (!Mouse.isPressed(MOUSE_LEFT)) {
Mouse.press(MOUSE_LEFT);
}
} else { // else the mouse button is not pressed:
// if the mouse is pressed, release it:
if (Mouse.isPressed(MOUSE_LEFT)) {
Mouse.release(MOUSE_LEFT);
}
}
// a delay so the mouse does not move too fast:
delay(responseDelay);
}
Código a tener en cuenta

Conecte suplaca a su computadora conun cablemicro-USB. Los botonesestán conectadosa las entradas digitales de
los pines 2 a 6. Asegúrese de utilizar resistencias desplegables de 10k.
Teclado serial

Este ejemplo escucha un byte proveniente del puerto serie. Cuando se recibe, el tablero envía unapulsacióndetecla
ala computadora. Lapulsaciónde tecla enviadaesmayorquelarecibida, por lo que si envía una "a" desde el monitor en
serie, recibirá una "b" desde la placa conectada a la computadora. Un "1" devolverá un "2" y así sucesivamente.

Advertencia : cuando utiliza el comando Keyboard.print () , la placa Leonardo, Micro o Due toma el control del
teclado de su computadora. Para asegurarse de no perder el control de su computadora mientras ejecuta un boceto
con esta función, configure un sistema de control confiable antes de llamar a Keyboard.print (). Este boceto está
diseñado para enviar solo un comando de teclado después de que la placa haya recibido un byte a través del puerto
serie.

Componentes requeridos
Necesitará los siguientes componentes:
• 1 × Arduino Leonardo, Micro, o placa de due
Procedimiento

Simplemente conecte su placa a la computadora con un cable USB.

Bosquejo

Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Notas : debe incluir la biblioteca del teclado en su archivo de biblioteca Arduino. Copie y pegue el archivo de
biblioteca del teclado dentro del archivo con el nombre 'bibliotecas' resaltado en color amarillo.
Código Arduino

/*
Keyboard test
For the Arduino Leonardo, Micro or Due Reads

a byte from the serial port, sends a keystroke back.

The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
A you get B, and so forth.
The circuit:
* none
*/

#include "Keyboard.h"

void setup() {
// open the serial port:
Serial.begin(9600);
// initialize control over the keyboard: Keyboard.begin();

void loop() {
// check for incoming serial data:
if (Serial.available() > 0) {

// read incoming serial data:

char inChar = Serial.read();
// Type the next ASCII value from what you received:
Keyboard.write(inChar + 1);

}
}
Código a tener en cuenta
Una vez programado, abra su monitor en serie y envíe un byte. El tablero responderá con una pulsación de tecla, que
es un número más alto.
Resultado
La placa responderá con una pulsación de tecla un número superior en el monitor serie Arduino IDE cuando envíe
un byte.
Sensor de humedad
En esta sección, aprenderemos cómo interactuar nuestra placa Arduino con diferentes sensores. Discutiremos los
siguientes sensores:

• Sensor de humedad (DHT22)

• Sensor de temperatura (LM35)
• Sensor detector de agua (Disparador simple de agua) • SENSOR PIR
• SENSOR ULTRASÓNICO • GPS

Sensor de humedad (DHT22)

El DHT-22 (también denominado AM2302) es un sensor de salida digital, humedad relativa y temperatura. Utiliza
un sensor de humedad capacitivo y un termistor para medir el aire circundante, y envía una señal digital en el pin de
datos.

En este ejemplo, aprenderá a usar este sensor con Arduino UNO. La temperatura ambiente y la humedad se
imprimirán en el monitor en serie.
El sensor DHT-22
Las conexiones son simples. El primer pin a la izquierda a 3-5V de potencia,el segundo pin al pin de entrada de
datos y el pin más a la derecha al suelo.

Detalles técnicos
• Poder - 3-5V
• Corriente Máxima - 2.5mA
• Humedad : 0-100%, precisión 2-5%
• Temperatura : 40 a 80 ° C, precisión de ± 0.5 ° C

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas • 1 × Arduino Uno R3 • 1 × DHT22

• Resistencia 1 × 10K ohm

Procedimiento
Siga el diagrama del circuito y conecte los componentes en el tablero como se muestra en la imagen a continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

io
ti.
en
id
76
19
ko
Ya
by

Código Arduino
// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1 // to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor // Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to // tweak the timings for faster
processors. This parameter is no longer needed // as the current DHT reading algorithm adjusts itself to work on
faster procs. DHT dht(DHTPIN, DHTTYPE);

void setup() {
Serial.begin(9600);
Serial.println("DHTxx test!"); dht.begin();

void loop() {
delay(2000); // Wait a few seconds between measurements float h = dht.readHumidity();
// Reading temperature or humidity takes about 250 milliseconds! float t = dht.readTemperature();
// Read temperature as Celsius (the default)
float f = dht.readTemperature(true);
// Read temperature as Fahrenheit (isFahrenheit = true) // Check if any reads failed and exit early (to try again). if
(isnan(h) || isnan(t) || isnan(f)) {

Serial.println("Failed to read from DHT sensor!");

return;
}

// Compute heat index in Fahrenheit (the default) float hif = dht.computeHeatIndex(f, h);
// Compute heat index in Celsius (isFahreheit = false) float hic = dht.computeHeatIndex(t, h, false);

Serial .print ("Humidity: ");

Serial.print (h);
Serial.print (" %\t");
Serial.print ("Temperature: ");
Serial.print (t);
Serial.print (" *C ");
Serial.print (f);
Serial.print (" *F\t");
Serial.print ("Heat index: ");
Serial.print (hic);
Serial.print (" *C ");
Serial.print (hif);
Serial.println (" *F");

}
Código a tener en cuenta
El sensor DHT22 tiene cuatro terminales (Vcc, DATA, NC, GND), que se conectan a la placa de la siguiente
manera:
• Pin de DATOS al pin número 2 de Arduino
• Vccpin a 5 voltios de placa Arduino
• GND pin al suelo de la placa Arduino

•Necesitamos conectar una resistencia de 10k ohmios (resistencia de extracción) entre los DATOS y el pin Vcc
Una vez que se realizan las conexiones de hardware, debe agregar la biblioteca DHT22 a su archivo de biblioteca
Arduino como se describió anteriormente.
Resultado
Verá lapantalla de temperatura yhumedad en elmonitor del puerto serieque se actualiza cada 2 segundos.
Sensor de temperatura

Los sensores de temperatura de la serie LM35 son dispositivos de temperatura de circuito integrado de precisión con
un voltaje de salida linealmente proporcional a la temperatura centígrada.

El dispositivo LM35 tiene una ventaja sobre los sensores lineales de temperatura calibrados en Kelvin, ya que no se
requiere que el usuario reste un voltaje constante grande de la salida para obteneruna escalaconveniente
engradoscentígrados. El dispositivoLM35 norequiere ninguna calibración o ajuste externo para proporcionar
precisiones típicas de ± ¼ ° C a temperatura ambiente y ± ¾ ° C en un rango completo de temperatura de −55 ° C a
150 ° C.

Especificaciones técnicas

• Calibrado directamente en Celsius (centígrado)

• Factor de escala lineal + 10-mV / ° C
• 0,5 ° C precisión garantizada (a 25 ° C)
• Clasificado para un rango completo de −55 ° C a 150 ° C
• Apto para aplicaciones remotas
Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas
• 1 × Arduino Uno R3
• 1 × sensor LM35

Procedimiento
Sigael diagramadelcircuito yconecte loscomponentesenlaplacadepruebascomo semuestra en la imagen a
continuación.
Bosquejo Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su
circuito. Abra un nuevo archivo de boceto haciendo clic en Nuevo.
Código Arduino
float temp;
int tempPin = 0;
void setup() {
Serial.begin(9600);
}

void loop() {
temp = analogRead(tempPin);
// read analog volt from sensor and save to variable temp
temp = temp * 0.48828125;
// convert the analog volt to its temperature equivalent
Serial.print("TEMPERATURE = ");
Serial.print(temp); // display temperature value
Serial.print("*C");
Serial.println();
delay(1000); // update sensor reading each one second

}
Código a tener en cuenta
El sensor LM35 tiene tres terminales: Vs, Vouty GND. Conectaremos el sensor de la siguiente manera:

• Conecte los + Vsa + 5v en su placa Arduino.

• Conecte lasalidaV a Analog0 o A0 en la placa Arduino.
• Conecte GND con GND en Arduino.

El convertidor analógico a digital (ADC) convierte los valores analógicos en una aproximación digitalbasada en la
fórmula Valor ADC =muestra* 1024 / voltajede referencia (+ 5v). Entonces, con una referencia de +5 voltios, la
aproximación digital será igual al voltaje de entrada * 205.

Resultado
Verá la pantalla de temperatura en el monitor del puerto serie que se actualiza cada segundo. Detector / sensor de
agua

El bloque sensor de agua está diseñado para la detección de agua, que puede usarse ampliamente para detectar
lluvia, nivel de agua e incluso fugas de líquido.
Conectarunsensordeagua aun Arduino es unaexcelentemaneradedetectar fugas,derrames, inundaciones, lluvia, etc.
Se puede utilizar para detectar la presencia, el nivel, el volumen y / o la ausencia de agua. Si bien esto podría usarse
para recordarle que riegue sus plantas, hay un mejor sensor Grove para eso. El sensor tiene una serie de trazas
expuestas, que leen BAJO cuando se detecta agua.

En estecapítulo,conectaremoselsensordeaguaal Pin8digitalen Arduino, yalistaremoselLED muy útil para ayudar a

identificar cuándo el sensor de agua entra en contacto con una fuente de agua.

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas
• 1 × Arduino Uno R3
• 1 × sensor de agua
• 1 × led
• 1 × resistencia de 330 ohmios

Procedimiento
Sigael diagramadelcircuito yconecte loscomponentesenlaplacadepruebascomo semuestra en la imagen a
continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Código Arduino
#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8 #define LED 9 // Attach an LED to
Digital Pin 9 (or use onboard LED)

void setup() {
pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input pinMode(LED, OUTPUT); // The LED is
an Output

void loop() {
/* The water sensor will switch LOW when water is detected.
Get the Arduino to illuminate the LED and activate the buzzer
when water is detected, and switch both off when no water is present */
if( digitalRead(Grove_Water_Sensor) == LOW) {

digitalWrite (LED,HIGH);
}else {
digitalWrite(LED,LOW);
}
}
Código a tener en cuenta

El sensor de agua tiene tres terminales: S, Vout(+) y GND (-). Conecte el sensor de la siguiente manera:

• Conecte los + Vsa + 5v en su placa Arduino.

• Conecte S al pin digital número 8 en la placa Arduino.
• Conecte GND con GND en Arduino.
• Conecte el LED al pin digital número 9 en la placa Arduino.

Cuando el sensor detecta agua, el pin 8 en Arduino se BAJA y luego el LED en Arduino se ENCIENDE.
Resultado
Verá que el LED indicador se enciende cuando el sensor detecta agua. Sensor PIR

Los sensores PIR le permiten sentir el movimiento. Se utilizan para detectar si un humano se ha movido dentro o
fuera del rango del sensor. Se encuentran comúnmente en electrodomésticos y aparatosque se usan en el hogar
oparanegocios. A menudo se les conoce como sensores PIR, "infrarrojo pasivo", "piroeléctrico" o "movimiento IR".

Las siguientes son las ventajas de los sensores PIR:

• Pequeño en tamaño • Amplio rango de lentes • Fácil de interactuar • Barato

• De baja potencia
• Fácil de usar
• No te desgastes
Los PIR están hechos de sensores piroeléctricos, una lata redonda de metal con un cristal rectangular en el centro,
que puede detectar niveles de radiación infrarroja. Todo emite radiación de bajo nivel, y cuanto más caliente es algo,
más radiación se emite. El sensor en un detector de movimiento se divide en dos mitades. Esto es para detectar
movimiento (cambio) y no niveles promedio de IR. Las dos mitades están conectadas para que se cancelen entre sí.
Si la mitad ve más o menos radiación IR que la otra, la salida oscilará alto o bajo.

Los PIRtienen configuraciones ajustables y tienen un encabezado instaladoen losterminalesde tierra / salida /
alimentación de 3 pines.
Para muchos proyectos o productos básicos que necesitan detectar cuándo una persona se ha ido o ingresado al área,
los sensores PIR son excelentes. Tenga en cuenta que los PIR no le indican la cantidad de personas alrededor o su
proximidad al sensor. La lente a menudo se fija a un cierto barrido a cierta distancia y, a veces, las mascotas de la
casa los detienen.

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa de pruebas
• 1 × Arduino Uno R3
• 1 × sensor PIR (MQ3)

Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Código Arduino
#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000; boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

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

}
void loop() { PIRSensor(); }
void PIRSensor() {
if(digitalRead(pirPin) == HIGH) {
if(lockLow) {

PIRValue = 1;
lockLow = false;
Serial.println("Motion detected.");
delay(50);

}
takeLowTime = true;
}
if(digitalRead(pirPin) == LOW) {
if(takeLowTime){
lowIn = millis();takeLowTime = false;
}
if(!lockLow && millis() lowIn > pause) {
PIRValue = 0;
lockLow = true;
Serial.println("Motion ended.");
delay(50);
}
}
}
Código a tener en cuenta

El sensor PIR tiene tres terminales: Vcc, OUT y GND. Conecte el sensor de la siguiente manera:

•Conecte el + Vcca + 5v en la placa Arduino. • Conecte OUT al pin digital 2 en la placa Arduino. • Conecte GND
con GND en Arduino.

Puede ajustar la sensibilidad del sensor y el tiempo de retraso a través de dos resistencias variables ubicadas en la
parte inferior de la placa del sensor.
Una vez que el sensor detecta cualquier movimiento, Arduino enviará un mensaje a través del puerto serie para decir
que se detecta un movimiento. El movimiento de detección PIR se retrasará durante cierto tiempo para verificar si
hay un nuevo movimiento. Si no se detecta movimiento, Arduino enviará un nuevo mensaje diciendo que el
movimiento ha finalizado.

Resultado
Verá un mensaje en su puerto serie si se detecta un movimiento y otro mensaje cuando el movimiento se detiene.
Sensor ultrasónico

El sensor ultrasónico HC-SR04 usa SONAR para determinar la distancia de un objeto tal como lo hacen los
murciélagos. Ofrece una excelente detección de rango sin contacto con alta precisión y lecturas estables en un
paquete fácil de usar de 2 cm a 400 cm o 1 "a 13 pies.

La operación no se ve afectada por la luz solar o el material negro, aunque acústicamente, los materiales blandos
comola telapueden serdifíciles de detectar. Se completa con un transmisor ultrasónico y un módulo receptor.
Especificaciones técnicas

• Fuente de alimentación - + 5V DC
• Corriente de reposo - <2mA
• Corriente de trabajo - 15mA
• Ángulo efectivo - <15 °
• Distancia de rango - 2 cm - 400 cm / 1 ″ - 13 pies • Resolución - 0.3 cm
• Ángulo de medición - 30 grados

Componentes requeridos
Necesitará los siguientes componentes:
• 1 × placa de pruebas
• 1 × Arduino Uno R3
• 1 × Sensor ULTRASÓNICO (HC-SR04) Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Código Arduino
const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor const int echoPin = 6; // Echo Pin of Ultrasonic Sensor
void setup() {
Serial.begin(9600); // Starting Serial Terminal }

void loop() {
long duration, inches, cm;
pinMode(pingPin, OUTPUT);
digitalWrite(pingPin, LOW);
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(10);
digitalWrite(pingPin, LOW);
pinMode(echoPin, INPUT);
duration = pulseIn(echoPin, HIGH);
inches = microsecondsToInches(duration); cm = microsecondsToCentimeters(duration); Serial.print(inches);

io
Serial.print("in, ");
Serial.print(cm);
Serial.print("cm");

ti.
Serial.println();
delay(100);

en
}

long microsecondsToInches(long microseconds) { return microseconds / 74 / 2;

}

long microsecondsToCentimeters(long microseconds) {

id
76
return microseconds / 29 / 2;
}
Código a tener en cuenta
19

El sensor ultrasónico tiene cuatro terminales: + 5V, Trigger, Echo y GND conectados de la siguiente manera:

•Conecte el pin + 5V a + 5v en su placa Arduino. • Conecte Trigger al pin digital 7 en su placa Arduino. • Conecte
ko

Echo al pin digital 6 en su placa Arduino. • Conecte GND con GND en Arduino.

En nuestro programa, hemos mostrado la distancia medida por el sensor en pulgadas y cm a través del puerto serie.
Resultado
Ya

Verá la distancia medida por el sensor en pulgadas y cm en el monitor serie Arduino. Interruptor de conexión
Los botones o interruptores conectan dos terminales abiertos en un circuito. Este ejemplo enciende el LED en el pin
2 cuando presiona el interruptor de botón conectado al pin 8.
by

Resistencia desplegable

Las resistencias desplegables se utilizan en circuitos lógicos electrónicos para garantizar que las
entradasaArduinoseasientenen losniveleslógicosesperadossilosdispositivosexternosestán desconectados o tienen alta
impedancia. Como nada está conectado a un pin de entrada, no significa que sea un cero lógico. Las resistencias de
extracción están conectadas entre la tierra y el pin apropiado del dispositivo.
Un ejemplo de una resistencia desplegable en un circuito digital se muestra en la siguiente figura. Un interruptor de
botón pulsador está conectado entre la tensión de alimentación y un pin del microcontrolador. En dicho circuito,
cuando el interruptor está cerrado, la entrada del microcontrolador está en un valor lógico alto, pero cuando el
interruptor está abierto, la resistencia pull-down tira la tensión de entrada hacia el suelo (valor cero lógico), evitando
Un estado indefinido en la entrada.

La resistencia pull-down debe teneruna resistencia mayor que la impedancia del circuito lógico, de lo contrario,
podría bajar demasiado el voltaje y el voltaje de entrada en el pin permanecería en un valor lógico bajo constante,
independientemente de la posición del interruptor. Componentes requeridos

Necesitará los siguientes componentes:

• 1 × placa Arduino UNO

• 1 × resistencia de 330 ohmios • Resistencia 1 × 4.7K ohm (pull down) • 1 × LED

Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Bosquejo Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su
circuito. Abra un nuevo archivo de boceto haciendo clic en Nuevo.
Código Arduino

// constants won't change. They're used here to

// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
// initialize the LED pin as an output: pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input: pinMode(buttonPin, INPUT);

void loop() {
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {

// turn LED on:

digitalWrite(ledPin, HIGH);

} else {
// turn LED off:
digitalWrite(ledPin, LOW);

}
}
Código a tener en cuenta

Cuando el interruptor está abierto (el botón no está presionado), no hay conexión entre los dos terminales del botón,
por lo que el pin está conectado a tierra (a través de la resistencia desplegable) y leemos un LOW. Cuando el
interruptor está cerrado (se presiona el botón), hace una conexión entre sus dos terminales, conectando el pin a 5
voltios, de modo que leemos un ALTO.

Resultado
El LED se ENCIENDE cuando se presiona el botón y se APAGA cuando se suelta. Motor DC
En este capítulo, conectaremos diferentes tipos de motores con la placa Arduino (UNO) y le mostraremos cómo
conectar el motor y conducirlo desde su placa.
Hay tres tipos diferentes de motores:

• motor de corriente continua • Servo motor

• Motor paso a paso

Un motor de CC (motor de corriente continua) es el tipo más común de motor. Los motores de
CCnormalmentetienensolodoscables,unopositivoyotronegativo. Siconectaestosdoscables directamenteaunabatería,
elmotorrotará. Si cambialos cables,elmotorrotaráen ladirección opuesta.
 Advertencia : no conduzca el motor directamente desde los pines de la placa
Arduino. Esto puede dañar el tablero. Use un circuito controlador o un IC.
Dividiremos este capítulo en tres partes:

• Solo haz girar tu motor

• Control de velocidad del motor
• Controla la dirección del giro del motor DC

Componentes requeridos
Necesitará los siguientes componentes:

• 1x placa Arduino UNO

• 1x transistor PN2222
• 1x motor pequeño de 6V DC
• 1x diodo 1N4001
• 1x resistencia de 270 Ω

Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Precauciones
Tome las siguientes precauciones mientras realiza las conexiones.
• Primero, asegúrese de que el transistor esté conectado de la manera correcta. El lado
planodeltransistordebemirarhacialaplacaArduino comosemuestraenla disposición. • En segundo lugar, el extremo
rayado del diodo debe estar hacia la línea de alimentación de + 5V de acuerdo con la disposición que se muestra en
la imagen.
Spin Control Código Arduino
int motorPin = 3;
void setup() {
}
void loop() {
digitalWrite(motorPin, HIGH);
}
Código a tener en cuenta
El transistor actúa como un interruptor, controlando la potencia del motor. El pin Arduino 3 se usa para encender y
apagar el transistor y se le da el nombre 'motorPin' en el boceto.

Resultado
El motor girará a toda velocidad cuando el pin Arduino número 3 suba.
Control de velocidad del motor

A continuación se muestra el diagrama esquemático de un motor de CC, conectado a la placa Arduino.

Código Arduino
int motorPin = 9;

void setup() {
pinMode(motorPin, OUTPUT);
Serial.begin(9600);
while (! Serial);
Serial.println("Speed 0 to 255");

}
void loop() {
if (Serial.available()) {
int speed = Serial.parseInt();

if (speed >= 0 && speed <= 255) {

analogWrite(motorPin, speed);
}
}
}
Código a tener en cuenta

El transistor actúa como un interruptor, controlando la potencia del motor. El pin Arduino 3 se usa para encender y
apagar el transistor y se le da el nombre 'motorPin' en el boceto. Cuando se inicia el programa, le solicita que
proporcione los valores para controlar la velocidad del motor. Debe ingresar un valor entre 0 y 255 en el Monitor de
serie.

En la función 'loop', el comando 'Serial.parseInt' se usa para leer el número ingresado como texto en el Serial
Monitor y convertirlo en un 'int'. Puede escribir cualquier número aquí. La declaración 'if' en la siguiente línea
simplemente hace una escritura analógica con este número, si el número está entre 0 y 255.

Resultado
El motor de CC girará con diferentes velocidades según el valor (0 a 250) recibido a través del puerto serie.
Control de dirección de giro

Para controlar la dirección del giro del motor de corriente continua, sin intercambiar los cables, puede utilizar un
circuito llamado H-puente . Un puente H es un circuito electrónico que puede conducir el motor en ambas
direcciones. Los puentes H se utilizan en muchas aplicaciones diferentes. Una de las aplicaciones más comunes es
controlar motores en robots. Se llama puente H porque utiliza cuatro transistores conectados de tal manera que el
diagrama esquemático se parece a una "H".

Usaremos el IC L298 H-Bridge aquí. El L298 puede controlar la velocidad y la dirección de los motores de CC y los
motores paso a paso, y puede controlar dos motores simultáneamente. Su clasificación actual es de 2A para cada
motor. A estas corrientes, sin embargo, necesitará usar disipadores de calor.
Componentes requeridos

Necesitará los siguientes componentes:

• 1 × L298 puente IC
• 1 × motor DC
• 1 × Arduino UNO
• 1 × placa de pruebas
• 10 × cables de puente

Procedimiento
El siguiente es el diagrama esquemático de la interfaz del motor de CC a la placa Arduino Uno.
El diagrama anterior muestra cómo conectar el IC L298 para controlar dos motores. Hay tres pines de entrada para
cada motor, Entrada1 (IN1), Entrada2 (IN2) y Enable1 (EN1) para Motor1 y Input3, Input4 y Enable2 para Motor2.

Como controlaremos solo un motor en esteejemplo, conectaremos el Arduino a IN1 (pin 5),IN2 (pin 7) y Enable1
(pin 6) del L298 IC. Los pines 5 y 7 son digitales, es decir, entradas ON u OFF, mientras que el pin 6 necesita una
señal modulada por ancho de pulso (PWM) para controlar la velocidad del motor.

La siguiente tabla muestra en qué dirección girará el motor en función de los valores digitales de IN1 e IN2.
IN 1 IN 2 Comportamiento motor
FRENO
1 ADELANTE
1 HACIA ATRÁS

1 1 FRENO
El pin IN1 del IC L298 está conectado al pin 8 de Arduino mientras que IN2 está conectado al pin 9. Estos dos pines
digitales de Arduino controlan la dirección del motor. El pin EN A de IC está conectado al pin PWM 2 de Arduino.
Esto controlará la velocidad del motor.

Para establecer los valores de los pines 8 y 9 de Arduino, hemos usado la función digitalWrite (), y para establecer el
valor del pin 2, tenemos que usar la función analogWrite (). Pasos de conexión

• Conecte 5V y la tierra del IC a 5V y la tierra de Arduino, respectivamente. • Conecte el motor a los pines 2 y 3 del
circuito integrado.
• Conecte IN1 del IC al pin 8 de Arduino.
• Conecte IN2 del IC al pin 9 de Arduino.
• Conecte EN1 de IC al pin 2 de Arduino.
• Conecte SENS Un pin de IC a la tierra.

•Conecte Arduino con el cable USB Arduino y cargue el programa en Arduino con el software Arduino IDE.
•Proporcione alimentación a la placa Arduino utilizando una fuente de alimentación, batería o cable USB.
Código Arduino

const int pwm = 2 ; //initializing pin 2 as pwm

const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output pinMode(in_1,OUTPUT) ; //Logic pins are also set
as output pinMode(in_2,OUTPUT) ;

void loop() {
//For Clock wise motion , in_1 = High , in_2 = Low
digitalWrite(in_1,HIGH) ;
digitalWrite(in_2,LOW) ;
analogWrite(pwm,255) ;
/* setting pwm of the motor to 255 we can change the speed of rotation by changing pwm input but we are only
using arduino so we are using highest value to driver the motor */
//Clockwise for 3 secs
delay(3000) ;
//For brake

digitalWrite (in_1,HIGH) ;
digitalWrite(in_2,HIGH) ;
delay(1000) ;
//For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
digitalWrite(in_1,LOW) ;
digitalWrite(in_2,HIGH) ;
delay(3000) ;
//For brake
digitalWrite(in_1,HIGH) ;
digitalWrite(in_2,HIGH) ;
delay(1000) ;

}
Resultado
El motor funcionará primero en sentido horario (CW) durante 3 segundos y luego en sentido antihorario (CCW)
durante 3 segundos.
Servomotor

Un servomotor es un dispositivo pequeño que tiene un eje de salida. Este eje se puede colocar en posiciones
angulares específicas enviando al servo una señal codificada. Mientras exista la señal codificadaenlalínea
deentrada,elservomantendrálaposiciónangulardeleje. Si laseñal codificada cambia, la posición angular del eje
cambia. En la práctica, los servos se utilizan en aviones controlados por radio para posicionar superficies de control
como los ascensores y timones. También se utilizan en automóviles, títeres y, por supuesto, robots controlados por
radio.
Los servos son extremadamente útiles en robótica. Los motores son pequeños, tienen un circuito de control
incorporado y son extremadamente potentes para su tamaño. Un servo estándar como el Futaba S-148 tiene 42 oz /
pulgadas de torque, que es fuerte para su tamaño. También consume energía proporcional a la carga mecánica. Un
servo ligeramente cargado, por lo tanto, no consume mucha energía.
Las tripas de un servomotor se muestran en la siguiente imagen. Puede ver los circuitos de control, el motor, un
conjunto de engranajes y la carcasa. También puede ver los 3 cables que se conectan al mundo exterior. Uno es para
alimentación (+ 5 voltios), tierra y el cable blanco es el cable de control.
Trabajo de un servomotor

El servomotor tiene algunos circuitos de control y un potenciómetro (una resistencia variable, también conocida
como potenciómetro) conectado al eje de salida. En la imagen de arriba, la olla se puede ver en el lado derecho de la
placa de circuito. Este bote permite que los circuitos de control controlen el ángulo actual del servomotor.

Si el eje está en el ángulo correcto, el motor se apaga. Si el circuito encuentra que el ángulo no es correcto, hará girar
el motor hasta que esté en el ángulo deseado. El eje de salida del servo es capaz de viajar en algún lugar alrededor de
180 grados. Por lo general, se encuentra en algún lugar en el rango de 210 grados, sin embargo, varía según el
fabricante. Se utiliza un servo normal para controlar un movimiento angular de 0 a 180 grados. No es capaz de girar
mecánicamente más lejos debido a un tope mecánico incorporado en el engranaje de salida principal.

La potencia aplicada al motor es proporcional a la distancia que necesita viajar. Entonces, si el eje necesita girar una
gran distancia, el motor funcionará a toda velocidad. Si necesita girar solo una pequeña cantidad, el motor
funcionará a una velocidad más lenta. Esto se llama control proporcional .
¿Cómo se comunica el ángulo al que debe girar el servo?

El cable de control se usa para comunicar el ángulo. El ángulo está determinado por la duración
deunpulsoqueseaplicaalcabledecontrol. Estosellama modulacióncodificadaporpulsos . El servo espera ver un pulso
cada 20 milisegundos (.02 segundos). La longitud del pulso determinará qué tan lejos gira el motor. Un pulso de 1.5
milisegundos, por ejemplo, hará que el motor gire a la posición de 90 grados (a menudo llamada posición neutral).
Si el pulso es más corto que 1.5 milisegundos, entonces el motor girará el eje más cerca de 0 grados. Si el pulso es
superior a 1,5 milisegundos, el eje gira más cerca de 180 grados.

Componentes requeridos

Necesitará los siguientes componentes:

• 1 × placa Arduino UNO

• 1 × servomotor
• 1 × IC de conducción ULN2003
• Resistencia 1 × 10 KΩ

Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Código Arduino
/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
Servo myservo; // create servo object to control a servo int potpin = 0; // analog pin used to connect the
potentiometer int val; // variable to read the value from the analog pin

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
val = analogRead(potpin);
// reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 180);
// scale it to use it with the servo (value between 0 and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15);

}
Código a tener en cuenta

Los servomotores tienen tres terminales: alimentación, tierra y señal. El cable de alimentación
sueleserrojoydebeconectarsealpinde5VdelArduino. Elcabledetierraestípicamentenegro o marrón y debe conectarse a
un terminal de ULN2003 IC (10-16). Para proteger su placa Arduino de daños, necesitará un controlador IC para
hacer eso. Aquí hemos utilizado ULN2003 IC para conducir el servomotor. El pin de señal es típicamente amarillo o
naranja y debe conectarse al pin número 9 de Arduino.

Conexión del potenciómetro

Un divisor de voltaje / divisor de potencial son resistencias en un circuito en serie que escalan el voltaje de salida a
una relación particular del voltaje de entrada aplicado. El siguiente es el diagrama del circuito:
$$ V_ {out} = (V_ {in} \ times R_ {2}) / (R_ {1} + R_ {2}) $$

Voutes el potencial de salida, que depende del voltaje de entrada aplicado (Vin) y las resistencias (R1y R2) en la serie.
Significa que la corriente que fluye a través de R1también fluirá a través de R2sin dividirse. En la ecuación anterior,
a medida que cambia el valor de R2, lasalida deV se escala en consecuencia con respecto al voltaje de entrada, Vde
entrada.

Típicamente,unpotenciómetroesundivisordepotencial,quepuede escalar elvoltajedesalida del circuito en función del

valor de la resistencia variable, que se escala utilizando la perilla. Tiene tres pines: GND, señal y + 5V como se
muestra en el siguiente diagrama:

Resultado
Al cambiar la posición NOP de la olla, el servomotor cambiará su ángulo.
Motor paso a paso

Un motor paso a paso o un motor paso a paso es un motor síncrono sin escobillas, que divide una rotación completa
en varios pasos. A diferencia de un motor de CC sin escobillas, que gira continuamente cuando se le aplica un
voltaje de CC fijo, un motor paso a paso gira en ángulos de paso discretos.

Por lo tanto, los motores paso a paso se fabrican con pasos por revolución de 12, 24, 72, 144, 180 y 200, lo que
resulta en ángulos de paso de 30, 15, 5, 2.5, 2 y 1.8 grados por paso. El motor paso a paso se puede controlar con o
sin retroalimentación.

ImagineunmotorenunaviónRC. Elmotorgiramuyrápidoenunadirecciónuotra. Puedevariar la velocidad con la cantidad

de potencia dada al motor, pero no puede decirle a la hélice que se detenga en una posición específica.

Ahora imagina una impresora. Hay muchas piezas móviles dentro de una impresora, incluidos motores. Uno de estos
motores actúa como el alimentador de papel, girando rodillos que
mueveneltrozodepapelamedidaqueseimprimetintaenél. Estemotornecesitapodermover el papel una distancia exacta
para poder imprimir la siguiente línea de texto o la siguiente línea de una imagen.

Hay otro motor conectado a una varilla roscada que mueve el cabezal de impresión de un lado a otro. Una vez más,
esa varilla roscada debe moverse una cantidad exacta para imprimir una letra tras otra. Aquí es donde los motores
paso a paso son útiles.
¿Cómo funciona un motor paso a paso?
Un motor de CC normal gira solo en una dirección, mientras que un motor paso a paso puede girar en incrementos
precisos.

Los motores paso a paso pueden girar una cantidad exacta de grados (o pasos) según lo deseado. Esto le brinda un
control total sobre el motor, lo que le permite moverlo a una ubicación exacta y mantener esa posición. Lo hace
alimentando las bobinas dentro del motor por períodos muy cortos de tiempo. La desventaja es que tiene que
alimentar el motor todo el tiempo para mantenerlo en la posición que desea.
Todo lo que necesita saber por ahora es que, para mover un motor paso a paso, le dice que mueva un cierto número
de pasos en una dirección u otra, y le dice la velocidad a la que debe caminar en esa dirección. Existen numerosas
variedades de motores paso a paso. Los métodos descritos aquí se pueden usar para inferir cómo usar otros motores
y controladores que no se mencionan en este libro. Sin embargo, siempre se recomienda que consulte las hojas de
datos y las guías de los motores y controladores específicos de los modelos que tiene.
Componentes requeridos
Necesitará los siguientes componentes:

• 1 × placa Arduino UNO

• 1 × motor paso a paso bipolar pequeño como se muestra en la imagen a continuación • 1 × LM298 conduciendo IC
Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Bosquejo
Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Código Arduino
/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution // for your motor
// initialize the stepper library on pins 8 through 11: Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
// set the speed at 60 rpm: myStepper.setSpeed(5); // initialize the serial port: Serial.begin(9600);

void loop() {
// step one revolution in one direction:
Serial.println("clockwise");
myStepper.step(stepsPerRevolution);
delay(500);
// step one revolution in the other direction:
Serial.println("counterclockwise");
myStepper.step(stepsPerRevolution);
delay(500);

}
Código a tener en cuenta
Este programa impulsa un motor paso a paso unipolar o bipolar. El motor está conectado a los pines digitales 8 - 11
de Arduino.
Resultado
El motor tomará una revolución en una dirección, luego una revolución en la otra dirección. Biblioteca de tonos

En este capítulo, utilizaremos la biblioteca de tonos Arduino. No es más que una Biblioteca Arduino, que produce
una onda cuadrada de una frecuencia específica (y un ciclo de trabajo del 50%) en cualquier pin Arduino.
Opcionalmente, se puede especificar una duración; de lo contrario, la onda continúa hasta que se llama a la función
stop (). El pin se puede conectar a un zumbador piezoeléctrico o un altavoz para reproducir los tonos.

Advertencia : no conecte el pin directamente a ninguna entrada de audio. El voltaje es considerablemente más alto
que los voltajes de nivel de línea estándar y puede dañar las entradas de la tarjeta de sonido, etc. Puede usar un
divisor de voltaje para bajar el voltaje. Componentes requeridos

Necesitará los siguientes componentes:

• Altavoz de 1 × 8 ohmios • 1 × 1k resistencia

• 1 × placa Arduino UNO

Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Bosquejo

Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Para crear el archivo pitches.h, haga clic en el botón que se encuentra debajo del icono del monitor en serie y
seleccione "Nueva pestaña", o use Ctrl + Shift + N.
Luego pegue el siguiente código:

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55 #define NOTE_AS1 58 #define NOTE_B1 62 #define NOTE_C2 65 #define NOTE_CS2 69
#define NOTE_D2 73 #define NOTE_DS2 78 #define NOTE_E2 82 #define NOTE_F2 87 #define NOTE_FS2 93
#define NOTE_G2 98 #define NOTE_GS2 104 #define NOTE_A2 110 #define NOTE_AS2 117 #define NOTE_B2
123 #define NOTE_C3 131 #define NOTE_CS3 139 #define NOTE_D3 147 #define NOTE_DS3 156 #define
NOTE_E3 165 #define NOTE_F3 175 #define NOTE_FS3 185 #define NOTE_G3 196 #define NOTE_GS3 208
#define NOTE_A3 220 #define NOTE_AS3 233 #define NOTE_B3 247 #define NOTE_C4 262 #define
NOTE_CS4 277 #define NOTE_D4 294 #define NOTE_DS4 311 #define NOTE_E4 330 #define NOTE_F4 349
#define NOTE_FS4 370 #define NOTE_G4 392 #define NOTE_GS4 415 #define NOTE_A4 440 #define
NOTE_AS4 466 #define NOTE_B4 494 #define NOTE_C5 523 #define NOTE_CS5 554 #define NOTE_D5 587
#define NOTE_DS5 622 #define NOTE_E5 659 #define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760

io
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093

ti.
#define NOTE_CS7 2217
#define NOTE_D7 2349

en
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
id
76
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
19

#define NOTE_CS8 4435

#define NOTE_D8 4699
#define NOTE_DS8 4978
ko

Guarde el código dado anteriormente como tonos.h

Código Arduino
Ya

#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4}; // note durations: 4 =
by

quarter note, 8 = eighth note, etc.:

int noteDurations[] = { 4, 8, 8, 4,4,4,4,4

};

void setup() {
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < 8; thisNote++) {

// to calculate the note duration, take one second // divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc. int noteDuration = 1000/noteDurations[thisNote]; tone(8,
melody[thisNote],noteDuration);
//pause for the note's duration plus 30 ms:
delay(noteDuration +30);

}
}

void loop() {
// no need to repeat the melody.
}
Código a tener en cuenta

El código usa un archivo adicional, pitches.h. Este archivo contiene todos los valores de tono para notas típicas. Por
ejemplo, NOTE_C4 es el medio C. NOTE_FS4 es F sostenido, y así sucesivamente. Esta tabla denotas fueescrita
originalmente por Brett Hagman, en cuyotrabajo se basó el comando tone (). Puede que le resulte útil cuando quiera
hacer notas musicales.

Resultado
Escuchará notas musicales guardadas en los tonos. H. archivo.
Comunicación inalámbrica

Los módulos inalámbricos de transmisor y receptor funcionan a 315 Mhz. Pueden caber fácilmente en una placa y
funcionar bien con microcontroladores para crear un enlace de datos inalámbrico muy simple. Con un par de
transmisor y receptor, los módulos solo funcionarán comunicando datos de una manera, sin embargo, necesitaría dos
pares (de diferentes frecuencias) para actuar como un par transmisor / receptor.

Nota : estos módulos son indiscriminados y reciben una buena cantidad de ruido. Tanto el transmisor como el

receptor funcionan a frecuencias comunes y no tienen ID.

Especificaciones del módulo receptor

• Modelo de producto - MX-05V

• Voltaje de operación - DC5V
• Corriente de reposo - 4 mA
• Frecuencia de recepción - 315Mhz
• Sensibilidad del receptor -105DB
• Tamaño - 30 * 14 * 7 mm

Especificaciones del módulo transmisor

• Modelo de producto - MX-FS-03V

• Distancia de lanzamiento: 20-200 metros (voltaje diferente, resultados diferentes) • Voltaje de funcionamiento: 3.5-
12 V
• Dimensiones - 19 * 19 mm
• Modo de funcionamiento - AM
• Velocidad de transferencia: 4KB / S
• Potencia de transmisión: 10 mW
• Frecuencia de transmisión - 315Mhz
• Una antena externa: línea de núcleo múltiple o núcleo simple de 25 cm • Pinout de izquierda → derecha - (DATOS;
VCC; GND)

Componentes requeridos
Necesitará los siguientes componentes:

• 2 × placa Arduino UNO • 1 × transmisor de enlace Rf • 1 × receptor de enlace Rf

Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
Bosquejo

Abra el software Arduino IDE en su computadora. La codificación en el idioma Arduino controlará su circuito. Abra
un nuevo archivo de boceto haciendo clic en Nuevo.

Nota : debe incluir la biblioteca de teclado en su archivo de biblioteca Arduino. Copie y pegue el
archivoVirtualWire.lib enla carpetade bibliotecascomoseresaltaen lacapturadepantallaque se muestra a continuación.
Código Arduino para transmisor
//simple Tx on pin D12
#include <VirtualWire.h> char *controller;

void setup() {
pinMode(13,OUTPUT);
vw_set_ptt_inverted(true);
vw_set_tx_pin(12);
vw_setup(4000);// speed of data transfer Kbps

void loop() {
controller="1" ;
vw_send((uint8_t *)controller, strlen(controller));
vw_wait_tx(); // Wait until the whole message is gone
digitalWrite(13,1);
delay(2000);
controller="0" ;
vw_send((uint8_t *)controller, strlen(controller));
vw_wait_tx(); // Wait until the whole message is gone
digitalWrite(13,0);
delay(2000);

}
Código a tener en cuenta
Este es un código simple. Primero, enviará el carácter '1' y después de dos segundos enviará el carácter '0' y así
sucesivamente.
Código Arduino para receptor
//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
vw_set_ptt_inverted(true); // Required for DR3100 vw_set_rx_pin(12);
vw_setup(4000); // Bits per sec
pinMode(5, OUTPUT);
vw_rx_start(); // Start the receiver PLL running

void loop() {
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) // Non-blocking {

if (buf[0]=='1') {
digitalWrite(5,1);
}
if(buf[0]=='0') {
digitalWrite(5,0);
}
}
}
Código a tener en cuenta

El LED conectado al pin número 5 en la placa Arduino se enciende cuando se recibe el carácter '1' y se apaga
cuando se recibe el carácter '0'.
Comunicación de red
El módulo WiFi CC3000 de Texas Instruments es un pequeño paquete plateado, que finalmente ofrece una
funcionalidad WiFi fácil de usar y asequible para sus proyectos Arduino.

UtilizaSPIparalacomunicación (¡noUART!)Paraquepuedaenviardatostanrápidocomodesee otanlentocomodesee.

Tieneunsistemadeinterrupciónadecuado con pin IRQparaque pueda tenerconexionesasincrónicas.
Admiteseguridad802.11b/g,abierta/WEP/ WPA/WPA2,TKIP y AES. Una pila TCP / IP incorporada con una interfaz
"socket BSD" admite TCP y UDP tanto en el modo cliente como en el servidor.

Componentes requeridos
Necesitará los siguientes componentes:

• 1 × Arduino Uno
• 1 × tablero de conexiones Adafruit CC3000
• Relé 1 × 5V
• 1 × diodo rectificador
• 1 × LED
• 1 × resistencia de 220 ohmios
• 1 × placa de pruebas y algunos cables de puente

Para este proyecto, solo necesita el IDE Arduino habitual, la biblioteca CC3000 de Adafruit y la biblioteca MDNS
CC3000. También vamos a utilizar la biblioteca aREST para enviar comandos al relé a través de WiFi.

Procedimiento
Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen a continuación.
La configuración de hardware para este proyecto es muy fácil.

• Conecte el pin IRQ de la placa CC3000 al pin número 3 de la placa Arduino. • VBAT al pin 5 y CS al pin 10.

• Conecte los pines SPI a la placa Arduino: MOSI, MISO y CLK a los pines 11, 12 y 13, respectivamente.

•Vinestá conectado a Arduino 5V y GND a GND.

Ahora conectemos el relé.

Después de colocar el relé en la placa de pruebas, puede comenzar a identificar las dos partes importantesensu relé:
lapartedelabobinaquecontrolaelrelé yla partedel interruptordonde conectaremos el LED.

• Primero, conecte el pin número 8 de la placa Arduino a un pin de la bobina. • Conecte el otro pin al suelo de la
placa Arduino.
También debe colocar eldiodo rectificador (ánodo conectado alpin detierra) sobre lospines de la bobina para
proteger su circuito cuando el relé está cambiando.
• Conecte los + 5V de la placa Arduino al pin común del interruptor del relé.

• Finalmente, conecteunode los otros pines del interruptor (generalmente,el que no está conectado cuando elrelé está
apagado)al LED en serie con la resistencia de 220 ohmios, y conecte el otro lado del LED a la tierra de Arduino
tablero.

Prueba de componentes individuales

Puede probar el relé con el siguiente boceto: const int relay_pin = 8; // Relay pin

void setup() {
Serial.begin(9600);
pinMode(relay_pin,OUTPUT);

void loop() {
// Activate relay
digitalWrite(relay_pin, HIGH);
// Wait for 1 second
delay(1000);
// Deactivate relay
digitalWrite(relay_pin, LOW);
// Wait for 1 second
delay(1000);

}
Código a tener en cuenta
El código se explica por sí mismo. Simplemente puede cargarlo en la placa y el relé cambiará de estado cada
segundo, y el LED se encenderá y apagará en consecuencia.
Agregar conectividad WiFi

Ahoracontrolemos elrelé deformainalámbricautilizandoelchip WiFiCC3000. El softwarepara este proyecto se basa

en el protocolo TCP. Sin embargo, para este proyecto, la placa Arduino
ejecutaráunpequeñoservidorweb,porloquepodemos"escuchar"loscomandosprovenientes delacomputadora.
PrimeronosocuparemosdelbocetoArduino,yluegoveremoscómoescribir el código del lado del servidor y crear una
interfaz agradable.

Primero, el boceto Arduino. El objetivo aquí es conectarse a su red WiFi, crear un servidor web, verificar si hay
conexiones TCP entrantes y luego cambiar el estado del relé en consecuencia. Partes importantes del código

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

Debe definir dentro del código qué es específico de su configuración, es decir, nombre y contraseña de Wi-Fi, y el
puerto para las comunicaciones TCP (hemos utilizado 80 aquí).

// WiFi network (change with your settings!)

#define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters! #define WLAN_PASS
"yourPassword"
#define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC,

WLAN_SEC_WEP,
// WLAN_SEC_WPA or WLAN_SEC_WPA2
// The port to listen for incoming TCP connections
#define LISTEN_PORT 80
Luego podemos crear la instancia CC3000, el servidor y una instancia REST

// Server instance
Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance MDNSResponder mdns; // Create
aREST instance
aREST rest = aREST();

En la parte setup () del boceto, ahora podemos conectar el chip CC3000 a la red:
cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

¿Cómo sabrá la computadora dónde enviar los datos? Una forma sería ejecutar el boceto una vez, luego obtener la
dirección IP de la placa CC3000 y modificar el código del servidor nuevamente. Sin embargo, podemos hacerlo
mejor, y ahí es donde entra en juego la biblioteca CC3000 MDNS. Asignaremos un nombre fijo a nuestra placa
CC3000 con esta biblioteca, para que podamos escribir este nombre directamente en el código del servidor.

Esto se hace con el siguiente código:

if (!mdns.begin("arduino", cc3000)) {
while(1);
}

También necesitamos escuchar las conexiones entrantes.

restServer.begin();

A continuación, codificaremos la función loop () del boceto que se ejecutará continuamente. Primero tenemos que
actualizar el servidor mDNS.
mdns.update();

El servidor que se ejecuta en la placa Arduino esperará las conexiones entrantes y manejará las solicitudes.
Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

Ahora es bastante fácil probar los proyectos a través de WiFi. Asegúrese de actualizar el boceto
consupropionombreycontraseñadeWiFi,ysubaelbocetoasuplacaArduino. Abrasumonitor serie Arduino IDE y busque
la dirección IP de su placa.

Supongamos por lo demás aquí que es algo así como 192.168.1.103.

Luego, simplemente vaya a su navegador web favorito y escriba:
192.168.1.103/digital/8/1
Debería ver que su relé se enciende automáticamente.
Construyendo la interfaz de relé
Ahora codificaremos la interfaz del proyecto. Habrá dos partes aquí: un archivo HTML que contiene la interfaz y un
archivo Javascript del lado del cliente para manejar los clics en la interfaz. La interfaz aquí se basa en el proyecto
aREST.js , creado para controlar fácilmente los dispositivos WiFi desde su computadora.

PrimeroveamoselarchivoHTML,llamadointerface.html. Laprimeraparteconsisteen importar todas las bibliotecas

necesarias para la interfaz:

<head>
<meta charset = utf-8 />
<title> Relay Control </title>
<link rel = "stylesheet" type = "text/css"

href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css"> <link rel="stylesheet" type =

"text/css" href = "style.css">
<script type = "text/javascript"

src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
<script type = "text/javascript"
src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
<script type = "text/javascript"
src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script> <script type = "text/javascript"
src = "script.js"></script>
</head>

Luego, definimos dos botones dentro de la interfaz, uno para encender el relé y el otro para apagarlo nuevamente.

<div class = 'container'>

<h1>Relay Control</h1>
<div class = 'row'>

<div class = "col-md-1">Relay</div>

<div class = "col-md-2">

<button id = 'on' class = 'btn btn-block btn-success'>On</button>

</div>
<div class = "col-md-2">

<button id = 'off' class = 'btn btn-block btn-danger'>On</button>

</div>
</div>
</div>

Ahora, también necesitamos un archivo Javascript del lado del cliente para manejar los clics en los botones.
También crearemos un dispositivo que vincularemos al nombre mDNS de nuestro dispositivo Arduino. Si cambió
esto en el código Arduino, también deberá modificarlo aquí.

// Create device
var device = new Device("arduino.local");
// Button

$ ('#on').click(function() { device.digitalWrite(8, 1);

});

$ ('#off').click(function() {
device.digitalWrite(8, 0);
});

El código completo para este proyecto se puede encontrar en el repositorio de GitHub . Vaya a la
carpetadelainterfazysimplemente abra elarchivo HTMLconsunavegadorfavorito. Debería ver algo similar dentro de
su navegador:

Intente hacer clic en

un botón en la interfaz web; Debería cambiar el estado del relé casi instantáneamente.

Si lograste que funcionara, ¡bravo! Acaba de construir un interruptor de luz controlado por WiFi. Por supuesto,
puedes controlar mucho más que luces con este proyecto. Solo asegúrese de que su relé admita la potencia requerida
para el dispositivo que desea controlar, y estará listo.