Electrónica III

Eric William Zurita Bustamante

zube84@[Link]
55 1907 4669
• ARDUINO
• Arduino es una tarjeta electrónica digital y además es un lenguaje de
programación basado en C++ que es «open-source».
• Su Hardware esta construido por un microcontrolador de la familia
AVR.
• Arduino es entonces una herramienta de procesamiento digital
parecido a una computadora.
• Tipos de placas
• Arduino Uno R3
• Microcontrolador: ATMega328P.
• Velocidad de reloj: 16 MHz.
• Voltaje de trabajo: 5V.
• Voltaje de entrada: 7,5 a 12 voltios.
• Pinout: 14 pines digitales (6 PWM) y
6 pines analógicos.
• 1 puerto serie por hardware.
• Memoria: 32 KB Flash (0,5 para
bootloader), 2KB RAM y 1KB Eeprom
• Arduino Mega
• Es usada para proyectos con necesidad de mayor
cantidad de pines. Estás son sus características
técnicas:
• Microcontrolador: ATMega2560.
• Velocidad de reloj: 16 MHz.
• Voltaje de trabajo: 5V.
• Voltaje de entrada: 7,5 a 12 voltios.
• Pinout: 54 pines digitales (15 PWM) y 16 pines
analógicos.
• 3 puertos serie por hardware.
• Memoria: 256 KB Flash (8KB para bootloader), 8KB
RAM y 4KB Eeprom
• Arduino Nano
• Es la placa Arduino Uno R3 en versión
reducida, pero con dos pines analógicos
adicionales. Estás son sus características
técnicas:
• Microcontrolador: ATMega328P.
• Velocidad de reloj: 16 MHz.
• Voltaje de trabajo: 5V.
• Voltaje de entrada: 7,5 a 12 voltios.
• Pinout: 14 pines digitales (6 PWM) y 8 pines
analógicos.
• 1 puerto serie por hardware.
• Memoria: 32 KB Flash (2KB para bootloader),
2KB RAM y 1KB Eeprom
• Arduino Leonardo
• Similar al Arduino Uno R3, pero con el
puerto USB integrado. Estás son sus
características técnicas:
• Microcontrolador: ATMega32u4.
• Velocidad de reloj: 16 MHz.
• Voltaje de trabajo: 3,3V.
• Voltaje de entrada: 7,5 a 12 voltios.
• Pinout: 20 pines digitales (7 PWM) y 12
pines analógicos.
• Memoria: 32 KB Flash (4KB para
bootloader), 2,5KB RAM y 1KB Eeprom
Información sobre arduino

[Link]
• Estructura de un programa en int led1; // antes de la función setup() podemos utilizar
Arduino esta zona para declarar variables
• La estructura básica del int led2;
void setup()
lenguaje de programación de {
Arduino es bastante simple y se instrucciones; // aquí realizamos la configuración inicial
compone de al menos dos de variables
}
partes: setup y loop. void loop()
• Estas dos partes necesarias, o { instrucciones; //el código que se va a repetir de forma
funciones, encierran bloques indefinida
que contienen declaraciones, }
estamentos o instrucciones.
• Variables
• Una variable es la manera que tenemos de guardar valores. Las variables
tienen nombre y son de un solo tipo. Estas variables se pueden usar para
muchas cosas: comprobaciones, operaciones matemáticas…
• Una variable puede ser declarada al inicio del programa, antes del setup(),
dentro de otras funciones o dentro de un control de flujo.

• int variableEntrada = 0;
• char letras = ‘b’;
• void setup(){
• variableEntrada = analogRead(2)
• }
• Una variable global es aquella que puede ser vista y utilizada por cualquier
función, esta se declara al principio. Por el contrario, las variables locales
son aquellas que se definen en una función y se usa solo en la función en la
que se declaró.
• boolean (8 bit)- lógico simple verdadero/falso.
• byte (8 bit)- número sin signo entre 0 y 255.
• char (8 bit)- número con signo, entre -128 y 127. En algunos casos el
compilador intentará interpretar este tipo de dato como un caracter,
lo que puede generar resultados inesperados.
• unsigned char (8 bit)- lo mismo que ‘byte’; si es que eso es lo que
necesitas, deberías usar ‘byte’, para que el código sea más claro.
• word (16 bit)- número sin signo entre, 0 y 65535.
• unsigned int (16 bit)- lo mismoque ‘word’. Utiliza ‘word’ por
simplicidad y brevedad.
• int (16 bit)- número con signo, entre -32768 y 32767. Este tipo es el más
usado para variables de propósito general en Arduino, en los códigos de
ejemplo que vienen con el IDE.
• unsigned long (32 bit)- número sin signo entre 0 y 4294967295. Este tipo
se usa comúnmente para almacenar el resultado de la función millis(), la
cual retorna el tiempo que el código actual ha estado corriendo, en
milisegundos.
• long (32 bit)- número con signo, entre -2,147,483,648 y 2,147,483,647.
• float (32 bit)- número con signo, entre 3.4028235E38 y 3.4028235E38. El
Punto Flotante no es un tipo nativo en Arduino; el compilador debe realizar
varios saltos para poder hacerlo funcionar. Arduino.
• Las constantes enteras son números utilizados en el sketch, estos números
son tratados como enteros, pero podemos cambiar su comportamiento

• Las constantes enteras son tratadas como base 10 (Decimal), pero con una
notación especial podemos cambiar su representación en otras bases.

• Binario – B00001110 //se indican con el prefijo “B".

• Octal – 0173 //se indican con el prefijo "0" (cero)
• Hexadecimal – 0x7C3 //se indican con el prefijo "0x" (cero equis).
 • CONSTANTES
• Una constante es un valor que no puede ser modificado durante la
ejecución de un programa.
Constantes booleanas: TRUE | FALSE Representan el valor de verdadero (1) o falso (0).
Definición de los pines: INPUT, INPUT_PULLUP y OUTPUT INPUT: entrada
INPUT_PULLUP: entrada con acoplamiento a positivo
OUTPUT: salida
Escritura de un pin: HIGH | LOW Si el pin está configurado como INPUT, dará HIGH si:
un voltaje mayor a 3 voltios esta presente en el pin (tarjetas
de 5V)
un voltaje mayor a 2 voltios esta presente en el pin (tarjetas
de 3.3V)
En cambio, si el pin está configurado como OUTPUT, dará
HIGH si:
5 voltios (tarjetas de 5V)
3.3 voltios (tarjetas de 3.3V)

LED_BUILTIN LED que viene incorporado en la placa.

• PINES DIGITALES
• Una señal digital es un tipo de señal generada por algún tipo de
fenómeno electromagnético en que cada signo que codifica el
contenido de la misma puede ser analizado en término de algunas
magnitudes que representan valores discretos, en lugar de valores
dentro de un cierto rango. Por ejemplo, el interruptor de la luz sólo
puede tomar dos valores o estados: abierto o cerrado, o la misma
lámpara: encendida o apagada.
• En arduino y placas compatibles para tratar las entradas y salidas digitales
usamos las siguientes funciones:
• pinMode() – configura en el pin especificado si se va a comportar como
una entrada o una salida. [Link]
• digitalWrite() – Escribe un valor HIGH o LOW en el pin digital especificado.
Si el pin está configurado como OUTPUT pone el voltaje correspondiente
en el pin seleccionado. Si el pin está configurado como INPUT habilita o
deshabilita la resistencia interna de pull up del correspondiente pin.
[Link]
• digitalRead() – lee el valor del pin correspondiente como HIGH o LOW.
• Ejemplo. Prender un led mediante el pin 5 del Arduino
• Ejemplo. Establece el pin 13 con el mismo valor que el pin 7,
declarado como una entrada.

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

int inPin = 7; // botón conectado al pin digital 7
int val = 0; // variable para almacenar el valor leido

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

void loop()
{
val = digitalRead(inPin); // lee el pin de entrada
digitalWrite(ledPin, val); // configura el pin del LED al mismo valor que el boton
}
• Ejercicio.
• a) Crear una función que reciba un entero de 0 a 9 y que genere las
salidas para mostrar el número correspondiente en un display de 7
segmentos.
• Los puertos de un
microcontrolador de 8 bits
tienen esa misma cantidad de
entradas/salidas, o sea ocho
líneas.
• El PORTB (puerto B) tiene
ocupadas dos líneas de
entrada/salida que se utilizan
para conectar el cristal oscilador.
Estos pines, el PORTB bit-6 y
PORTB bit-7.
• El PORTC tiene dos bits que no
están disponibles, uno de ellos,
el PORTC bit-6 se utiliza como
entrada de reinicio (RESET), y el
otro bit (7) no está cableado
hacia el exterior
• El ATmega328P tiene tres registros de 8 bits con los que administra
estos tres puertos:

• DDRx (donde x es B, C o D en este caso) determina si un bit es

entrada (fijándolo en 0) o salida (fijándolo en 1)
• PORTx controla si el pin está en nivel ALTO (HIGH) o BAJO (LOW).
También define la existencia o no de un resistor de polarización a Vcc
(pull-up, en inglés) si es una entrada.
• PINx permite leer el estado de los pines de un puerto (solo es para
lectura)
• Ventajas de usar registros:
• Cada instrucción de máquina necesita un ciclo de reloj a 16 MHz. Las
funciones digitalRead() y digitalWrite() se componen cada una de ellas de
varias instrucciones de máquina, lo que puede influir negativamente en
aplicaciones muy dependientes del tiempo. El uso de los registros PORTx
puede hacer el mismo trabajo en muchos menos ciclos de reloj.
• Si es necesario cambiar de estado varios pines simultáneamente en lugar
de ir haciéndolo de a uno con un ciclo for, que tomaría mucho tiempo, es
posibles escribir directamente al registro y establecer los valores de varios
pines de una sola vez.
• Si el código está llegando al límite de memoria de programa disponible
(memoria Flash), es posible usar este método para hacer que el código use
menos bytes de programa.
• Ejemplos:
• DDRB = B11110000; // PORTB7-PORTB4 como salidas, PORTB0-PORTB3
como entradas.
• DDRD = B11111111; // PORTD0-PORTD7 como salidas.
• DDRB = B00000000; // PORTB0-PORTB7 como entradas.
• DDRB = B00000111; // PORTB0-PORTB2 salidas, PORTB3-PORTB7 como
entradas.
• PORTD = B11111111; // PORTD0-PORTD7 en ALTO (HIGH).
• PORTD = B00000000; // PORTD0-PORTD7 en BAJO (LOW).
• PORTB = B00000101; // PORTB0 y PORTB2 en ALTO (HIGH), PORTB1,
PORTB3-PORTB7 en BAJO (LOW).
Número a b c d e f g HEX
0 1 1 1 1 1 1 0 0x7E
1 0 1 1 0 0 0 0 0x30
2 1 1 0 1 1 0 1 0x6D
3 1 1 1 1 0 0 1 0x79
4 0 1 1 0 0 1 1 0x33
5 1 0 1 1 0 1 1 0x5B
6 1 0 1 1 1 1 1 0x5F
7 1 1 1 0 0 0 0 0x70
8 1 1 1 1 1 1 1 0x7F
9 1 1 1 1 0 1 1 0x7B
 PUERTO SERIAL
• La comunicación serial basada en el protocolo RS-232 es la principal
forma de comunicación que posee Arduino para intercambiar
información con otros dispositivos. A través del puerto serie es como
los usuarios podemos enviarle información desde la computadora. El
Arduino IDE utiliza comunicación serial para cargar el código en el
Arduino.
UART
UART (Modo asíncrono)
• El receptor/transmisor asíncrono universal (Universal Asynchronous
Receiver/Transmitter,UART) es un dispositivo de comunicaciones
serie. Su función principal es convertir los datos serie a paralelos
cuando se reciben datos (de entrada) y de convertir los datos
paralelos a serie para transmisión (de salida).
• ¿Cómo configurar UART?
• Establecer la velocidad de transmisión en emisor y receptor debe ser la
misma para poder realizar la comunicación.

• [Link](9600);//Instrucción dentro del setup

• Esta instrucción le indica al Arduino que inicie comunicación con la

computadora (o cualquier dispositivo conectado a los pines RX y TX) con
una velocidad de comunicación serial de 9600 bits por segundo (baudios).
Existen otras velocidades de transmisión de datos, tales como 300, 600,
1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200.
[Link]("Hola Mundo");
Imprime datos al puerto serie como texto ASCII

[Link] (78) da "78"

[Link] (1,23456) da "1,23"
[Link] ( "N") da "N"
[Link] ( "Hola mundo".) Da "Hola mundo".
• [Link]

• Imprime datos al puerto serie como texto ASCII seguido de un

carácter de retorno de carro (‘\r’) y un carácter de retorno de línea
(‘\n’)
• SINTAXIS
• [Link](val)
• [Link](val,format)
• SINTAXIS
• [Link](val)
• [Link](val,format)
• Val: Valor a imprimir
• Format: Especifica la base numérica (para datos de tipo int) o número de decimales para float.

• analogValue = analogRead(0);
• //imprime la salida en varios formatos: [Link](analogValue);
• [Link](analogValue, DEC); // imprime como ASCII-codificado decimal
• [Link](analogValue, HEX);
• [Link](analogValue, OCT);
• [Link](analogValue, BIN);
• Ejemplo. Realizar una cuenta de 0 a 100 y mandar el número por el
puerto serie a una velocidad de 9600 bps.
Recibir datos por el puerto serial
• En el lenguaje Arduino Serial Read es una función que permite leer
(recibir) bytes mediante un puerto Serial. La función puede funcionar
asíncronamente. Una de las características principales del puerto
serial de Arduino, es que sólo puede enviar o recibir un byte por
transmisión. Entonces para poder usar a la función [Link]() se
requiere indicar, de preferencia, cuantos bytes son los que se quieren
leer.
• Esto es, utilizar a la función [Link]() en conjunto con Arduino
Serial Read para hacer la lectura de los bytes seriales.
• La trama de datos recibidos incluye: un bit de inicio + 8 bits de datos +
1 bit de parada.
• Sintaxis:
[Link]( ) ;
• Parámetros de entrada: Ninguno

• Parámetro de salida: byte de lectura ó -1 cuando no existe un byte

disponible para la lectura.

• Recomendación: Usar en conjunto con [Link]();

• Ejemplo. Encender un led conectado al pin número 13 si se recibe un
byte=‘A’. Apagarlo si se recibe un byte=‘B’
Iniciar función
setup

¿Existe 1
Byte disponible
No
Configurar
en el puerto
serial
serial?

Configurar pin
Si
13 como salida Dato=[Link]();

Fin función Si
setup Dato==’A’; digitalWrite(13,HIGH);

No
Si
Iniciar función Dato==’B’; digitalWrite(13,LOW);
loop
No
void setup(){
[Link](9600);
pinMode(13,OUTPUT);
}

void loop(){
if([Link]() > 0 ){
char Dato = [Link]();
if(Dato == 'A') digitalWrite(13,HIGH);
else if(Dato == 'B') digitalWrite(13,LOW);
}
}
• Todos los caracteres que se encuentren después de '//' son
comentarios y sirve para indicarnos y recordarnos que hacen
determinados tramos o piezas de código. En el código anterior hay 2
funciones llamadas:

• setup()

• loop()
• La función setup() es donde se configura el microcontrolador y solo se
ejecuta una vez, cuando la placa es alimentada por una fuente de
voltaje o cuando ejecutamos un reset.

• La función loop() como su nombre lo indica es un

bucle que se repite indefinidamente y es donde se
escribe el programa principal.
• Ejemplo. Encender y apagar un led
void setup() {
pinMode(5, OUTPUT);
}
void loop() {
digitalWrite(5, HIGH);
delay(1000);
digitalWrite(5, LOW);
delay(1000);
}
• USO DE SENTENCIA IF
• Sentencia if…else
• La utilizamos cuando tenemos una condición que nos arroja dos
resultados: Verdadero o Falso.
if (edad >= 18){
printf("Ya puedes votar");
}
else{
printf("Todavia eres un niño");
}
• Operadores condicionales
• Las condiciones que van dentro de los paréntesis usan operadores
condicionales, que son los siguientes: <, >, <=, >=, ==, !=. (Menor,
mayor, menor-igual, mayor-igual, igual, diferente)
if (n==0){
printf("Es nulo");
}
else{
if (n<0){
printf("Es negativo");
}
else{
printf("Es positivo");
}
}
• Operadores lógicos
• Los operadores lógicos son Y, O, y NO (AND, OR y NOT). En lenguaje C
se utilizan estos símbolos: &&, || y !

• Se utilizan para que evaluar dos o más condiciones en un solo if.

• Hacer un programa que realice descuentos en base a lo siguiente:
• Si la compra es menor a 500 no hay descuento int main(){
float compra, descuento, total;
• Si es entre 500 y 1000, 10% de descuento printf("Monto de la compra: ");
• Si es entre 1000 y 2000, 20% de descuento scanf("%f",&compra);
if (compra < 500){
• Si es mayor a 2000, 30% de descuento descuento = 0;
}
if (compra >= 500 && compra < 1000){
descuento= compra * .10;
}
if (compra >= 1000 && compra < 2000){
descuento = compra * .20;
}
if (compra >= 2000){
descuento = compra * .30;
}
total = compra - descuento;
printf("Su descuento es: %.2f", descuento);
printf("\nEl total a pagar es: %.2f", total);
}
• Operador AND && • Operador OR ||
• Tabla de verdad • Tabla de verdad
• V && V = V • V || V = V
• V && F = F V || F = V
F || V = V
• F&& V =F F || F = F
• F && F= F
• Ejercicio Arduino. Definir dos variables en c
• Int a=5;
• Int b=3;
• Determinar mediante secuencias if else, cual de los dos números es
mayor.
• Si a>b encender un led por el pin 0.
• Si a=b encender un led por el pin 1.
• Si a<b encender un led por el pin 2.
• Los valores de las variables se definen al declararse.
• Ejercicio. Configurar dos entradas digitales en Arduino (pines 12 y 13)
y determinar la tabla de verdad para una compuerta AND (pin 0),
compuerta OR (pin 1) y compuerta XOR (pin 2) mediante secuencias if
else.
• SENTENCIA FOR
• La función for() se usa para repetir un bloque de estados encerrados
entre llaves. Generalmente se utiliza un contador para incrementar y
terminar el bucle. Esta función es útil para cualquier operación
repetitiva, y se usa a menudo en combinación con arreglos para
operar en los datos / pines. Se usa de la siguiente manera:
• for (inicialización; condición; incremento) {
• // declaración (s);
•}
• Para ello necesitaremos tres cosas:
• El índice, es una variable que irá almacenando el número de
repeticiones del bucle.
• Una condición que cuando se cumpla, haga terminar el bucle y
que el resto de programa siga ejecutándose a continuación.
• El incremento que modificará el índice en cada repetición del
bucle.
• Ejercicio. Realizar la suma desde 0 hasta un valor n mediante la
secuencia for.
• SENTENCIA WHILE
• La sentencia, o grupo de sentencias o instrucciones se ejecutan mientras la
evaluación de la expresión sea verdadera.

• while( condición ){ // mientras la condición sea "true o 1"

• // instrucción 1
• // instrucción 2
• //.
• //.
• // instrucción n
• }
• La condición escrita dentro del paréntesis sigue teniendo las mismas
condiciones que la sentencia de control «if»
• Ejercicio. Realizar un programa en Arduino que use la sentencia while,
de tal forma que mande un dato serial mientras la variable x sea
menor a 50. El valor de la variable x se inicializa en 0 y se incrementa
dentro del while. Poner un retardo de 1 segundo entre cada
incremento. Si el valor de x es par, encender un led conectado al pin
5.
• SENTENCIA DO-WHILE
• El bucle do funciona exactamente igual que el bucle while, con la
excepción de que la condición es evaluada después de ejecutar las
instrucciones escritas dentro de las llaves. Esto hace que las
instrucciones siempre sean ejecutadas como mínimo una vez, aun
cuando la condición sea falsa. La sintaxis es de la siguiente forma:
• do {
• //Instrucciones que se repetirán mientras la condición sea cierta –
true –
• } while (condición)
• SENTENCIA SWITCH-CASE
• Al igual que las instrucciones if, switch ... case controla el flujo del
programa permitiendo que los programas especifiquen un código diferente
que debe ser ejecutado en distintas condiciones. En particular, una
sentencia switch compara el valor de una variable con los valores
especificados en las instrucciones case. Cuando se encuentra una sentencia
case cuyo valor coincide con el de la variable, el código de esa declaración
case se ejecuta.
• La palabra reservada break interrumpe la sentencia switch, y se usa
normalmente al final de cada declaración case. Sin una declaración de
interrupción, la sentencia switch continuará la ejecución de las siguientes
expresiones hasta que se alcanza una interrupción o hasta el final de la
sentencia switch.
Sintaxis
switch (var)
{
case label
// instrucciones
break;

case label:
// instrucciones
break;

default:
// instrucciones
break;
}

Parametros

var: la variable cuyo valor es comparado en los distintos

case.

label: el valor a comparar con la variable

• Ejercicio. Realizar un programa en Arduino que use la sentencia do-
while, de tal forma que mande un dato serial mientras la variable x
sea menor a 50. El valor de la variable x se inicializa en 0 y se
incrementa dentro del do-while. Poner un retardo de 1 segundo entre
cada incremento. Si el valor de x es impar, encender un led conectado
al pin 5.
• Ejercicio. Obtener un valor aleatorio entre 1 y 15 y enviar por el
puerto serial el valor del número obtenido. Utilizar la sentencia switch

• Random(max): Se obtiene un numero “aleatorio” desde 0

hasta max.
• Random(min, max): Se obtiene un numero “aleatorio” desde
min hasta max

• Se debe de enviar “El numero aleatorio es ” Seguido del número que

se generó aleatoriamente.
• Ejercicio. Realizar la secuencia de apagado y encendido de 8 leds
conectados al pin 0-7. La secuencia será de izquierda a derecha y
posteriormente de derecha a izquierda cada 50ms, mediante la
secuencia for.
ENTRADAS ANALÓGICAS
• Una señal analógica es una magnitud que puede tomar cualquier
valor dentro de un intervalo –Vcc y + Vcc. Por ejemplo, una señal
analógica de tensión entre 0V y 5V podría valer 2,72V, o cualquier
otro valor con cualquier número de decimales. Por contra,
recordemos que una señal digital de tensión teórica únicamente
podía registrar dos valores (en el ejemplo, 0V o 5V).
• Las entradas analógicas son más escasas, más lentas y más caras que
las entradas digitales.
• En el caso de Arduino uno disponemos de un número variable de
entradas analógicas, que en el caso de Arduino Uno y Mini Pro son 6,
y en el Arduino Mega son 16.

• Un ADC es un dispositivo que convierte una medición analógica en

una medición digital codificada con un número N de bits.
• en realidad no medimos el valor analógico con todos sus decimales,
sino que lo “clasificamos” dentro de 2^N niveles, que definen 2^N-1
intervalos. El ancho de este intervalo medido en mV es la precisión de
la señal. Cuanto mayor sea el número de bits, mayor será el número
de intervalos, menor será el ancho del intervalo, y por tanto mejor la
precisión de la medición.
• En el caso de Arduino Uno, Mini Pro, y Mega, las entradas analógicas
disponen de 10 bits de resolución, lo que proporciona 1024 niveles
digitales, lo que a 5V supone una precisión de la medición de +-
2,44mV.
• Arduino Due tiene una resolución de 12bits, 4096 niveles digitales, lo
que supone una precisión de 0,61 mV.
• Un sistema alimentado entre 0V y 5V, que mide una señal analógica
de tensión entre 0V a 5V. En este caso, con un ADC de 10 bit tenemos
una precisión de 4,88mV
• REFERENCIA DE TENSIÓN ANALÓGICA (AREF)

• El valor de la referencia se cambia con la función AnalogRef, y los valores

posibles son:

• DEFAULT: Valor por defecto, correspondiente con Vcc (5V o 3.3V, según modelos)
• INTERNAL: Corresponde a 1.1V (en Atmega 168 y 328)
• EXTERNAL: Voltaje aplicado de forma externa en el pin Vref (siempre entre 0 y Vcc
• INTERNAL1V1 y INTERNAL2V56, correspondientes a 1.1V y 2.56V (sólo en Mega)
• CONEXIÓN DE ENTRADAS ANALÓGICAS EN ARDUINO
• Si se requiere medir una señal analógica entre 0 y 5V se emplea una
conexión similar a la lectura digital
const int sensorPin = A0; // seleccionar la entrada para el sensor const int sensorPin = A0; // seleccionar la entrada para el sensor
int sensorValue; // variable que almacena el valor raw (0 a 1023) int sensorValue; // variable que almacena el valor raw (0 a 1023)
void setup() float value; // variable que almacena el voltaje (0.0 a 5.0)
{ void setup() {
[Link](9600); [Link](9600);
} }
void loop() { void loop() {
sensorValue = analogRead(sensorPin); // realizar la lectura sensorValue = analogRead(sensorPin); // realizar la lectura
//mandar mensaje a puerto serie en función del valor leido value = fmap(sensorValue, 0, 1023, 0.0, 5.0); // cambiar escala a 0.0 - 5.0
if (sensorValue > 512) { [Link](value); // mostrar el valor por serial
[Link]("Mayor que 2,5V"); delay(1000);
} }
else{ // cambio de escala entre floats
[Link]("Menor que 2,5V"); float fmap(float x, float in_min, float in_max, float out_min, float out_max){
} return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
delay(1000); }
}
• LECTURAS MAYORES A 12V
• Si es necesario medir una entrada analógica con un voltaje superior a
5V, es necesario realizar un circuito para adaptar el voltaje. Por
ejemplo
TIMERS o TEMPORIZADORES
• Los microcontroladores tienen la capacidad de trabajar con tiempos
con gran precisión.
• El periférico que realiza el conteo de tiempo se denomina TIMER.
•
• Un timer no es más que un contador. Es como un reloj que se usa
para medir eventos temporales. Se configura a través de unos
registros especiales y se puede elegir, entre otras cosas, su modo de
funcionamiento.
• Señales digitales
• Las señales digitales son aquellas que solo pueden tener un conjunto
finito de valores. Ya pueden ser 2 o 64 posibles estados, pero siempre
una cantidad finita.
• Una señal digital puede tener más de dos estados posibles
• Señales periódicas
• Una señal periódica es una señal que se repite a una frecuencia y a
intervalos determinados.
 • Señal PWM
• El término PWM proviene del inglés Pulse Width Modulation que
significa modulación por ancho de pulsos. Una señal PWM es una
señal digital similar al tren de pulsos.
• La principal diferencia con el tren de pulsos es que en la señal PWM,
es posible variar el tiempo que la señal se mantiene en estado alto,
pero siempre manteniendo el periodo constante, tal y como se
muestra en la imagen siguiente.

El periodo y la frecuencia son

constantes. Lo que varía es el tiempo
que está en estado alto (HIGH) y bajo
(LOW).
• Pueden utilizarse para controlar un servomotor mediante señales
pulsantes con diferentes tiempos en alto.
• Sirven para emular una salida analógica.
• Es muy empleada en algunas fuentes de alimentación en la etapa de
regulación.
• El ciclo de trabajo o duty cycle de la señal es uno de los conceptos
más importantes de una señal PWM. Este se representa mediante la
letra D y se define como la razón entre el tiempo en estado alto (TON)
y el periodo de la señal (T):

𝑇𝑂𝑁
• 𝐷= ∗ 100 %
𝑇
• El ciclo de trabajo permite controlar el voltaje promedio de la señal es
decir, variar el voltaje de salida. Podrías cambiar el voltaje de salida de
5V a 3,75V por ejemplo. Este parámetro es fundamental cuando la
señal PWM se emplea como conversor digital-analógico.

• El voltaje promedio se calcula

mediante la siguiente expresión:

𝐷
• 𝑉𝑝𝑟𝑜𝑚 = 𝑉𝐻 − 𝑉𝐿 ∗
100
• Como en las placas Arduino el voltaje en estado bajo es normalmente
0V, la expresión se simplifica de la siguiente manera:
• SEÑALES PWM CON ARDUINO
• Las placas de Arduino o ESP8266 ya están adaptadas para poder
generar una señal PWM con Arduino de una forma muy sencilla
utilizando la función analogWrite().
• Arduino permite generar señales PWM en todos los pines marcados
con el símbolo ~.
• Para generar una señal PWM con Arduino utilizando la función
analogWrite(), el procesador emplea un recurso llamado
temporizador o contador de 8 bits (en inglés timer o counter), un
comparador y un valor que representa el ciclo útil de la señal a
generar.

• Un temporizador o contador de 8 bits no es más que un entero cuyo

valor se va incrementando de 0 a 255 y una vez alcanza ese valor
regresa a 0 para recomenzar el ciclo. Se incrementa hasta 255, ya que
este es el máximo valor que se puede obtener con 8 bits.
• El comparador cuenta con dos entradas y una salida. Este es el encargado
de generar la señal PWM con Arduino utilizando el contador y el valor que
representa al ciclo útil.

• Para generar la señal PWM con Arduino, el comparador mantiene su salida

en estado alto (HIGH) mientras el valor del temporizador sea menor que el
del ciclo útil. Una vez el valor del contador supera el valor del ciclo útil, la
salida pasa a estado bajo (LOW).
• FUNCIÓN AnalogWrite
• Esta función admite dos parámetros:

• analogWrite(pin, valor)

• Donde:
• pin: es el pin de Arduino por donde queremos sacar la señal. Tiene que estar marcado con el
símbolo ~.
• valor: es el ciclo de trabajo. Puede tomar valores entre 0 (apagado 0V) y 255 (encendido 5V).
• El segundo parámetro, ciclo de trabajo, puede tomar valores entre 0 y 255. Eso
significa que si pasas a la función 0, obtendrás 0V que equivale a un ciclo de
trabajo del 0%. Si pones 178, obtendrás un voltaje promedio de 3,5V que
equivale a un ciclo de trabajo del 70%.
• Ejemplo. Controlar la intensidad de luz que le llega a un led
• SERVOMOTOR
• Un servomotor es un tipo especial de motor que permite controlar la
posición del eje en un momento dado. Esta diseñado para moverse
determinada cantidad de grados y luego mantenerse fijo en una
posición.
• El ángulo de giro, en este caso nos permite hacer
un barrido entre -90° y 90°. Lo que viene a ser
un ángulo de giro de 180°.
• Funcionamiento de un servomotor
• Los servomotores poseen tres cables, a diferencia de los motores
comunes que sólo tienen dos. Estos tres cables casi siempre tienen
los mismos colores, por lo que son fácilmente reconocibles.
• Las señales de PWM requeridas para que el circuito de control
electrónico son similares para la mayoría de los modelos de servo.
Esta señal tiene la forma de una onda cuadrada. Dependiendo del
ancho del pulso, el motor adoptará una posición fija.
• SG90 9 g Micro Servo

• Position "0" (1.5 ms pulse) is middle, "90" (~2 ms pulse) is all the way
to the left. ms pulse) is middle, "90" (~2 ms pulse) is all the way to the
right, " the left.
• CONEXIÓN CON ARDUINO
• Se utiliza la librería Servo, la cual está incluida por defecto en la
interfaz de Arduino.

• #include <Servo.h>

• Servo myservo; // create servo object to control a servo

• Una vez creada la instancia del servo, tenemos que incluir una línea en la
función setup() para informar a C que vamos a conectar ese objeto
abstracto que todavía es servo a un pin físico del Arduino para controlarlo.
En nuestro caso el pin 9:

• void setup() {
• [Link](9); // attaches the servo on pin 9 to the servo object
• }
• Una vez cumplido el trámite para gobernar la posición del servo recurrimos
a

• [Link]( angulo);
• Ejemplo. Hacer un barrido de 0° a 180° en Arduino.
• #include <Servo.h>
• Servo myservo; // crea el objeto servo
• int pos = 0; // posicion del servo
• void setup() {
• [Link](9); // vincula el servo al pin digital 9
• }
• void loop() {
• //varia la posicion de 0 a 180, con esperas de 15ms
• for (pos = 0; pos <= 180; pos += 1)
• {
• [Link](pos);
• delay(15);
• }