INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y
ELÉCTRICA
(ESIME)
MATERIA: MÁQUINAS ELÉCTRICAS I
Equipo 8/9
INTEGRANTES:
ARTEAGA HERNÁNDEZ FERNANDO
GARCÍA CORONA LUDWIG ALEJANDRO
PÉREZ SAN LÁZARO ALEJANDRO
VALENCIA RODRÍGUEZ MARISOL ITZEL
GRUPO:5AM3
PROFESOR: FRANCO GUZMÁN LUIS FERNANDO
Contenido
OBJETIVO....................................................................................................................................... 2
MARCO TEÓRICO ......................................................................................................................... 2
CONSTRUCCIÓN PLACA ARDUINO ..................................................................................... 2
Características técnicas del Arduino Uno. ............................................................................... 3
IDE ARDUINO............................................................................................................................ 4
RESISTENCIA PULL-UP ........................................................................................................... 5
RESISTENCIA PULL-DOWN ................................................................................................... 6
COMUNICACIÓN SERIAL ....................................................................................................... 6
MODULACIÓN DE ANCHO DE PULSO (PWM).................................................................... 7
MATERIAL ..................................................................................................................................... 8
DESARROLLO EXPERIMENTAL................................................................................................ 8
PARTE 1. Configuración de salida digital: Intermitencia-“Hola mundo” .................................. 8
PARTE 2. Configuración de una entrada digital: energizar un led mediante una acción N.A. y
una acción N.C. .......................................................................................................................... 14
PARTE 3. Lectura de una entrada analógica: Lectura en pantalla del valor de voltaje de entrada
en un pin analógico. ................................................................................................................... 18
PARTE 4. Salida analógica tipo PWM: Control de la intensidad luminosa de un LED ........... 22
CUESTIONARIO .......................................................................................................................... 27
OBSERVACIONES Y CONCLUSIONES ................................................................................... 28
OBSERVACIONES................................................................................................................... 28
CONCLUSIONES ..................................................................................................................... 28
REFERENCIAS ............................................................................................................................. 29
ANEXOS ....................................................................................................................................... 31
1
OBJETIVO
Identificar el ambiente de programación del Arduino IDE, así como el protocolo para cargar
programas a la tarjeta de desarrollo, analizar los módulos internos con los que cuenta la tarjeta
Arduino/Genuino Uno, y desarrollar un programa básico para probar y reconocer e correcto
funcionamiento de la tarjeta con los circuitos propuestos.
MARCO TEÓRICO
CONSTRUCCIÓN PLACA ARDUINO
Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un
entorno de desarrollo, diseñadas para facilitar el uso de la electrónica en proyectos
multidisciplinarios.
La parte del hardware consiste en una placa con un microcontrolador ATmega338P para el caso
del Arduino/Genuino Uno, es utilizado por su sencillez y bajo costo que permiten el desarrollo de
múltiples diseños. Su software consiste en un entorno de desarrollo que implementa el lenguaje de
programación Processing/Writing.
Esta placa cuenta con 14 pines de entrada/salida digital, de estos 14 pines 6 pueden ser usados
como salidas PWM , 6 entradas analógicas y un oscilador de cuarzo a 16MHz.
Las partes del Arduino/Genuino Uno son:
Ilustración 1 Partes del Arduino/Genuino Uno
1. Conector USB: Cada placa Arduino necesita una forma de estar alimentado eléctricamente.
Esta puede ser alimentado desde un cable USB que viene de su ordenador o un cable de
corriente eléctrica con su respectivo adaptador. La conexión USB es también cómo va a
cargar código en su placa Arduino.
2
2. Botón de reset: Presionando este botón se conectará temporalmente el pin de reset a tierra
y reinicie cualquier código que se carga en el Arduino. Esto puede ser muy útil si el código
no se repite, pero quiere probarlo varias veces.
3. Pines digitales y PWM (entradas y salidas):
Digitales: Son los pines digitales (del 0 al 13). Estos pines se pueden utilizar tanto para la
entrada digital (como decir, si se oprime un botón) y salida digital (como encender un LED).
PWM: Estos pines actúan como pines digitales normales, pero también se pueden usar para
algo llamado Modulación por ancho de pulsos (PWM, por sus siglas en Ingles).Para
identificarlos estos pines tienen una tilde a un costado del número de pin.
4. Indicador LED de alimentación: Este LED debe encenderse cada vez que conecte la placa
Arduino a una toma eléctrica. Si esta luz no se enciende, hay una buena probabilidad de
que algo anda mal.
5. LED naranja conectado al Pin 13, puede considerarse como un led de prueba.
6. ATmega 16U2 encargado de la comunicación con el PC.
7. LEDs RX Tx: TX es la abreviatura de transmisión, RX es la abreviatura de recibir. Estas
marcas aparecen un poco en la electrónica para indicar los pasadores responsables de la
comunicación en serie. En nuestro caso, hay dos lugares en la Arduino UNO donde
aparecen TX y RX - una vez por pines digitales 0 y 1, y por segunda vez junto a los
indicadores LED de TX y RX (12). Estos LEDs nos darán algunas buenas indicaciones
visuales siempre nuestro Arduino está recibiendo o transmitiendo datos (como cuando nos
estamos cargando un nuevo programa en el tablero).
8. Puerto ICSP para programación serial.
9. Microcontrolador ATmega 328P: Lo negro con todas las patas de metal es un circuito
integrado (IC, por sus siglas en Ingles). Piense en ello como el cerebro de nuestro Arduino.
La principal IC en el Arduino es ligeramente diferente del tipo de placa a placa tipo, pero
es por lo general de la línea de ATmega de CI de la empresa ATMEL. Esto puede ser
importante, ya que puede necesitar para saber el tipo de IC (junto con su tipo de tarjeta)
antes de cargar un nuevo programa desde el software de Arduino.
10. Cristal de cuarzo de 16MHz.
11. Regulador de voltaje: Esto no es realmente algo que se puede (o debe) interactuar con el
Arduino. Pero es potencialmente útil para saber que está ahí y para qué sirve. El regulador
de voltaje hace exactamente lo que dice - que controla la cantidad de tensión que se deja en
la placa Arduino. Piense en ello como una especie de guardián; se dará la espalda a una
tensión adicional que podría dañar el circuito. Por supuesto, tiene sus límites, por lo que no
conecta tu Arduino a nada superior a 20 voltios.
12. Conector hembra 2.1mm con centro positivo: La tensión recomendada para la mayoría de
los modelos de Arduino es de entre 6 y 12 voltios.
13. Pines de voltaje y Tierra: Son los suministros pin 5V 5 voltios de energía, y los suministros
de pin 3.3V 3.3 voltios de potencia.
14. Entradas analógicas:El área de pines en el marco del 'analógica' etiqueta (A0 a A5) son
analógicas. Estos pines pueden leer la señal de un sensor analógico (como un sensor de
temperatura) y convertirlo en un valor digital que podemos leer.
Características técnicas del Arduino Uno.
Microcontrolador: ATmega328
Voltaje: 5V
3
Voltaje entrada (recomendado): 7-12V
Voltaje entrada (limites): 20V
Digital I/O Pins: 14 (de los cuales 6 son salida PWM)
Entradas Analógicas: 6
Corriente DC por I/O Pin: 40 mA
Corriente DC para 3.3V Pin: 50 mA
Flash Memory: 32 KB (ATmega328) de los cuales 0.5 KB son utilizados para el arranque
SRAM: 2 KB (ATmega328)
EEPROM: 1 KB (ATmega328)
Velocidad del reloj (Clock Speed): 16 MHz
IDE ARDUINO
El término IDE viene de las siglas en inglés “Integrated Development Environment”, lo que es el
Entorno de Desarrollo Integrado. Este consiste en un editor de código, un compilador, un depurador
y un constructor de interfaz gráfica, es decir, es un programa de aplicación y será una herramienta
de trabajo para la práctica.
Algunas ventajas del IDE son que tiene un lenguaje simple en C/C++, o que nos permite programar
directamente el hardware. Para configurar el IDE de desarrollo, se ejecuta el programa Arduino.
En el IDE de desarrollo de Arduino, se selecciona el tipo de dispositivo (Board). Para ello, se pulsas
en el menú "Tools" - "Board" y se selecciona "Arduino Uno" (o el que se haya adquirido):
Ilustración 2 Pantalla y menú herramientas
El siguiente paso es muy importante, ya que debemos estar en el puerto que corresponde. Para esto,
se selecciona el puerto serie asignado al controlador de Arduino (en el caso de la imagen es COM3),
para ello accederemos al menú "Tools" - "Serial Port" - "COM3":
4
Ilustración 3 Elección de COM
Arduino guarda los archivos de programa con la extensión “.ino” y a estos se les llaman Sketches.
También, el Arduino IDE puede leer los archivos de las versiones anteriores con extensión “.pde”,
ósea los reconoce sin problemas.
Ilustración 4 Vista general del software Arduino
RESISTENCIA PULL-UP
Como su nombre indica esta resistencia tiene la función de “jalar” hacia “arriba”, lo que significa
que polariza el voltaje hacia el voltaje de fuente (VDD). De esta forma cuando el pulsador está
abierto o en reposo, el voltaje en la entrada del Arduino siempre será de +5V.
Las entradas del Arduino son de alta impedancia, por lo que habrá una pequeña corriente y el
voltaje que “cae” en la resistencia pull-up es mínimo. Así, se tiene casi el mismo voltaje de fuente
en la entrada del Arduino.
Cuando el pulsador es presionado, la corriente circula por la resistencia y luego por el pulsador, de
esta forma tenemos que el voltaje en la entrada del Arduino es Tierra o 0V. Entonces en la
configuración pull-up cuando el pulsador está en reposo el Arduino lee 1 y cuando presionamos
leerá 0.
5
Ilustración 5 Resistencia Pull-Up
RESISTENCIA PULL-DOWN
De forma similar la resistencia Pull-Down “jala” el voltaje hacia “abajo” o “0V”. Cuando el
pulsador está en reposo, el voltaje en la entrada del Arduino será 0V. Cuando presionamos el
pulsador la corriente fluye de +5V por el pulsador hacia la resistencia y termina en 0V, de esa
forma tenemos +5V en la entrada del Arduino. Entonces en la configuración Pull-Down cuando el
pulsador está en reposo el Arduino lee 0 y cuando presionamos leerá 1.
Ilustración 6 Resistencias Pull-Down
COMUNICACIÓN SERIAL
Definiremos la comunicación serie como una “interfaz de comunicación de datos digitales que nos
permite establecer transferencia de información entre varios dispositivos”. Esto nos va a permitir
interactuar con nuestro Arduino, recibiendo información y enviándosela nosotros cuando lo
necesitemos. Otra cosa que nos será muy útil de esta comunicación, es que podremos darle las
órdenes, previamente programadas, que queramos.
Arduino IDE nos proporciona una herramienta que nos permite enviar y visualizar los datos que se
manejan a través del puerto Serie. Dicha herramienta se conoce como Monitor Serial y se puede
encontrar en el menú de herramientas, en la opción «Monitor Serial». Es la forma más simple que
existe para establecer la comunicación serial con Arduino
6
Ilustración 7 Monitor serie
A través de esta ventana se puede enviar o recibir información utilizando el puerto serie. Nótese
que para poder abrir esta ventana es necesario que tengamos nuestra placa Arduino conectada a
nuestra PC mediante USB.
Para iniciar la comunicación serial con Arduino utilizando el Monitor Serial debemos establecer
algunos comandos en el Arduino IDE y luego subirlos al microcontrolador.
El código es el siguiente:
void setup(){
Serial.begin(9600);
4}
5
6 void loop(){
7 Serial.println('1');
8 delay(1000);
}
El 9600 indica el baud rate, o la cantidad de baudios que manejará el puerto serie. Se define baudio
como una unidad de medida, usada en telecomunicaciones, que representa el número de símbolos
por segundo en un medio de transmisión ya sea analógico o digital.
Cuando usamos println le estamos diciendo al microcontrolador que tendrá que imprimir un
carácter a través del puerto serie.
MODULACIÓN DE ANCHO DE PULSO (PWM)
La modulación de ancho de pulso PWM “Pulse Width Modulation” es una técnica donde se
modifica el ciclo de trabajo (conocido como D) de una señal periódica ya sea senoidal o cuadrada.
Se usan para controlar la cantidad de energía que se envía a una carga, como para controlar la
velocidad de motores, o para transmitir información. El ciclo de trabajo se expresa
matemáticamente como el ancho de pulso por el periodo de la función. Recordemos que el ancho
de pulso es el tiempo en el que la función es positiva.
Los pulsos son de amplitud constante, pero varían su duración (ancho del pulso / ciclo de vida útil)
proporcionalmente a los valores de la información en los instantes de muestreo. La modulación de
ancho de pulso PWM, a veces también se nombra modulación de duración de pulso y se denota
como PDM.
7
A continuación, tenemos algunos ejemplos aplicados a la velocidad de motores. En las
ilustraciones, tenemos los valores D=50 y D=20. Significa que el motor irá a un 50% y 20% de la
velocidad máxima, respectivamente.
Ilustración 8 Ciclo de trabajo al 50%
Ilustración 9 Ciclo de trabajo al 20%
MATERIAL
o 1 placa ARDUINO UNO con chip ATmega328P DIP28 (28 pines)
o Fuente de alimentación de 9 V CD con conector de 2.1 mm macho con centro positivo para
la placa
o 1 protoboard
o 1 jgo Cables dupont (jumpers) macho-macho preferente
o 1 jgo Cables dupont (jumpers) macho-hembra preferente
o 1 LED de 5 mm, (color a elegir)
o 1 Resistencia de 220 Ω ¼ watts
o 2 Resistencia de 10 kΩ ¼ watts
o 2 Push-botton NA de 2 o 4 pines
o 1 Potenciómetro de 10 kΩ, 1 vuelta
DESARROLLO EXPERIMENTAL
PARTE 1. Configuración de salida digital: Intermitencia-“Hola mundo”
1. Para este primer circuito se desarrollara un programa que encienda un LED 400ms y se
apague 400ms.Para eso necesitaremos una placa arduino y un LED.
8
Ilustración 10 Diagrama de conexión del circuito 1
Como se puede ver en la imagen el led se conectara directamente al ARDUINO en el Pin
13 va la termina positivas y GND la negativa.
Ilustración 11 Esquema de conexión del circuito 1
2. Para continuar desarrollaremos el diagrama de flujo que describirá el funcionamiento del
programa:
9
Ilustración 12 Diagrama de flujo circuito1
3. Una vez que desarrollamos el diagrama procederemos a la programación dentro de un
Sketch en el software ARDUINO IDE.
//5AM3-Hola Mundo.
//García Corona Ludwig Alejandro.
//Arteaga Hernández Fernando.
//Pérez Sanlázaro Alejandro.
//Valencia Rodríguez Itzel Marisol.
void setup() { //Configuración de Hardware
pinMode(13,OUTPUT); //Declaración como salida de pin 13
}
void loop() { //Inicio de programa principal
10
digitalWrite(13,HIGH); //Colocar en 1 el pin 13
delay(400); //Retraso de 400ms
digitalWrite(13,LOW); //Colocar en 0 el pin 13
delay(400); //Retraso de 400ms
}
Ilustración 13 Circuito 1 armado y funcionando
Cuando conectemos el LED podemos observar que se enciende sin quemarse, esto se debe
a que internamente el ARDUINO en este pin cuenta con una resistencia.
4. Como último paso de la parte 1 modificaremos el circuito. Necesitaremos dos jumpers, un
led, placa ARDUINO UNO y una resistencia de 220Ω.
Se conectara la salida del Pin 2 a un resistor y a un LED, se programara para encender
500ms y apagarse por 500ms, después se encenderá 50 ms y finalmente se apagara 50ms,
sin olvidar conectar la GND del ARDUINO a la GND del proto.
Ilustración 14 Diagrama de conexión del LED pin 2
A la salida del Pin 2 se conectó una resistencia con un valor de 220Ω como protección.
11
Ilustración 15 Esquema de conexión del LED al pin 2
5. Procederemos a realizar el diagrama de flujo del funcionamiento.
Ilustración 16 Diagrama de flujo del circuito 1.1
12
6. Del programa anterior se modificara el Pin de salida, el tiempo de encendido y apagado,
quedando el código de la siguiente manera.
//5AM3-Hola Mundo 2.
//García Corona Ludwig Alejandro.
//Arteaga Hernández Fernando.
//Pérez Sanlázaro Alejandro.
//Valencia Rodríguez Itzel Marisol.
const int ledPin = 2; //Declaración de variable para puerto
void setup() { //Configuración de hardware
pinMode(ledPin,OUTPUT); //Declaración como salida de ledPin
}
void loop() { //Inicio de programa principal
digitalWrite(ledPin,HIGH); //Colocar en 1 ledPin
delay(500); //Retraso de 500ms
digitalWrite(ledPin,LOW); //Colocar en 0 ledPin
delay(500); //Retraso de 500ms
digitalWrite(ledPin,HIGH); //Colocar en 1 ledPin
delay(50); //Retraso de 50ms
digitalWrite(ledPin,LOW); //Colocar en 0 ledPin
delay(50); //Retraso de 50ms
}
Ilustración 17 Circuito 1.1 armado y funcionando
13
PARTE 2. Configuración de una entrada digital: energizar un led mediante una acción N.A.
y una acción N.C.
1. Ahora, se energizará el led mediante las acciones normalmente abierto (Pull-Down) y
normalmente cerrado (Pull-Up).
a) Para la acción N.A., se diseñará un circuito con configuración Pull-Down con un
interruptor y una resistencia de 10 kΩ conectada al pin 2 de la placa, y el pin 11 en
serie con un led y una resistencia.
Ilustración 18 Diagrama de conexión circuito 2.1
Ilustración 19 Esquema de conexión circuito 2.1
b) Para la acción N.C., se diseñará un circuito con configuración Pull-Up con un
interruptor y una resistencia de 10 kΩ conectada al pin 2 de la placa, se conectará
el pin 11 en serie con un led y una resistencia.
Ilustración 20 Diagrama de conexión circuito 2.2
14
Ilustración 21 Esquema de conexión circuito 2.2
2. Para continuar desarrollaremos el diagrama de flujo que describirá el funcionamiento del
programa:
15
3. Una vez que desarrollamos el diagrama procederemos a la programación dentro de un
Sketch en el software ARDUINO IDE.
//5AM3-I/O digitales
//Arteaga Hernández Fernando
//García Corona Ludwig Alejandro
//Pérez Sanlázaro Alejandro
//Valencia Rodríguez Itzel Marisol
const int buttonPin = 11; //Declaración de variable para puerto
const int ledPin = 2; //Declaración de variable para puerto
boolean buttonState = 0; //Declaración de variable para puerto
void setup() { //Configuración de hardware
pinMode(buttonPin,INPUT); //Configuración de Pin como entrada
pinMode(ledPin,OUTPUT); //Configuración de Pin como salida
}
void loop() { //Inicio de programa principal
buttonState = digitalRead(buttonPin); //Lectura de estado de buttonPin
if(buttonState==HIGH){ //Comparación del estado de
buttonPin
digitalWrite(ledPin,HIGH); //Colocar en 1 ledPin
}
else{ //Instrucción por defecto
digitalWrite(ledPin,LOW); //Colocar en 0 ledPin
delay(1000); //Retraso de 1s
}
}
a) Como se puede apreciar en la ilustración, al presionar el interruptor el led se enciende ya que
deja de estar en estado de reposo. Por lo tanto, se cumplió la acción N.A.
b) En las ilustraciones se muestra cuando el pin está encendido y en reposo. Al momento de
presionar el interruptor, observamos que el led se apaga. Por lo tanto, se cumplió la acción N.C.
16
4. Por último, se observará en el monitor serie el estado que guarda el led. Para esto, se
modificará el programa de acción N.C., para esto se realizó el siguiente diagrama de flujo:
17
5. Usando la librería Serial() y el diagrama de flujo previo, se obtuvo el siguiente programa:
//5AM3-Monitor Serial
//Arteaga Hernández Fernando
//García Corona Ludwig Alejandro
//Pérez Sanlázaro Alejandro
//Valencia Rodríguez Itzel Marisol
const int buttonPin = 11; //Declaración de variable para puerto
const int ledPin = 2; //Declaración de variable para puerto
boolean buttonState = 0; //Declaración de variable para puerto
void setup() { //Configuración de hardware
pinMode(buttonPin,INPUT); //Declaración de Pin como entrada
pinMode(ledPin,OUTPUT); //Declaración de Pin como salida
Serial.begin(9600); //Inicialización de puerto serial a 9600 baud
}
void loop() { //Inicio de programa principal
buttonState = digitalRead(buttonPin); //Lectura de estado de buttonPin
if(buttonState==HIGH){ //Comparación de estado de buttonPin
digitalWrite(ledPin,HIGH); //Colocar en 1 ledPin
Serial.println("ON"); //Imprimir en monitor
}
else{ //Instrucciones por defecto
digitalWrite(ledPin,LOW); //Colocar en 0 ledPin
Serial.println("OFF"); //Imprimir en monitor
}
delay(50); //Retraso de 50 ms
}
PARTE 3. Lectura de una entrada analógica: Lectura en pantalla del valor de voltaje de
entrada en un pin analógico.
1. El circuito que se diseñara será para la lectura de un potenciómetro, la cual podrá observarse
a partir del monitor serie, con ayuda del pin PWM del ARDUINO. Para esto necesitamos
una placa ARDUINO UNO, un potenciómetro de 10KΩ y 3 jumpers.
2. Conectaremos el pinA2 a la terminal variable (central) del potenciómetro, una de las
terminales del potenciómetro se conectara a Vcc y otro a GND, el circuito se alimentara
con el pin del ARDUINO que suministra 5V y se deberá conectar la GND del ARDUINO
al proto.
18
Ilustración 22Diagrama de conexión del circuito 4 con potenciómetro
Ilustración 23 Esquema de conexión del circuito 4 con potenciómetro
3. A continuación se desarrollara el diagrama de flujo del funcionamiento:
19
Ilustración 24 Diagrama de flujo del circuito 4
4. A partir del diagrama de flujo obtuvimos el siguiente programa y a continuación se muestra
el circuito armado y funcionando junto con una imagen del puerto serie.
//5AM3-Conversión analógico Digital
//García Corona Ludwig Alejandro
//Arteaga Hernández Fernando
//Pérez Sanlázaro Alejandro
//Valencia Rodríguez Itzel
const int potPin = A2; //Declaración de variable para puerto
20
int analogValue; //Declaración de variable entera
float voltageValue; //Declaración de variable flotante
int percentage; //Declaración de variable entera
void setup() { //Configuración de hardware
Serial.begin(9600); //Inicilización de puerto serial a 9600
baud
}
void loop() { //Inicio de programa principal
analogValue = analogRead(potPin); //Lectura de valor de potPin
Serial.print(analogValue); //Imprimir en monitor
//percentage = map(analogValue,0,1023,0,5);
voltageValue = mapfloat(analogValue,0,1023,0,5); //Asignación de valor
Serial.print("\t"); //Imprimir en monitor
Serial.print(voltageValue); //Imprimir en monitor
Serial.println(" v"); //Imprimir en monitor
}
float mapfloat(float x,float in_min,float in_max,float out_min,float out_max){
//inicio de función
return(x-in_min)*(out_max-out_min)/(in_max-in_min)+(out_min);
//Retorno de valor acotado y escalado
}
Ilustración 25 Circuito 4 armado y funcionando
Como podemos ver en el monitor serie nos imprime dos valores, siendo el primero la lectura
del valor analógico del potenciómetro que va de 0 a 255 por la conversión. El segundo valor
se refiere al valor proporcional en tensión que se obtiene al variar el potenciómetro.
21
PARTE 4. Salida analógica tipo PWM: Control de la intensidad luminosa de un LED
1. El siguiente circuito controlara la intensidad luminosa de un LED a partir de la lectura de
un potenciómetro con el pin PWM del ARDUINO, además de poder observar en el monitor
serie el valor analógico, el valor PWM y el valor de la tensión que llegara al LED que es
proporcional al valor analógico.
Para esto necesitaremos un potenciómetro de 10 kΩ, 7 jumpers, una placa ARDUINO
UNO, un led y una resistencia de 220Ω.
Ilustración 26 Diagrama de conexión del circuito 4.1
En este caso se utilizarán dos pines para armar el circuito, el pin 9 será el encargado de mandar
la señal para modificar la intensidad del LED y el pin A2 leerá el valor del potenciómetro.
Ilustración 27 Esquema de conexión del circuito 4.1
2. Procederemos a realizar el diagrama de flujo del funcionamiento.
22
Ilustración 28 Diagrama de flujo del circuito 4.1
3. Del diagrama de flujo obtuvimos el siguiente programa.
//5AM3-PWM
//Arteaga Hernández Fernando
//García Corona Ludwig Alejandro
//Pérez Sanlázaro Alejandro
//Valencia Rodríguez Itzel Marisol
const int potPin = A2; //Declaración de variable para puerto
23
const int ledPin = 9; //Declaración de variable para puerto
int analogValue; //Declaración de variable entera
int pwmValue; //Declaración de variable entera
float voltageValue; //Declaración de variable flotante
void setup() { //Configuración de hardware
pinMode(ledPin,OUTPUT); //Configuración de Pin como salida
Serial.begin(9600); //Inicialización de puerto serial a 9600 baud
}
void loop() { //Inicio de programa principal
analogValue = analogRead(potPin); //Lectura de valor de potPin
pwmValue = map(analogValue,0,1023,0,255); //Acotación y escala de valor
voltageValue = mapfloat(analogValue,0,1023,0,5); //Asignación de valor a
voltageValue
analogWrite(ledPin,pwmValue); //Colocar valor de pwm en ledPin
Serial.print(analogValue); //Imprimir en monitor
Serial.print("\t"); //Imprimir en monitor
Serial.print(pwmValue); //Imprimir en monitor
Serial.print("\t"); //Imprimir en monitor
Serial.print(voltageValue); //Imprimir en monitor
Serial.println(" v"); //Imprimir en monitor
}
float mapfloat(float x,float in_min,float in_max,float out_min,float out_max){ //Inicio
de función
return(x-in_min)*(out_max-out_min)/(in_max-in_min)+(out_min);
//Retorno de valor acotado y escalado
}
Ilustración 29 Circuito 4.1 armado y funcionando
Como se puede observar en la imagen la intensidad del LED se modifica respecto a la
posición/valor del potenciómetro.
4. Con ayuda del osciloscopio observaremos como se modifica la onda cuadrada que nos
proporciona el ARDUINO por el pin PWM de las siguientes tensiones, además de agregar
24
los datos pedidos. El osciloscopio se conectara de la parte positiva al pin 9 del ARDUINO
y la parte negativa a GND.
El ciclo de trabajo será calculado a partir de la siguiente formula:
𝐴𝑛𝑐ℎ𝑜 𝑝𝑜𝑠𝑖𝑡𝑖𝑣𝑜
𝐷=
𝑃𝑒𝑟𝑖𝑜𝑑𝑜
Y el voltaje calculado se obtendrá con la siguiente formula:
𝑉 = (𝐷 ) ∗ (5𝑉 )
Se utilizara 5V ya que es la máxima tensión que se le suministrara, y el ciclo de trabajo será
el porcentaje de la modulación de ancho de pulso.
VOLTAJE VOLTAJE PERIODO ANCHO CICLO DE VOLTAJE VALOR
(MULT.) POSITIVO TRABAJO CALCULADO PWM
CALCULADO M.SERIE
0.6 V 2.04ms 200μs 0.099 0.49V 25
1.5V 2.04ms 608μs 0.298 1.49V 76
2.5V 2.04ms 1.02ms 0.5 2.5V 127
3.5V 2.04ms 1.42ms 0.69 3.48V 178
4.5V 2.04ms 1.83ms 0.9 4.52V 229
Ilustración 30 Señal cuadrada obtenida para .06V
25
Ilustración 31 Señal cuadrada obtenida para 1.5V
Ilustración 32 Señal cuadrada obtenida para 2.5V
Ilustración 33 Señal cuadrada obtenida para 3.5V
26
Ilustración 34 Señal cuadrada obtenida para 4.5V
Como podemos ver entre más pequeño sea el valor leído del potenciómetro mayor será el ancho
positivo de la onda, además del valor de la tensión obtenido.
CUESTIONARIO
1. ¿Cómo se estructura un programa en Arduino IDE y qué nombre recibe?
El programa en el IDE tiene el nombre de Sketch, y la estructura tiene mucha similitud con
la programación estructurada básica, es decir, al inicio del programa se desarrolla la
declaración de las variables que se utilizarán en el sketch, después de eso en la sección de
“setup”, se configura el hardware del microcontrolador, en donde se definen el propósito
de los pines configurados, ya sean entradas o salidas digitales o analógicas. Dentro del
“loop”, se escribe el programa principal en el cual vamos a desarrollar las decisiones que
tomará el microcontrolador dependiendo de las circunstancias en las que se desarrolle el
circuito. Y finalmente después del loop encontramos las funciones de usuario, que nos
permiten controlar subrutinas llamadas desde el programa principal, son desarrolladas para
tareas muy específicas.
2. Explique brevemente cuál es la utilidad de las configuraciones Pull-up y Pull-down,
mencione ejemplos prácticos.
Las configuraciones pull-up y pull-down en esencia nos permiten reducir al mínimo las
corrientes parásitas (ruido), que pueden producirse en las entradas digitales de un
dispositivo, con una resistencia pull-up o pull-down, eliminamos las posibilidades de
encontrar falsos positivos al momento de hacer una detección, o al momento de enviar una
señal. La gran mayoría de los circuitos digitales tienen un circuito pull-up o pull-down
dependiendo de el propósito del circuito principal.
3. ¿Qué es una comunicación serie? ¿Qué utilidad puede tener en la solución de proyectos de
control y automatización?
La comunicación serial es un protocolo de transferencia de información en la que se envían
paquetes de datos, un bit a la vez, para que esto se dé, el transmisor y el receptor deben de
27
trabajar a la misma frecuencia, llamada baudaje, que les permite interpretar de forma
correcta los datos intercambiados, es de suma utilidad en los proyectos de control y
automatización debido a que permite monitorear dispositivos, equipos y procesos casi en
un tiempo aproximado al real. Puede mejorar el tiempo de respuesta de algunos
controladores y enviar información más precisa por parte de los transmisores.
4. Describa brevemente ¿Qué es una señal PWM? Y su utilidad en dispositivos electrónicos.
Una señal PWM es un tren de pulsos a altas frecuencias, las cuales pueden ser moduladas
y controladas para enviar pulsos más largos o cortos, en un periodo determinado. Es muy
útil para realizar controles debido a que no es necesario modificar valores directos del
sistema, sino que sólo se modifica la señal que recibe el circuito.
5. ¿Qué elementos se requieren para generar una señal PWM?
La señal PWM requiere de forma estricta un oscilador, éste puede ser el 555, o bien, el
oscilador del microcontrolador (interno o externo), la modulación dependerá directamente
de los componentes del circuito oscilador.
6. ¿Cuál es la importancia del ciclo de trabajo en una señal tipo PWM?
El ciclo de trabajo o duty cycle es el porcentaje en el cual está activa la señal (HIGH), con
respecto a el periodo de la señal, es de gran utilidad ya que permite modular la potencia
entregada a un dispositivo, por ejemplo un led (podemos disminuir o aumentar su intensidad
luminosa) o un motor (podemos disminuir o aumentar su velocidad) entre mayor sea el
porcentaje de el ciclo de trabajo mayor será la potencia suministrada a elemento que
queremos controlar.
7. ¿Cómo emplearía una señal PWM para control de velocidad de un MCDIP?
Ya que la señal pwm funciona activando y desactivando la entrada (en este caso de un
motor), sin disminuir la corriente entregada, al reducir el duty cycle la velocidad del motor
disminuirá, sin embargo la fuerza con la que gira no, el pwm controla la potencia
suministrada por la etapa de potencia y como se vio en la práctica, un potenciómetro sería
muy cómodo para controlar manualmente la velocidad del motor.
OBSERVACIONES Y CONCLUSIONES
OBSERVACIONES
Se debe tener en cuenta que al alimentar un led a partir de un pin del Arduino se debe colocar una
resistencia de 200 y 500 ohmios como protección. El pin 13 no necesita de esta resistencia ya que
internamente ya cuenta con una.
Cada vez que se conecte el Arduino se debe verificar en la parte de “Herramientas”, “Puerto” que
este en el puerto correcto, de lo contrario será imposible cargar un programa al Arduino.
CONCLUSIONES
ARTEAGA HERNÁNDEZ FERNANDO
Una placa de desarrollo como lo es la Arduino UNO es una herramienta muy intuitiva y práctica,
permite implementar circuitos básicos de control, e incluso circuitos más elaborados, con
conocimientos básicos de electrónica por parte del usuario. Los módulos internos con los que
28
cuenta permiten generar señales PWM, hacer lectura de datos analógicos, lectura de datos digitales
y manipular las salidas de la placa para activar circuitos de potencia, ya sea un motor, un relevador
o sistemas más complejos. El entorno de programación es muy intuitivo también, no son necesarios
más que conocimientos básicos de programación estructurada y conocer los comandos específicos
del IDE. Las herramientas con las que cuenta incluyen un monitor serie que permite monitorear el
estado del programa o de la placa en sí.
GARCÍA CORONA LUDWIG ALEJANDRO
La implementación de la placa Arduino UNO es una forma “sencilla” de configurar la etapa de
control de un circuito, con conocimientos básicos de electrónica y programación ya que utiliza una
mezcla de C y Java para el control de motores eléctricos el cual es nuestro objetivo final, utilizando
señales PWM, se aprendió cómo utilizar las entradas analógicas y digitales de la placa, así como
el uso del monitor serial el cual nos permite ver el comportamiento en tiempo real de las transmisión
de datos, aprendimos desde lo más básico para familiarizarnos con la interfaz de programación se
empezó a incursionar en la programación de la etapa de control de circuitos más complejos.
PÉREZ SAN LÁZARO ALEJANDRO
La IDE nos ayuda a programar de una manera sencilla la placa de Arduino. Es necesario conocer
las distintas funciones que nos puede ofrecer el IDE para llevar una correcta ejecución, como saber
configurar pines digitales, temporizar salidas, lecturas de entradas y activaciones de señales. Es
importante checar el que estemos en el puerto correcto y desconectar el puerto USB de la placa al
hacer cualquier modificación en el Sketch. El monitor serie nos ayudará a visualizar los datos que
se manejan a través del puerto Serie.
VALENCIA RODRÍGUEZ ITZEL MARISOL
Arduino es una de las maneras más simples, prácticas y baratas de empezar a desarrollar un
proyecto, o para implementar en un circuito de control. Parte importante de lo que nos proporciona
Arduino es poder generar una señal PWM ya sea sinusoidal o cuadrada además de poder leer
señales analógicas, como al leer el valor de un potenciómetro, eso se podrá realizar gracias al
comando “serial” y el monitor serial. Todo esto puede implementarse para controlar el paro y
arranque de un motor, la activación de un relevador, entre otras cosas.
Otra ventaja de e Arduino es el entorno de programación ya que es muy sencillo de usar y solo se
requieren conocimientos básicos de programación, además de conocer los comandos de la IDE, los
cuales se pueden encontrar directamente en la página de Arduino con un ejemplo de como
utilizarlos.
REFERENCIAS
¿Que es una Señal Modulada por Ancho de Pulso (PWM) y Para Qué es Utilizada? - National
Instruments. (s.f.). Recuperado 8 septiembre, 2019, de
http://digital.ni.com/public.nsf/allkb/AA1BDEA4AA224E3E86257CE400707527
Resistencias PULL-UP. (s.f.). Recuperado 8 septiembre, 2019, de
http://www.myelectronic.mipropia.com/Componentes/LAS%20RESISTENCIAS%20PULL-
UP.pdf
29
Arduino - Tutorial 0: Introducción. (s.f.). Recuperado 8 septiembre, 2019, de
https://www.instructables.com/id/Arduino-Tutorial-0-Introducci%C3%B3n/
Comunicación de Arduino con puerto serie. (2017, 30 octubre). Recuperado 8 septiembre, 2019,
de https://www.luisllamas.es/arduino-puerto-serie/
Antony García González, A. G. G. (2017, 9 noviembre). Comunicación Serial con Arduino -
Panama Hitek. Recuperado 8 septiembre, 2019, de http://panamahitek.com/comunicacion-serial-
con-arduino/
30
ANEXOS
Ilustración 35 Firma parte 1, equipo 8
31
Ilustración 36 Firma parte 2, equipo 8
32
Ilustración 37 Firma parte 3, equipo 8
33
Ilustración 38 Firma parte 4, equipo 8
34
Ilustración 39 Firma parte 1, equipo 9
35
Ilustración 40 Firma parte 2, equipo 9
36
Ilustración 41 Firma parte 3 y 4, equipo 9
37
Ilustración 42 Diagrama de la placa ARDUINO y del ATMega328PU
38
