Paso 6 Grupo 309696 36

Paso 6 – Proyecto final 1
PASO 6 – PROYECTO FINAL
PRESENTADO POR:
KAREN LIZETH VILLAMIL. CODIGO: 1233695732
MANUEL ALEJANDRO RINCON SANCHEZ. CODIGO: 1057577288
JORGE LUIS MANRIQUE. CODIGO:
PRESENTADO A: NESTOR JAVIER RODRIGUEZ
GRUPO: 309696_36
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD
ESCUELA DE CIENCIAS BASICAS, TECNOLOGIA E INGENIERIA
MICROCONTROLADORES Y MICROPROCESADORES
SOGAMOSO BOYACA
2020
CONTENIDO
INTRODUCCIÓN......................................................................................................................3
OBJETIVOS...............................................................................................................................4
General:...................................................................................................................................4
Específicos:.............................................................................................................................4
PASO 6 – PROYEVTO FINAL.................................................................................................5
VIDEO EXPLICATIVO.......................................................................................................12
PASO 1 – FUNDAMENTACION DEL CURSO....................................................................13
VIDEO EXPLICATIVO:......................................................................................................18
PASO 2 – CONTEXTUALIZACIÓN DEL PROYECTO.......................................................18
VÍDEO EXPLICATIVO.......................................................................................................22
PASO 3 – PROPUESTA DEL PROYECTO............................................................................22
PASO 4 – ANALISIS DEL PROYECTO................................................................................25
CONCLUSIONES....................................................................................................................30
BIBLIOGRAFIA......................................................................................................................31
INTRODUCCIÓN
En el presente trabajo se implementaran las distintas tarjetas de desarrollo de hardware libre bajo
parámetros de configuración periféricos y programación de alto nivel para ser aplicados en el
proceso de automatización o control del proyecto.
La presente actividad tiene como propósito emplear una placa Arduino como microcontrolador
para la automatización y control de procesos. El proyecto donde implementaremos esta Tarjeta
de desarrollo GNU es el diseño de una maquina centrifuga, simulada en el programa Proteus y
basada en actividades anteriores donde se hizo uso de motores DC, controlando su velocidad y
tiempo de uso.
Este informe final abarcara todos los temas y experiencias vistos a lo largo del semestre, por lo
que se aplicara el lenguaje de programación de Arduino, diseño de circuito más acorde para la
elaboración de una maquina centrifuga que como bien se debe aclarar es un equipo de
Laboratorio que genera movimientos de rotación, tiene el objetivo de separar los componentes
que constituyen una sustancia.
Por lo anterior se desarrolló el diseño en Proteus, usando placa de Arduino Uno y demás
necesarios para cumplir con los requerimientos indicados, el cual se incluye el funcionamiento
potenciómetros, visualización de mensajes en el LCD referente a los tiempos y la velocidad de la
máquina centrífuga.
Cada integrante del grupo comparte aportes correspondientes al desarrollo del proyecto y al final
se tomara el mejor para presentar como sustentación a la presente actividad.

OBJETIVOS
General:
Desarrollar correctamente el proyecto del paso 6 apropiando los conceptos fundamentales de las
tarjetas de desarrollo de hardware, emplear una placa Arduino como microcontrolador para la
automatización y control de procesos su aplicación en sistemas de automatización, redes o control
y uso de periféricos.
Específicos:
- Investigar el funcionamiento de una maquina centrifuga, y con ello evaluar cuáles son los
componentes electrónicos necesarios para integrar la placa Arduino.
- Aprender el manejo del software de desarrollo Arduino para la implementación de
programas en este sistema basado en micro controlador.
- Analizar, diseñar y simular un circuito que cumpla con los parámetros indicados para la
maquina centrifuga.
- Afianzar los conocimientos en programación bajo la plataforma Arduino, integrándolos
en un diseño de proteus.
- Identificar las ventajas que nos brinda trabajar en Arduino.
- Fomentar el trabajo en equipos, delegando funciones y aportando propuesta.

PASO 6 – PROYEVTO FINAL
METODOLOGIA
¿En qué consiste la actividad?
Se plantea como proyecto a desarrollar en todo el curso el diseño de un sistema de control y
automatización de un laboratorio de Calidad para la empresa Bambo la cual tiene como función
la produccion de pan integral.
Se debe diseñar un máquina “amasadora de pan” para el control de calidad del tiempo y
velocidad que debe llevar la masa para obtener el mejor producto que la empresa Bambo ofrece.
¿Cómo y qué se utilizó para el desarrollo de la simulación y la programación?
Para poder llevar a cabo esta actividad, es necesario realizar una investigación con los temas
relacionados y que contribuyen a la implementación del equipo solicitado. Por lo tanto primero
se debe investigar que es una Maquina Centrifuga, su operación y diseño que nos permite tener
abanicos de alternativas para realizar su diseño, teniendo en cuenta los parámetros de la guía.
Maquina Centrifuga.
En la actualidad podemos encontrar gran variedad de máquinas centrífugas, las cuales se han
creado para poder atender necesidades específicas de las industrias, en especial áreas de
investigación. La máquina de centrífuga ha sido diseñada con el fin de aplicar este tipo de fuerza,
con el fin de separar los residuos sólidos que se encuentran suspendidos en un medio líquido por
sedimentación o para separar líquidos de diversa densidad; esto es posible gracias a los
movimientos de tipo rotacional, los cuales permiten que se genere una fuerza aún mayor que la
de gravedad, en un periodo controlado de tiempo.
Imagen 1. Maquina centrifuga.

Tarjeta de desarrollo Arduino.
Es una placa
de microcontrolador de código
abierto basado en
el microchip ATmega328P y
desarrollado por Arduino.cc.12 La placa
está equipada con conjuntos de pines
de E/S digitales y analógicas que pueden

conectarse a varias placas de expansión y otros circuitos. La placa tiene 14 pines digitales, 6
pines analógicos y programables con el Arduino IDE (Entorno de desarrollo integrado) a través
de un cable USB tipo B.3 Puede ser alimentado por el cable USB o por una batería externa de 9
voltios, aunque acepta voltajes entre 7 y 20 voltios.
Código en Arduino.
El compilador cogerá el código en C++ que has
escrito en el IDE de Arduino y lo convertirá en
código máquina para que lo entienda el
microcontrolador. El que utiliza Arduino se
llama AVR-GCC.
Arduino es una plataforma de creación de
electrónica de código abierto, la cual está
basada en hardware y software libre, flexible y
fácil de utilizar para los creadores y
desarrolladores.
Con el IDE de Arduino podemos escribir nuestro código de una forma muy fácil y sobre todo,
con muchas ayudas. Pero lo más importante del IDE de Arduino es que podemos cargar el
código a la placa. Podríamos escribir todo nuestro código en el Bloc de Notas o algún otro editor
de texto y sería totalmente válido. El código no es más que texto.
Proteus.
Es una aplicación para la ejecución de
proyectos de construcción de equipos

electrónicos en todas sus etapas: diseño del esquema electrónico, programación del software,
construcción de la placa de circuito impreso, simulación de todo el conjunto, depuración de errores,
documentación y construcción.
PROYECTO
- Para la maquina “amasadora de pan” se debe diseñar una perilla para ajustar el tiempo de
funcionamiento del rotor, el tiempo mínimo es de 10 segundos y el tiempo máximo es de 1
minuto, por lo que esta perilla se puede ajustar con un potenciómetro y el rotor será un motor DC
que controla el Microcontrolador o la placa de desarrollo hardware.
- La segunda perilla de la máquina centrifuga es el control y ajuste de rotación mediante
revoluciones por minuto (RPM), por lo que con esta perilla se ajusta la velocidad de rotación del
rotor, tengan en cuenta que se debe controlar desde 0x100rpm hasta 40x100rpm, (el ajuste de
rotación se puede hacer en cualquier momento del funcionamiento de la máquina)
Código ejecutado en la tarjeta de desarrollo Arduino:

#include <LiquidCrystal.h>
LiquidCrystal lcd(12,11,5,4,3,2);
const int pinBtn=13; //PULSADOR
const int pinVelocidad=A1; //potenciometros
const int pinTiempo=A0;
const int pinmotor7=10; // PWM
const int pinmotor2=9;
const int LedOn=7; // LED
const int LedW=6;
int estado=0; // Variables
int contador=0;
int tiempo_escogido=10; //10seg.
int velocidad_escogida=0;
int pwm;
int velocidad_nueva;
int fin = 0;
void setup() {
// Mensajes de Inicio
lcd.begin(16,2);
lcd.print("Fase 6 - Grupo 36");
lcd.setCursor(0,1);
lcd.print("Proyecto Final");
delay(1000);
lcd.clear();
lcd.print("Confi. perillas");
lcd.setCursor(0,1);
lcd.print("y pulse Encender");
delay(1000);
pinMode(pinBtn, INPUT); // Default
pinMode(pinmotor7, OUTPUT);
pinMode(pinmotor2, OUTPUT);
pinMode(LedOn, OUTPUT);
pinMode(LedW, OUTPUT);
}
void loop() {
estado=digitalRead(pinBtn); // pulsador
digitalWrite(LedOn, HIGH); //led Conectado
// DISPLAY visualizar las perillas
tiempo_escogido = (analogRead(pinTiempo)/20.2)+10; // formula de proporcion
velocidad_escogida = (analogRead(pinVelocidad)/25.57);
lcd.clear();
lcd.print("Tiempo: "+String(tiempo_escogido)+"seg.");
lcd.setCursor(0,1);
lcd.print("Velocidad:"+String(velocidad_escogida)+"x100 RPM");
delay(100);
//ENCENDIDO
if(estado == HIGH ){
digitalWrite(LedW, HIGH);//led funcionando
while (contador <= tiempo_escogido){
velocidad_escogida = (analogRead(pinVelocidad)/25.57);
velocidad_nueva = analogRead(pinVelocidad);
pwm = map(velocidad_nueva, 0, 1023, 0, 255); // invertir rango
analogWrite(pinmotor7, pwm); // envia la velocidad del motor
lcd.clear(); lcd.print("Tiempo:"+String(tiempo_escogido)+"S.->"+String(contador));
lcd.setCursor(0,1); lcd.print("Velocidad:"+String(velocidad_escogida)+"x100 RPM");
delay(200); // delay(1000);
contador++;
fin = 1;}}
// AL FINALIZAR
if(fin == 1){
digitalWrite(LedW, LOW);
analogWrite(pinmotor2, LOW);
analogWrite(pinmotor7, LOW);
lcd.clear();
lcd.print("Fin del Proceso");
lcd.setCursor(0,1);
lcd.print("Masa lista");
delay(2000);
fin = 0;
}}
Circuito implementado en el software Proteus:

VIDEO EXPLICATIVO
PASO 1 – FUNDAMENTACION DEL CURSO
FUNCIONAMIENTO DE UNA ALU
DEFINICIÓN:
Como su nombre lo indica la ALU (unidad aritmética-lógica), es un dispositivo que se encarga
de realizar operaciones aritmeticas (suma, resta, multiplicación, división) y operaciones lógicas
(and, or xor, etc).
La ALU requiere de dos entradas a las que comunmente se les denomina A y B, estas pueden
tomar valores de 1 o 0. Dependiendo de estos valores y de la señal de control ella da una salida
con un resultado digital 1 o 0.
La representación esquemática típica de una ALU es la siguiente:
- A y B son los operandos.
- F representa la unidad de control.
- R la salida.
- D estado de salida.
El principio funcional de esta, está basado en el funcionamiento de las compuertas lógicas que
definiremos a continuación:
COMPUERTA LÓGICA:
Las compuertas lógicas son circuitos electrónicos con la capacidad de realizar operaciones
lógicas básicas, mediante un circuito combinacional cuya salida está condicionada por sus
entradas.
Datos de entrada Compuerta lógica Datos de salida
Las compuertas lógicas más comunes son:
COMPUERTA AND:
Su salida es un “1”, únicamente si sus dos entradas con “1”, esta compuerta representa la
multiplicación en lógica booleana.

COMPUERTA OR:
Su salida es un “0”, únicamente cuando sus dos entradas son “0”, representa la suma.
COMPUERTA NOT:
Su salida es “1”, si la entrada es “0” y viceversa.
COMPUERTA NAND:
La salida será”0”, solo si ambas entradas son “1”.

COMPUERTA NOR:
La salida será “1”, solo si ambas entradas son “0”.
COMPUERTA XOR:
Su salida es “1”, cuando una de sus dos entradas es “1”, pero no las dos simultáneamente.
COMPUERTA XNOR:
La salida es “0”, cuando una de las entradas es “1”, pero no las dos al tiempo.
Análisis y diseño de una unidad aritmético lógica por medio de compuertas, flip-flops y uso
de VHDL
VIDEO EXPLICATIVO:
https://youtu.be/N0JnRw6_55A
PASO 2 – CONTEXTUALIZACIÓN DEL PROYECTO
CÓDIGO PYTHON
PROYECTO PROPUESTO:
Para el paso 2 del proyecto propuesto se desea realizar un sistema de seguridad de ingreso del
personal al laboratorio de calidad, teniendo en cuenta que son 15 funcionarios los que ingresan al
laboratorio cada uno recibe un número binario y con este se le da acceso, sin embargo, se debe
tener en cuenta que va a estar cambiando este código cada 12 horas.
CÓDIGO:
# !/usr/bin/env python3 pio.server.begin (0)

# Generated by Proteus Visual Designer for # Install interrupt handlers
Raspberry Pi def peripheral_loop () :
# Modules pass
from goto import with_goto #---CONFIG_END---
from stddef import * def variables_setup () :
import var # Flowchart Variables
import pio var.T = 0
import resource var.ID_state = False
from datetime import datetime var.file = None
import random var.Line = ''
# Peripheral Configuration Code (Do Not var.P = 0
Edit) var.N = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
#---CONFIG_BEGIN--- var.millis = 0
import cpu var.ID = -1
import FileStore var.state = False
import VFP var.Show_state = False
import Generic var.cm = 0
import Displays # Flowchart Routines
def peripheral_setup () : @with_goto
# Peripheral Constructors def chart_SETUP () :
pio.cpu=cpu.CPU () pio.cpu.pinMode (2, cpu.OUTPUT)
pio.storage=FileStore.FileStore () pio.cpu.pinMode (3, cpu.OUTPUT)
pio.server=VFP.VfpServer () pio.cpu.pinMode (5, cpu.INPUT)
pio.BTN1=Generic.Button (pio.GPIO5) pio.cpu.pinMode (6, cpu.INPUT)
pio.BTN2=Generic.Button (pio.GPIO6) for x in range (15) :
pio.LCD1=Displays.I2CLDC () var.N[x]=random.randrange(0,255)
pio.storage.begin () var.T=millis(); var.P=7000;
return @with_goto
@with_goto def chart_Timer () :
def chart_LOOP () : var.cm=millis()
chart_BTN_ID () if var.cm>(var.T+var.P) :
chart_BTN_Show () var.T=millis()
chart_Timer () chart_Generador ()
return return
@with_goto @with_goto
def chart_BTN_ID () : def chart_Generador () :
var.ID_state = pio.cpu.digitalRead (5) for x in range (15) :
if var.ID_state : var.N[x]=(random.randrange(10, 110))
sleep((300)*0.001) pio.LCD1.clear ()
var.ID=(var.ID+1)%15 pio.LCD1.print ("N :", var.N[0])
pio.LCD1.clear () return
pio.LCD1.print ("IDENTI:", var.ID) # Main function
return def main () :
@with_goto # Setup
def chart_BTN_Show () : variables_setup ()
var.Show_state = pio.cpu.digitalRead (6) peripheral_setup ()
if var.Show_state : chart_SETUP ()
sleep((300)*0.001) # Infinite loop
if var.ID<1: while True :
var.ID = 0 peripheral_loop ()
pio.LCD1.clear () chart_LOOP ()
pio.LCD1.print ("IDENTI : ", var.ID, " ", # Command line execution
"COD: ", bin(var.N [ var.ID])) if __name__ == '__main__' :
return main()
SIMULACIÓN EN PROTEUS
VÍDEO EXPLICATIVO
LINK:
https://www.youtube.com/watch?v=75RxtzGm4vQ&feature=youtu.be
PASO 3 – PROPUESTA DEL PROYECTO
Para el paso 3 del proyecto propuesto se desea realizar un sistema
de apertura y cierre de las 3 puertas que tiene el laboratorio de
calidad de la empresa Bambo teniendo en cuenta el código de acceso
generado en el paso 2 con los últimos 4 dígitos binarios
SOLUCIÓN:
CODIGO:
#define pin_pb1 9 const int waitTime = 500; //espera entre

#define pin_pb2 10 fases
#define pin_pb3 11 const int speed = 200; //velocidad de
#define pin_pb0 8 giro
#define pin_pd7 7
#define pin_pd6 6 const int pinMotorA[1] = { pin_pb2 };
#define pin_pb4 12 const int pinMotorA1[2] = { pin_pb1 };
#define pin_pb5 13 const int pinMotorB[3] = { pin_pb3 };
#define pin_pd5 5 const int pinMotorB1[4] = { pin_pb0 };
#define pin_pd4 4 const int pinMotorC[5] = { pin_pd7};
#define pin_pd3 3 const int pinMotorC1[6] = { pin_pd6 };
#define pin_pd2 2
#define pin_pc0 0 void setup ()
#define pin_pc1 1 {
#define pin_pc2 2 pinMode (pin_pb1, OUTPUT);
#define pin_pc3 3 pinMode (pin_pb2, OUTPUT);
pinMode (pin_pb3, OUTPUT);
#include <LiquidCrystal.h> pinMode (pin_pb0, OUTPUT);
pinMode (pin_pd7, OUTPUT);
LiquidCrystal lcd(pin_pb5, pin_pb4, pinMode (pin_pd6, OUTPUT);
pin_pd5, pin_pd4, pin_pd3, pin_pd2); }
void loop ()
{ ///MOTOR 3 CERRANDO
/// A que velocidad se va amover hacia
la derecha digitalWrite(pin_pd6,HIGH);
moverderecha(pinMotorA, 180); lcd.begin(16, 2);
moverderecha(pinMotorB, 180); //Print a message to the LCD.
moverderecha(pinMotorC, 180); lcd.print("cerrando 3");
delay(waitTime);
digitalWrite(pin_pd7,LOW);
/// A que velocidad se va amover hacia lcd.begin(16, 2);
la izquierda //Print a message to the LCD.
moverizquierda(pinMotorA, 180); lcd.print("cerrando 3");
moverizquierda(pinMotorB, 180); }
moverizquierda(pinMotorC, 180); //Apertura de los motores
delay(waitTime); void moverizquierda(const int
pinMotor[3], int speed)
} {
//MOTOR 1 ABRIENDO
//Cerrado de los motores digitalWrite(pin_pb1,LOW);
void moverderecha(const int lcd.begin(16, 2);
pinMotor[3], int speed) // Print a message to the LCD.
{ lcd.print("ABRIENDO 1");
///MOTOR 1 CERRANDO
digitalWrite(pin_pb2,HIGH);
digitalWrite(pin_pb1,HIGH); lcd.begin(16, 2);
lcd.begin(16, 2); // Print a message to the LCD.
//Print a message to the LCD. lcd.print("ABRIENDO 1");
lcd.print("cerrando 1");
//MOTOR 2 ABRIENDO
digitalWrite(pin_pb2,LOW); digitalWrite(pin_pb3,LOW);
lcd.begin(16, 2); lcd.begin(16, 2);
//Print a message to the LCD. // Print a message to the LCD.
lcd.print("cerrando 1"); lcd.print("ABRIENDO 2");
///MOTOR 2 CERRANDO digitalWrite(pin_pb0,HIGH);

lcd.begin(16, 2);
digitalWrite(pin_pb3,HIGH); // Print a message to the LCD.
lcd.begin(16, 2); lcd.print("ABRIENDO 2");
//Print a message to the LCD.
lcd.print("cerrando 2"); //MOTOR 3 ABRIENDO
digitalWrite(pin_pd6,LOW);
digitalWrite(pin_pb0,LOW); lcd.begin(16, 2);
lcd.begin(16, 2); // Print a message to the LCD.
//Print a message to the LCD. lcd.print("ABRIENDO 3");
lcd.print("cerrando 2");
digitalWrite(pin_pd7,HIGH);
lcd.begin(16, 2); lcd.print("ABRIENDO 3");

// Print a message to the LCD. }
SIMULACIÓN EN PROTEUS:
VIDEO EXPLICATIVO
LINK DEL VIDEO:
https://youtu.be/MVkvPGNe1IQ
PASO 4 – ANALISIS DEL PROYECTO
Códigos binarios de los leds:
23 10111
24 11000
25 11001
26 11010
27 11011
28 11100
29 11101
30 11110
Simulación en Proteus:
Código realizado en Arduino:

//Nombres de pines:
int fotocel=A0; //PC0: analog input 0 señal analoga de la frecuencia
int datoluz0=2; //PD2: digital input 2 señal del dato digital de luz = bit 0
int dbluz[3][32]; //Base de datos de monitores: {{tiempo, luz, voltaje}}

int intervalo=1000; //Representa 45 minutos
int minutos;
int ensayos=32; //24 horas *60min = 1440 min. / 45 min = 32 ensayos.
float voltaje;
int segmento;
int n;
int vcode[5]; //Voltaje codificado en binario
void setup() {
pinMode(fotocel, INPUT);
pinMode(datoluz0, OUTPUT);
Serial.begin(9600);
}
void loop() {
minutos=0;
Serial.println();
Serial.println();
Serial.println("Inicia examen de muestra de pan cada 45 minutos durante 24 horas");
Serial.println("Sensor de luz TSL251RD: irradiancia de 0 a 200, salda de 0a 3 voltios");
Serial.println("24 horas = 1440 min / 45 min = 32 ensayos.");
Serial.println();
delay (intervalo*2);
for (int i=0; i<ensayos; i++)

{
dbluz[0][i]=minutos; //tiempo
Serial.print(i+1); Serial.print(" .Minuto: "); Serial.print(minutos);
dbluz[2][i]=analogRead(fotocel); //Lectura del sensor
//Irradiancia: se recupera el valor inicial ingresado en la GUI. Relacion

salida/entrada=619/200=3.095
dbluz[1][i]=(dbluz[2][i])/3.095;
Serial.print(". Irradiancia: "); Serial.print(dbluz[1][i]);
Serial.print(". Lectura: "); Serial.print(dbluz[2][i]);
//Calculo del voltaje: 3V/619=0.00485V

voltaje=(dbluz[2][i])*0.00485;
Serial.print(". Voltaje: "); Serial.print(voltaje);
//Codificacion 5-bit: 2^5=32 segmentos de longitud 619/32=19.34375

segmento=(dbluz[2][i])/19.34375;
Serial.print(". Codigo (ver binario en LEDS): "); Serial.println(segmento);
//Conversion decimal a binario:

n=segmento;
int d=0;
while (n>0)
{
vcode[d]=n%2;
n=n/2;
d++;
}
digitalWrite(datoluz0, vcode[0]);
minutos=minutos+45;
delay(intervalo);
vcode[0]=0;
vcode[1]=0;
vcode[2]=0;
vcode[3]=0;
vcode[4]=0;
}
Serial.println("...terminado examen de muestra.");
Serial.println();
delay(intervalo*2);
Serial.println("Inicia transmision de datos:...");

delay(intervalo*2);
Serial.print("...Transmision de datos terminada.");

delay(intervalo*4);
}
VIDEO EXPLICATIVO
https://www.youtube.com/watch?v=ZColCU8X-EA&feature=youtu.be
CONCLUSIONES
El diseño implementado fue basado en los ejercicios anteriores usando el Arduino UNO como
microcontrolador.
Entre las principales equivocaciones estuvieron las relacionadas con la programación del motor
DC pues la entrada analógica del Arduino es de 10 bits, el rango va de 0 a 1023 y la salidas del
Arduino son de 8 bits con rangos entre 0 a 255, y tuvimos que mapear el número de un rango a
otro.
Se implementaron distintos métodos para lograr configurar la velocidad correctamente con la
perilla como deteniendo la simulación para variarla, también luego de accionar un pulsador y
iendo ambos métodos.
A través del desarrollo de la actividad grupal, se efectuaron las siguientes acciones: recopilar
información para la resolución de problema, elaborar del plan de trabajo, decidir cuáles son las
variables o estrategias se van a seguir, llevar a cabo el desarrollo del proyecto en conjunto y
discutir entre las partes que intervienen en el proyecto cuál será el consolidado final.
BIBLIOGRAFIA
- Baer, J.-L. (2010). Microprocessor Architecture : From Simple Pipelines to Chip
Multiprocessors. Cambridge University Press. (pp. 177 - 206). Recuperado

de: https://bibliotecavirtual.unad.edu.co/login?url=https://search-ebscohost-com.bibliotecavirtual
.unad.edu.co/login.aspx?direct=true&db=nlebk&AN=312518&lang=es&site=ehost-live&ebv=E
B&ppid=pp_177
- Fisher, M. (2016). ARM® Cortex® M4 Cookbook. Packt Publishing. (pp. 23 - 198).
Recuperado de: https://bibliotecavirtual.unad.edu.co/login?url=https://search-ebscohost-
com.bibliotecavirtual .unad.edu.co/login.aspx?
direct=true&db=nlebk&AN=1201955&lang=es&site=ehost-live&ebv= EK&ppid=Page-__-23
- Amariei, C. (2015). Arduino Development Cookbook. Packt Publishing. (pp. 1 - 191).
Recuperado de: https://bibliotecavirtual.unad.edu.co/login?url=https://search-ebscohost-com.bi
bliotecavirtual.unad.edu.co/login.aspx?
direct=true&db=nlebk&AN=984619&lang=es&site=ehost-live&ebv=EB&ppid=pp_1
- Bates, M. (2004). PIC Microcontrollers : An Introduction to Microelectronics: Vol. 2nd ed.
Newnes. (pp. 117 - 129). Recuperado de: https://bibliotecavirtual.unad.edu.co/login?url=https
://search-ebscohost-com.bibliotecavirtual.unad.edu.co/login.aspx?direct=true&db=nlebk&AN=1
89599&lang=es&site=ehost-live&ebv=EB&ppid=pp_117
- Rodriguez, N. (2020). OVI: Introducción al software Arduino. Universidad Nacional Abierta
y/a Distancia. Recuperado de: https://repository.unad.edu.co/handle/10596/31789
- Pajankar, A., Kakkar, A., Poole, M., & Grimmett, R. (2016). Raspberry Pi: Amazing Projects
From Scratch. Packt Publishing. (pp. 75 - 92). Recuperado de: https://bibliotecavirtual.unad.

edu.co/login?url=https://search-ebscohost-com.bibliotecavirtual.unad.edu.co/login.aspx?direct=
true&db=nlebk&AN=1361385&lang=es&site=ehost-live&ebv=EB&ppid=pp_75
- Schwartz, M. (2014). Arduino Networking. Packt Publishing. (pp. 7 - 99). Recuperado
de: https://bibliotecavirtual.unad.edu.co/login?url=https://search-ebscohost-com.bibliotecavirtual
.unad.edu.co/login.aspx?direct=true&db=nlebk&AN=834836&lang=es&site=ehost-live&ebv=E
B&ppid=pp_7

Paso 6 Grupo 309696 36

Cargado por

Copyright:

Formatos disponibles

Paso 6 Grupo 309696 36

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Paso 6 Grupo 309696 36

Cargado por

Copyright:

Formatos disponibles

Paso 6 – Proyecto final 1

PASO 6 – PROYECTO FINAL

KAREN LIZETH VILLAMIL. CODIGO: 1233695732

MANUEL ALEJANDRO RINCON SANCHEZ. CODIGO: 1057577288

JORGE LUIS MANRIQUE. CODIGO:

PRESENTADO A: NESTOR JAVIER RODRIGUEZ

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

ESCUELA DE CIENCIAS BASICAS, TECNOLOGIA E INGENIERIA

PASO 6 – PROYEVTO FINAL.................................................................................................5

PASO 1 – FUNDAMENTACION DEL CURSO....................................................................13

PASO 2 – CONTEXTUALIZACIÓN DEL PROYECTO.......................................................18

PASO 3 – PROPUESTA DEL PROYECTO............................................................................22

PASO 4 – ANALISIS DEL PROYECTO................................................................................25

parámetros de configuración periféricos y programación de alto nivel para ser aplicados en el

proceso de automatización o control del proyecto.

para la automatización y control de procesos. El proyecto donde implementaremos esta Tarjeta

de desarrollo GNU es el diseño de una maquina centrifuga, simulada en el programa Proteus y

que constituyen una sustancia.

potenciómetros, visualización de mensajes en el LCD referente a los tiempos y la velocidad de la

se tomara el mejor para presentar como sustentación a la presente actividad.

automatización y control de procesos su aplicación en sistemas de automatización, redes o control

componentes electrónicos necesarios para integrar la placa Arduino.

- Aprender el manejo del software de desarrollo Arduino para la implementación de

programas en este sistema basado en micro controlador.

- Afianzar los conocimientos en programación bajo la plataforma Arduino, integrándolos

- Identificar las ventajas que nos brinda trabajar en Arduino.

- Fomentar el trabajo en equipos, delegando funciones y aportando propuesta.

PASO 6 – PROYEVTO FINAL

¿En qué consiste la actividad?

Se plantea como proyecto a desarrollar en todo el curso el diseño de un sistema de control y

la produccion de pan integral.

¿Cómo y qué se utilizó para el desarrollo de la simulación y la programación?

de gravedad, en un periodo controlado de tiempo.

Imagen 1. Maquina centrifuga.

Tarjeta de desarrollo Arduino.

desarrollado por Arduino.cc.12 La placa

está equipada con conjuntos de pines

de E/S digitales y analógicas que pueden

conectarse a varias placas de expansión y otros circuitos. La placa tiene 14 pines digitales, 6

pines analógicos y programables con el Arduino IDE (Entorno de desarrollo integrado) a través

voltios, aunque acepta voltajes entre 7 y 20 voltios.

El compilador cogerá el código en C++ que has

escrito en el IDE de Arduino y lo convertirá en

código máquina para que lo entienda el

microcontrolador. El que utiliza Arduino se

Arduino es una plataforma de creación de

electrónica de código abierto, la cual está

basada en hardware y software libre, flexible y

fácil de utilizar para los creadores y

de texto y sería totalmente válido. El código no es más que texto.

Es una aplicación para la ejecución de

proyectos de construcción de equipos

construcción de la placa de circuito impreso, simulación de todo el conjunto, depuración de errores,

funcionamiento del rotor, el tiempo mínimo es de 10 segundos y el tiempo máximo es de 1

que controla el Microcontrolador o la placa de desarrollo hardware.

- La segunda perilla de la máquina centrifuga es el control y ajuste de rotación mediante

rotación se puede hacer en cualquier momento del funcionamiento de la máquina)

Código ejecutado en la tarjeta de desarrollo Arduino:

Circuito implementado en el software Proteus:

- Baer, J.-L. (2010). Microprocessor Architecture : From Simple Pipelines to Chip

- Bates, M. (2004). PIC Microcontrollers : An Introduction to Microelectronics: Vol. 2nd ed.