Informe Componente - Practico Jose Anibal Mora

INFORME COMPONENTE PRACTICO
MICROCONTROLADORES
Tutora
SANDRA ISABEL VARGAS LOPEZ
Alumno
JOSE ANIBAL MORA AMADO
Código
74270650
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD
ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA ECBTI
TASCO MAYO DEL 2020

INTRODUCCCIÓN
El presente informe, hace referencia al uso de PIC, aplicado a la tarjeta de software
libre Arduino, en donde se desarrollan ejercicios de aplicación que permiten conocer las
partes fundamentales del hardware y las partes de desarrollo del software mediante la
aplicación de diseños de algoritmos que dan solución a las tareas propuestas, esto se
complementa con la simulación en el software proteus.

Marco teórico
Arduino
Arduino es una plataforma para el diseño y creación de proyectos electrónicos, la cual
es de código abierto, es decir que está basada en hardware y software libre; es decir
que el hardware y diagramas son de acceso público, El software libre son los
programas informáticos cuyos códigos son de acceso libre para que cualquier
usuario pueda utilizarlo y modificarlo. Arduino da las bases y a partir de ellas el usuario
pueda crear sus propias aplicaciones de hardware y software.
Para el desarrollo del presente programa se usó la placa Arduino 1
La placa Arduino cuenta con puertos de entrada, salida y comunicación. Por lo tanto,
tiene los pines
 Pines digitales, estos pueden configurarse como entrada (para lectura de pulsadores ,
interruptores, sensores, etc.), o como salida (para los actuadores, relé, drivers, led, etc.).
 Pines analógicos de entrada: estos pines usan un conversor analógico/digital y se usan para leer
sensores analógicos como sondas de temperatura, potenciómetros, sensor de presión, etc.
 Pines analógicos de salida (PWM, estas salidas nos permiten modular la salida por el ancho de
pulso, por ello son bastante útiles en el momento de regular la velocidad de salida de motores,
servomotores, etc.
 Puertos de comunicación: cuenta con puertos USB, serie, I2C y SPI, que permiten su
programación y comunicación con el computador y otros dispositivos.
A continuación, se muestra la imagen de una placa Arduino 1 con sus diferentes partes
Programación en Arduino
Estructura del programa
La estructura del lenguaje de programación en Arduino consta como mínimo de dos partes, que son
necesarias para que sea funcional, estas dos partes encierran bloques que contienen declaraciones o
instrucciones.
void setup() { estamentos; }
void loop() { estamentos;
En donde el void setup() es la parte que se encarga de recoger la configuración y el
voi loop() es la parte que contienen el programa que se ejecutará.
La función void setup contiene la declaración de las variables, se usa para configurar o
inicializar el pinMode (modo de trabajo de las E/S), configuración de la comunicación en
serie y otras; es la primera función que se ejecuta en el programa, se ejecuta sólo una
vez, la configuración es la siguiente
void setup()
{ pinMode(pin, OUTPUT); // configura el ‘pin’ como salida
La función void (loop) siguiente contiene el código que se ejecutara continuamente (lee
entradas, activas salidas, etc.) Esta función es la más importante de todos los
programas de Arduino y la que realiza la mayoría del trabajo, su configuración es la
siguiente:
void setup() {
pinMode(pin, OUTPUT); // configura el ‘pin’ como salida
Funciones
Una función es un bloque de código que con un nombre y un conjunto de códigos que
son ejecutados cuando se llama a la función. Setup() y loop() son funciones. Las
funciones de usuario se usan para realizar tareas repetitivas estas permiten reducir el
tamaño de un programa. Las funciones se declaran asociadas a un tipo de valor “type”,
este es el valor devolverá la función, si es ‘int’ la función devuelva un dato numérico de
tipo entero, o si por ejemplo la función puede no devolver ningún valor (“void”), que
significa “función vacía”. Su escritura es la siguiente
type nombre Función(parámetros)
{ estamentos; }
{} Llaves
Las llaves se usan para definir el principio y el final de un bloque de instrucciones. Se
utilizan para los bloques de programación setup(), loop(), if., type funcion() {}, etc
Punto y coma (;)

El punto y coma “;” se usa para separar instrucciones en el lenguaje de programación de Arduino.
También se utiliza para separar elementos en una instrucción de tipo “bucle for”. Por ejemplo
int x = 13;
No colocar el punto y coma al final de la línea, genera un error de compilación.
Bloque de comentarios /*, //
Los comentarios, so áreas que contienen textos que el programa los ignora, debido a esto son muy útiles
para el programados para hacer aclaraciones del programa que se está diseñando.
/* comentario
// comentario
Variable
Una variable almacena un valor numérico para después usarlo en el programa, esta siempre debe ser
usada para su posterior uso. Ejemplo
int variableEntrada = 3; // declara una variable y le asigna un valor de 3
variableEntrada = analogRead(0);// esta variable recoge el valor analógico del PIN 0
En la primera línea se declara el tipo de variable entero “int”, variable, la segunda línea da el valor
correspondiente a la entrada. Todas las variables deben ser declaradas antes de usarlas.
int value; // declaración de la variable
void setup() { // no es necesario configurar }
void loop() {
for (int i=0; i)// uso de la variable
Byte
Almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y 255 byte
una Variable = 180; // declara ‘una Variable’ como tipo byte
Int
Variable tipo entero almacenan valores numéricos de 16 bits sin decimales comprendidos en el rango
32,767 to -32,768.
int unaVariable = 1500; // declara ‘unaVariable’ como una variable de tipo entero
Long
Es un formato de variable numérica de tipo extendido “long” se refiere a números enteros de 32 bits sin
decimales que se encuentran dentro del rango -2147483648 a 2147483647.
long unaVariable = 90000; // declara ‘unaVariable’ como tipo long
Float
Dato tipo “punto flotante” “float” se aplica a los números con decimales. Los números de punto
flotante tienen una mayor resolución que los de 32 bits con un rango comprendido 3.4028235E +38
a +38-3.4028235E.
float unaVariable = 3.14; // declara ‘unaVariable’ como tipo flotante
Comparadores lógicos
Los operadores lógicos son usualmente una forma de comparar dos expresiones y devolver un
VERDADERO o FALSO dependiendo del operador. Existen tres operadores lógicos, AND, OR y
NOT,
Se usan en:
Estamentos de tipo
if
if (x > 0 && x < 5) // cierto sólo si las dos expresiones son ciertas
OR
if (x > 0 || y > 0) // cierto si una cualquiera de las expresiones es cierta
NOT
if (!x > 0) // cierto solo si la expresión es falsa
Constantes
Las constantes se clasifican en:

True/false
Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando los se
refieren al estado de las salidas digitales.
If (b == true){
Ejecutar acciones
}.
HIGH/LOW
Estas constantes definen la salida como altos o bajos, un alto equivale a un 1(5 voltios), mientras
que un bajo equivale a un 0 (0 voltios).
Digital Write(1, HIGH); // activa la salida 1.
INPUT/OUTPUT
Estas constantes se usan para definir al inicio del programa el modo en que funcionaran los
pines, es decir como entrada o como salida, su escritura es la siguiente:
pinMode(1, INPUT); // se designa el pin 1 como entrada
If (si)
Este estamento se usa para verificar si una determinada condición se cumple o no, se pueden
ejecutar una serie de declaraciones o tareas si esta condición se cumple, estas deben ir dentro de
llaves{}. Ejemplo
If (variable == VALOR)
// ejecutar instrucciones
}
Si las condiciones expresadas dentro del parentesis se cumplen, se ejecutan las instrucciones
dentro del parentesis.
If/else
Esta estructura ejecuta dos tareas, una si la condición se cumple y otra si la condición no se
cumple, ejemplo
If (inputPin1 ==HIGH)
Instrucciones para esta condición
Else
Instrucciones para esta otra instrucción
For
La declaración ‘for’ se usa para repetir un bloque de instrucciones que están dentro de {}
determinado número de veces. La condición for debe cumplir con las siguientes condiciones:
for (inicialización; condición; expresión)
Ejecutar Instrucciones;
}
While
El while es un bucle de ejecución continua mientras se cumpla la condición colocada entre

paréntesis en la cabecera del bucle. La variable de prueba tendrá que cambiar para salir del bucle
cuando esta condición no se cumpla.
while (Variable ?? valor)
Instrucciones
digitalRead
Lee el valor de un pin ( digital) y da un resultado HIGH (alto) o LOW (bajo). Este pin se puede
especificar como una variable o como una constante (0-13 para Arduino 1).
valor = digitalRead(Pin); // hace que ‘valor sea igual al estado leído en ´Pin´
digitalWrite
Envía al ´pin´ definido previamente como OUTPUT(salida) un valor HIGH o LOW (0 o 1 en la

salida). El pin se puede especificar ya sea como una variable o como una constante (0-13).
digitalWrite(pin, HIGH); // da al ‘pin’ un valor HIGH (alto o 1)
analogRead
Lee el valor de un pin definido como entrada analógica con una resolución de 10 bits. La
instrucción sólo funciona en los pines (0-5). El rango de valor que podemos leer oscila de 0 a 1023,
estos pines no necesitan ser declarados como INPUT o UOTPUT
valor = analogRead(pin); // asigna a valor que se lee en la entrada ´pin’
analogWrite
Esta instrucción sirve para escribir un valor analógico utilizando el procedimiento de modulación
PWM ( ancho de pulso) a uno de los pines del Arduino marcados como “pin PWM”.
analogWrite(pin, valor); // escribe ‘valor’ en el ‘pin’ definido como analógico
Formas de conexionado de las entradas y salidas digitales y analógicas

A continuación, se muestran los diagramas de conexionado para entradas y salidas digitales y
analógicas.
Entrada digital
Salida digital
Salida de alto consumo de corriente
Salida analógica tipo PWM
Entrada de potenciómetro
Entrada analógica (entrada conectada a una resistencia variable)
Salida conectada a un servo
Sensores para Arduino
Para el desarrosllo de el presente trabajo se usaron os siguientes sensores a los que haremos
referencia en este apartado
Sensor PIR
Los sensores infrarrojos pasivos (PIR) son dispositivos para la detección de movimiento, Los sensores
PIR se basan en la medición de la radiación infrarroja . Todos los cuerpos (vivos o no) emiten
una cierta cantidad de energía infrarroja, mayor cuanto mayor es su temperatura. Los dispositivos PIR
disponen de un sensor piro eléctrico capaz de captar esta radiación y convertirla en una señal eléctrica.
Sensor ultrasónico
Los sensores ultrasónicos generan un sonido con una frecuencia ultrasónica (inaudible por el oído
humano) el cual al chocar con un objeto es devuelto y captado por el sensor, teniendo en cuenta la
velocidad del sonido y el tiempo que se demora en ir y volver el sonido es posible calcular la distancia a
la cual se encuentra el objeto.
Display de 7 segmentos
El display 7 Segmentos es un dispositivo opto-electrónico que permite visualizar números del 0 al 9.

Existen dos tipos de display, de cátodo común y de ánodo común, importante tener en cuenta que los
displays de 7 segmentos están construidos con diodos LED, y que requieren una corriente máxima, por lo
que es necesario colocar una resistencia en serie para limitar la corriente. El valor de esta resistencia
depende de la corriente que se quiera suministrar al LED, así como de la caída de voltaje.
Drivers para motores
También llamado controlador (Driver) de motor es un amplificador de corriente; el funcionamiento de
los Drivers de motor es tomar una señal de control que es de baja corriente y luego convertirla en una
señal de corriente más alta que pueda conducir un motor, su función es similar a la del relé, pero con las
ventajas de los dispositivos electrónicos.
Desarrollo
Práctica 1:
Para la programación de un microcontrolador, se propone el uso de un dispositivo
integrado de la empresa Atmel, utilizando la tarjeta de programación libre Arduino en
cualquiera de sus modelos: Mega, Leonardo, Uno, De, Nano, etc. Con este dispositivo que se haya
seleccionado, se debe dar solución al siguiente
problema:
Se debe diseñar un contador utilizando 2 displays de 7 segmentos (El grupo escoge si
es de ánodo o cátodo común), para presentar el valor desde 0.0 hasta 9.9 cada
número del reloj es un display de 7 segmentos, debe tener un botón de inicio y parada.
Código en Arduino
Link video https://www.loom.com/share/9164ea3b5ab3451bb38d122e7ef192aa
Para el desarrollo de este ejercicio, se propone el desarrollo mediante el uso de la multiplexación y el
circuito integrado MAX 7219, ya que desarrollar el programa realizando arreglo para cada número, haría
el algoritmo demasiado extenso y dispendioso.
//MAX 7219
#include “LedControl.h”; //incluir libreria led control
LedControl lc1 = LedControl (11,13,10,1); //crear objeto con nombre lc1 y usamos
pines 11, 13 10 para interfase SPI
// 11 pin data
//13 CLK MAX 7219
// 10 LOAD
int segundos; //declaramos variable para almacenar segundos transcurridos
void setup() { //inicializamos variables
lc1.shutdown(0,false); //función que envia al dispositivo true o false No dispositivos
conectados
lc1.setIntensity(0,4); //nivel de brillo
lc1.clearDisplay(0); //Borra a 0 digitos
void loop() {
segundos = millis ()/1000;
lc1.setDigit(0,0,segundos % 10, false); //funcion setDigit (No d dispositivo, digito, valor, valor logico) se
usa operador aritmético modulo, devuelve el consciente entre la división
lc1.setDigit(0,1,(segundos/10) % 10, false);
lc1.setDigit(0,2,(segundos/100) % 10, false);
lc1.setDigit(0,3,(segundos/1000)% 10, false);
delay (1000);
Imagen código en Arduino

Simulación en software Proteus
Para el desarrollo de esta simulación se usó la multiplexación, por lo tanto, fue necesario el uso del
integrado MAX 7219 para multiplexar los displays, la dificultad en la apreciación es que el simulador
tiene retardo en las secuencias por lo que no se aprecia con claridad el multiplexado, pero se logra ver
las señales de salida en el MAX7219.
Práctica 2
Utilizando un sensor de Movimiento PIR con lente Fresnel detectar el movimiento de un objeto que se
encuentre en un espacio determinado (Pueden configurar dicho rango utilizando el Datasheet del
dispositivo), determinar con 3 leds a que distancia se encuentra del circuito, para ello van a utilizar un
sensor de ultrasonido que determina a que distancia se encuentra el objeto, para el LED verde es porque
el objeto se encuentra más lejos, para el LED amarillo el objeto se encuentra a una distancia media y
para el LED rojo es porque el objeto se encuentra muy cerca al circuito, el sensor de proximidad solo se
activa una vez el sensor PIR notifique que existe una presencia de un objeto en el espacio:
Desarrollo del programa

La simulación se puede ver en video en el enlace https://youtu.be/h5Ooa6m_Uu4 la simulación
física y la simulación en Proteus en el link
https://www.loom.com/share/17c5c8a2f94e4c7597cf48eecac04c05
Para el desarrollo de este programa se tuvo en cuenta el funcionamiento de cada uno de los sensores
(PIR, y ultrasónico) y el esquema de conexionado, el programa se desarrolla para una placa Arduino 1.
Programa en Arduino
Se declaran las diferentes variables de entrada y salida, adicionalmente es necesario declarar las
variables “trig” debido a que el sensor de ultrasonido requiere de un pulso para enviar una señal de
sonido ultrasónico , la variable eco, se usa para recibir la señal de retorno del sonido y así determinar la
distancia.
int PIR = 2; //sensor PIR
int LEDPIR =3; // indicador activación PIR
int ESTADO =0; // def de variable para almacenar valor leido estado sensor, 0,
asume que no ha recibido señal.
int TRIG = 10; //disparo de señal
int ECO = 9; //recepción señal
int LED2 = 4; //distancia lejos
int LED3 = 7; //distancia media
int LED4 = 6; //distancia cerca
int DURACION; //variables para convertir tiempo en distancia
int DISTANCIA;
void setup() {
// Inicalizar variables
pinMode(PIR, INPUT);
pinMode(LEDPIR, OUTPUT);
for(int i = 0; i > 30; i++) //Utilizamos un for para calibrar el sensor
delay(1000);
}
delay(50);
pinMode(TRIG, OUTPUT);
pinMode(ECO, INPUT);
pinMode(LED2, OUTPUT);
Serial.begin(9600);
void loop() {
// en el sensor ultrasonido se debe enviar un pulso alto y luego uno bajo duración 1 milisegundo
ESTADO = digitalRead(PIR);
if (ESTADO == HIGH){ // si detecta movimineto el sensor PIR
digitalWrite(LEDPIR, HIGH); //encendirer ledp
else //Si la condición anterior no se cumple manda apagar el led

{
digitalWrite(LEDPIR, LOW);
}
//sensor ultrasonido
do // Ciclo do while se ejecuta las lineas de codigo del sensor ultrasonico al final se verifica con while
{
digitalWrite(TRIG, HIGH); //enviar pulso (emisor)
delay(5);
digitalWrite(TRIG, LOW);
DURACION = pulseIn(ECO, HIGH); //devuelve un valor de pulso en microsegundos y lo asigna a la

variable DURACION
//convertir tiempo en distancia cm
DISTANCIA = DURACION/58.2; //Distancia en centimetros
Serial.println(DISTANCIA);
delay(200);
if (DISTANCIA <=200 && DISTANCIA >=100){
digitalWrite(LED2, HIGH);
// delay(DISTANCIA*10);
//digitalWrite(LED2, LOW);
if (DISTANCIA <= 100 && DISTANCIA >=50){
//delay(DISTANCIA*10);
// digitalWrite(LED3, LOW);
if (DISTANCIA <= 50 && DISTANCIA >= 0){
//delay(DISTANCIA*10);
// digitalWrite(LED4, LOW);
}
}
while(ESTADO==HIGH);
Imagen código en Arduino

Simulación en software Proteus
A continuación se muestra imagen de montaje del proyecto en proteus para su simulación.
Practica No. 3
Para esta práctica el estudiante junto con su grupo de trabajo colaborativo utiliza el
módulo microcontrolador Arduino, (Pueden utilizar cualquier versión Mega, Leonardo,

Due, Uno, Nano, etc.), para dar solución al siguiente problema:
Diseño de un robot controlado por bluetooth (pueden utilizar como bluetooth
transmisor el celular de uno de los compañeros) de 4 motores de 5v DC (obligatorio
el uso de 4 motores) para realizar cambios de giro y evasión de obstáculos, pueden
separar la parte digital de la potencia con el regulador de lm7805, utilizar un sistema
de accionamiento de motores por transistores, tiristores (libre a implementar, o
pueden usar un driver para motores como el L293D) y conector de batería de 9vdc:
Codigo en Arduino
El código se puede apreciar en el video correspondiente en el link

https://www.loom.com/share/160741a2505c4eb2bdf9528685b50f64
int motor1 = 13;

int motor2 = 10;
int motor3 = 9;
int motor4 = 8;
int motor5 = 7;
int motor6 = 6;
int motor7 = 5;
int motor8 = 4;
int state = 0;
void setup() {
// put your setup code here, to run once:
pinMode(motor1, OUTPUT);
pinMode(motor1, LOW);
Serial.begin (9600);
void loop() {
// put your main code here, to run repeatedly:
if (Serial.available() > 0){

state = Serial.read();
}
if (state == 'F'){// Frente
digitalWrite(motor1, HIGH); / / control driver
digitalWrite(motor2, LOW);
digitalWrite(motor3, HIGH);
state = 0;
}
if (state == 'R'){// reversa
state = 0;
}
if (state == 'D'){ // direccion derecha

state = 0;
}
if (state == 'I'){ // dirección izquierda
state = 0;
}
if (state == 'P'){ // paro

state = 0;
}
}
Simulación proteus
Practicas laboratorio presencial
En la práctica desarrollada en el laboratorio presencial se desarrollaron algunos ejercicios adicionales
que referencio a continuación. Link video display 7 segmentos https://youtu.be/A32bhRxim00
Display de 7 segmentos de 0 a 9
Código Arduino
int led0 =21;// led conectado a pin 13.
int led1 =20; // led conectado a pin 12.
int led6 =15;
int led7 =22;//segundo display
int led8 =23;
int led9 =24;
int led10 =25;
int led11 =26;
int led12 =27;
int led13 =28;
int pul1 =29;
//la instalacion se ejecuata al presionar reset
void setup() {
pinMode (led0,OUTPUT);// inicializar el pin 13 como salida

pinMode (led5,OUTPUT);// inicializar el pin 8 como salid
pinMode (led6,OUTPUT);
pinMode (led12,OUTPUT);// inicializar el pin 8 como salid
pinMode (led13,OUTPUT);
pinMode (pul1, INPUT); //pulsador inicio
void loop (){
digitalWrite(21,HIGH);// 1
digitalWrite(20,LOW);
digitalWrite(18,HIGH);
delay(500);
digitalWrite(21,LOW);// 2
delay(500);
digitalWrite(21,LOW);///3
delay(500);
digitalWrite(21,HIGH);// 4
delay(500);
digitalWrite(21,LOW);//5
delay(500);
delay(1000);
delay(500);
delay(500);
delay(500);
delay(500);
digitalWrite(22,LOW);//1 DES
delay(5000);
digitalWrite(22,HIGH);//2 DES
delay(5000);
delay(5000);
digitalWrite(22,HIGH);// 4 DES
delay(5000);
digitalWrite(26, HIGH);
delay(5000);
delay(5000);
delay(5000);
digitalWrite(22,LOW);//8 DSE
delay(5000);
delay(5000);
}
Conclusiones
El desarrollo del presente trabajo permitio conocer el software libre Arduino, sienta las
bases pares el desarrollo de proyectos en futuro.
La amplia gama de aplicaciones permite la libre imaginación para diversidad de
aplicaciones en aplicaciones desde proyectos escolares, aplicaciones a la agronomía,
industria, etc.
El desarrollo de la simulación en proteos, permite en cierta forma apreciar el
comportamiento del programa diseñado, pero presenta dificultad en la simulación, ya
algunos componentes no son compatibles con la realidad, además de la diferencia de
tiempos de respuesta, ejemplo en el caso de display de 7 segmento multiplicados, no
se aprecia el correcto funcionamiento del programa.

BIBLIOGRAFÍA
Franco, C. A. (2012). Hardware Libre Arduino. Universidad Politécnica de Valencia.
[Video]. Recuperado de https://riunet.upv.es/handle/10251/17289
Robotica, T. (2012). Libro básico de Arduino. Equipo de cosas de Mecatrónica. .
Recuperado de: https://openlibra.com/es/book/libro-basico-de-arduino-electronica-y-
programacion
Herrero, J. (2015). Una Mirada al mundo Arduino. Tecnología y Desarrollo Recuperado
de: https://dialnet.unirioja.es/servlet/articulo?codigo=5468086
Corona, L. (2014). Sensores y Actuadores Aplicaciones con Arduino. Instituto
Politécnico Nacional (Pp. 39-108). Recuperado
de: http://bibliotecavirtual.unad.edu.co:2460/lib/unadsp/reader.action?
ppg=2&docID=4569609&tm=1527546697645

Informe Componente - Practico Jose Anibal Mora

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

Informe Componente - Practico Jose Anibal Mora

Cargado por

Copyright:

Formatos disponibles

INFORME COMPONENTE PRACTICO

JOSE ANIBAL MORA AMADO

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

ESCUELA DE CIENCIAS BASICAS TECNOLOGIA E INGENIERIA ECBTI

TASCO MAYO DEL 2020

El presente informe, hace referencia al uso de PIC, aplicado a la tarjeta de software

complementa con la simulación en el software proteus.

Arduino es una plataforma para el diseño y creación de proyectos electrónicos, la cual

programas informáticos cuyos códigos son de acceso libre para que cualquier

usuario pueda utilizarlo y modificarlo. Arduino da las bases y a partir de ellas el usuario

pueda crear sus propias aplicaciones de hardware y software.

Para el desarrollo del presente programa se usó la placa Arduino 1

tiene los pines

voi loop() es la parte que contienen el programa que se ejecutará.

inicializar el pinMode (modo de trabajo de las E/S), configuración de la comunicación en

vez, la configuración es la siguiente

{ pinMode(pin, OUTPUT); // configura el ‘pin’ como salida

programas de Arduino y la que realiza la mayoría del trabajo, su configuración es la

pinMode(pin, OUTPUT); // configura el ‘pin’ como salida

tamaño de un programa. Las funciones se declaran asociadas a un tipo de valor “type”,

este es el valor devolverá la función, si es ‘int’ la función devuelva un dato numérico de

significa “función vacía”. Su escritura es la siguiente

type nombre Función(parámetros)

Las llaves se usan para definir el principio y el final de un bloque de instrucciones. Se

Punto y coma (;)

float unaVariable = 3.14; // declara ‘unaVariable’ como tipo flotante

if (!x > 0) // cierto solo si la expresión es falsa

Las constantes se clasifican en:

Digital Write(1, HIGH); // activa la salida 1.

pinMode(1, INPUT); // se designa el pin 1 como entrada

Instrucciones para esta condición

Instrucciones para esta otra instrucción

for (inicialización; condición; expresión)

El while es un bucle de ejecución continua mientras se cumpla la condición colocada entre

while (Variable ?? valor)

Envía al ´pin´ definido previamente como OUTPUT(salida) un valor HIGH o LOW (0 o 1 en la

digitalWrite(pin, HIGH); // da al ‘pin’ un valor HIGH (alto o 1)

valor = analogRead(pin); // asigna a valor que se lee en la entrada ´pin’

analogWrite(pin, valor); // escribe ‘valor’ en el ‘pin’ definido como analógico

Formas de conexionado de las entradas y salidas digitales y analógicas

Salida de alto consumo de corriente

Salida analógica tipo PWM

Salida conectada a un servo

Sensores para Arduino

El display 7 Segmentos es un dispositivo opto-electrónico que permite visualizar números del 0 al 9.

Para la programación de un microcontrolador, se propone el uso de un dispositivo

integrado de la empresa Atmel, utilizando la tarjeta de programación libre Arduino en

#include “LedControl.h”; //incluir libreria led control

pines 11, 13 10 para interfase SPI

int segundos; //declaramos variable para almacenar segundos transcurridos

void setup() { //inicializamos variables

lc1.shutdown(0,false); //función que envia al dispositivo true o false No dispositivos

lc1.setIntensity(0,4); //nivel de brillo

lc1.clearDisplay(0); //Borra a 0 digitos

Imagen código en Arduino

Desarrollo del programa

int PIR = 2; //sensor PIR

int LEDPIR =3; // indicador activación PIR

asume que no ha recibido señal.

int TRIG = 10; //disparo de señal

int ECO = 9; //recepción señal

int LED2 = 4; //distancia lejos

int LED3 = 7; //distancia media