UNIDAD EDUCATIVA PARTICULAR “POLITÉCNICO”
3° AÑO PAI - 9° GRADO B
Tarea #1: Bitácora Arduino
Nombre: Ariana Lindao M. Fecha: 20/07/17.
Arduino Uno
Arduino puede ser utilizado para desarrollar objetos autónomos e interactivos, como prototipos o interactuar con software instalado en el ordenador. Dada su rápida curva de aprendizaje y su precio económico es ideal para educadores, diseñadores y cualquiera interesado en la electrónica y robótica.El compilador necesario para programarlo está disponible de forma gratuita en www.arduino.cc y está disponible para Mac OS X, Windows y Linux.
Arduino UNO es la versión mejorada de su predecesor Duemilanove. Incluye función de auto reset, protección de sobrecargas, conector USB para programarlo, totalmente montado con componentes miniatura SMD (salvo el microcontrolador, para poder cambiarlo fácilmente) y nuevo bootloader OptiBoot a 155kbps.La placa se entrega completamente ensamblada y probada con un microcontrolador AVR ATmega328 con un cristal de cuarzo de 16Mhz.
El microcontrolador se entrega con un bootloader que permite su programación sin necesidad de ningún tipo de programado externo.Se entrega con el nuevo chip Atmega328 de AVR con 32KB de memoria de programa en lugar de 16 KB de la anterior versión, RAM de 2 KB (antes 1KB) y EEPROM de 1 KB (antes 512 bytes).La carga de los programas también es más rápida ya que el bootloader fué actualizado a una velocidad de 115000 baudios.
Estructura básica de un programa
La estructura básica de programación de Arduino es bastante simple y divide la ejecución en dos partes: setup y loop. Setup() constituye la preparación del programa y loop() es la ejecución. En la función Setup() se incluye la declaración de variables y se trata de la primera función que se ejecuta en el programa. Esta función se ejecuta una única vez y es empleada para configurar el pinMode (p. ej. si un determinado pin digital es de entrada o salida) e inicializar la comunicación serie. La función loop() incluye el código a ser ejecutado continuamente (leyendo las entradas de la placa, salidas, etc.).
void setup() {
inMode(pin, OUTPUT); // Establece 'pin' como salida
}
void loop() {
digitalWrite(pin, HIGH); // Activa 'pin'
delay(1000); // Pausa un segundo
digitalWrite(pin, LOW); // Desactiva 'pin'
delay(1000);
}
Como se observa en este bloque de código cada instrucción acaba con ; y los comentarios se indican con //. Al igual que en C se pueden introducir bloques de comentarios con /* ... */.
Tipos de datos
Arduino permite manejar los siguientes tipos de datos:
- Byte. Almacena un valor numérico de 8 bits. Tienen un rango de 0-255.
- Int. Almacena un valor entero de 16 bits con un rango de 32,767 a -32,768.
- Long. Valor entero almacenado en 32 bits con un rango de 2,147,483,647 a -2,147,483,648.
- Float. Tipo coma flotante almacenado en 32 bits con un rango de 3.4028235E+38 a -3.4028235E+38.
- Arrays Se trata de una colección de valores que pueden ser accedidos con un número de índice (el primer valor del índice es 0). Ejemplos de utilización:
- Definición y asignación. int myArray[] = {value0, value1, value2...}
- Definición. int myArray[5]; // declara un array de 6 enteros
- Asignación del cuarto componente. myArray[3] = 10;
- Recuperar el cuarto componente y asignarlo a x. x = myArray[3];
pinMode(pin, mode)
Esta instrucción es utilizada en la parte de configuración setup () y sirve para configurar el modo de trabajo de un pin pudiendo ser INPUT (entrada) u OUTPUT (salida).
pinMode(pin, OUTPUT); // configura 'pin' como salida
Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto no es necesario definirlos en el caso de que vayan a trabajar como entradas. Los pines configurados como entrada quedan, bajo el punto de vista eléctrico, como entradas en alta impedancia.
Estos pines tienen a nivel interno una resistencia de 20 KΩ a las que se puede acceder mediante software. Estas resistencias se accede de la siguiente manera:
pinMode(pin, INPUT); // activa las resistencias internas,
// configurando el pin como entrada
digitalWrite(pin, HIGH); // Pone el pin a 1 (pull-up)
Las resistencias internas normalmente se utilizan para conectar las entradas a interruptores. En el ejemplo anterior no se trata de convertir un pin en entrada, es simplemente un método para activar las resistencias internas.
Los pins configurado como OUTPUT (salida) se dice que están en un estado de baja impedancia y pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos. Esta corriente es suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie), pero no es lo suficiente grande como para alimentar cargas de mayor consumo como relés, solenoides o motores.
Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el chip ATmega. Puede ser buena idea conectar un pin configurado como salida a un dispositivo externo en serie con una resistencia de 470 o de 1000 Ω.
digitalRead(pin)
Lee el valor de un pin digital dando un resultado HIGH (alto) o LOW (bajo). El pin se puede especificar ya sea como una variable o una constante (0-13).
valor = digitalRead(pin); // hace que 'valor' sea igual al
// estado leído en 'pin'
digitalWrite(pin, value)
Envía al pin definido previamente como OUTPUT el valor HIGH o LOW (poniendo a 1 ó 0 la salida). El pin se puede especificar ya sea como una variable o como una constante (0-13).
digitalWrite(pin, HIGH); // deposita en el 'pin' un valor
// HIGH (alto o 1)
El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo escribe en el pin de salida led:
int led = 13; // asigna a LED el valor 13
int boton = 7; // asigna a botón el valor 7
int valor = 0; // define el valor y le asigna el
// valor 0
void setup()
{
pinMode(led, OUTPUT); // configura el led (pin13) como salida
pinMode(boton, INPUT); // configura botón (pin7) como entrada
}
void loop()
{
valor = digitalRead(boton); //lee el estado de la entrada botón
digitalWrite(led, valor); // envía a la salida 'led' el valor leído
}
analogRead(pin)
Lee el valor de un determinado pin definido como entrada analógica con una resolución de 10 bits. Esta instrucción sólo funciona en los pines (0-5). El rango de valor que podemos leer oscila de 0 a 1023.valor = analogRead(pin); // asigna a 'valor' lo que lee en la entrada 'pin'Nota: Los pins analógicos (0-5) a diferencia de los pines digitales, no necesitan ser declarados como INPUT u OUPUT ya que son siempre INPUT.analogWrite(pin, value)
Esta instrucción sirve para escribir un pseudo-valor analógico utilizando el procedimiento de modulación por ancho de pulso (PWM) a uno de los pines de Arduino marcados como PWM. El más reciente Arduino, que implementa el chip ATmega 368, permite habilitar como salidas analógicas tipo PWM los pines 3, 5, 6, 9, 10 y 11. Los modelos de Arduino más antiguos que implementan el chip ATmega8, sólo tiene habilitadas para esta función los pines 9, 10 y 11. El valor que se puede enviar a estos pines de salida analógica puede darse en forma de variable o constante, pero siempre con un margen de 0-255.analogWrite(pin, valor); // escribe 'valor' en el 'pin' // definido como analógicoSi enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un valor de 255 genera una salida de 5 voltios de salida en el pin especificado. Para valores de entre 0 y 255, el pin saca tensiones entre 0 y 5 voltios - cuanto mayor sea el valor, más a menudo estará a HIGH (5 voltios). Teniendo en cuenta el concepto de señal PWM , por ejemplo, un valor de 64 equivaldrá a mantener 0 voltios de tres cuartas partes del tiempo y 5 voltios a una cuarta parte del tiempo; un valor de 128 equivaldrá a mantener la salida en 0 la mitad del tiempo y 5 voltios la otra mitad del tiempo, y un valor de 192 equivaldrá a mantener en la salida 0 voltios una cuarta parte del tiempo y de 5 voltios de tres cuartas partes del tiempo restante.Debido a que esta es una función de hardware, en el pin de salida analógica (PWM) se generará una onda constante después de ejecutada la instrucción analogWrite hasta que se llegue a ejecutar otra instrucción analogWrite (o una llamada a digitalRead o digitalWrite en el mismo pin).Nota: Las salidas analógicas a diferencia de las digitales, no necesitan ser declaradas como INPUT u OUTPUT.El siguiente ejemplo lee un valor analógico de un pin de entrada analógica, convierte el valor dividiéndolo por 4 y envía el nuevo valor convertido a una salida del tipo PWM o salida analógica:int led = 10; // define el pin 10 como 'led' int analog = 0; // define el pin 0 como 'analog' int valor; // define la variable 'valor' void setup(){} // no es necesario configurar // entradas y salidas void loop() { valor = analogRead(analog); // lee el pin 0 y lo asocia a // la variable valor valor /= 4; // divide valor entre 4 y lo // reasigna a valor analogWrite(led, value); // escribe en el pin 10 'valor' }delay()Descripción
Hace una pausa en el programa durante el tiempo (en milisegundos) especificado como parámetro. (Hay 1000 milisegundos en un segundo.)Sintaxis
delay (ms)Parámetros
ms: el número de milisegundos para hacer una pausa (long sin signo)Retornos
NingunoEjemplo
int ledPin = 13; // LED conectado al pin digital 13 void.setup () { pinMode (ledPin, OUTPUT); // establece el pin digital como salida void.loop() { digitalWrite(ledPin, HIGH); // enciende el LED delay(1000); // espera un segundo digitalWrite(ledPin, LOW); //apaga el LED delay( 1000 ); // espera por un segundo }Advertencia
Si bien es fácil crear un LED parpadeante con la función delay(), y muchos programas utilizan retardos cortos para tareas tales como supresión de rebotes de un interruptor, el uso delay() en un programa tiene inconvenientes significativos. Ninguna lectura de los sensores, cálculos matemáticos, o la manipulación de pines puede seguir durante la función delay(). Para enfoques alternativos para controlar del tiempo ver la función millis () y el programa que lo sigue. Los programadores con más conocimientos por lo general evitan el uso de delay () para la sincronización de los eventos de más de 10 de de milisegundos a menos que el programa Arduino sea muy simple.Ciertas cosas no funcionan mientras que la función delay () está controlando el chip ATmega, debido a que la función delay() no deshabilita las interrupciones. La comunicación serie que aparece en el pin RX se registra, PWM (valores analogWrite) y los estados de los pines se mantienen, y las interrupciones funcionarán como es debido.Individual# 3: Sensor de Temperatura y HumedadEn esta nueva entrada vamos a ver como hacer funcionar este sensor DHT11que nos va a servir para medir tanto la humedadrelativa como la temperatura.Lo malo de este sensor es que solo nos va a darmedidas enteras, es decir sin decimales, ya que la resolución que presenta esde 1% para la humedad relativa y de 1ºC para la temperatura.Pero compensa ya que presenta un valor muyeconómico para pequeños proyectos y que nos permite obtener medidas tanto para humedad como para temperatura.El sensor de temperatura DHT11 tiene solo 3pines:● VCC● GND● OUTAlimenta tu sensor con 5 volts y conectalo auna de las entradas digitales y listo!. En el siguiente ejemplo tenemos un código que lee la temperatura y humedad del sensor DHT11 conectado al pin 7 y luego muestra los resultados en el monitor serial. Recuerda que para que el código funcione es necesario descargar la librería de el sensor. Copia y pega esta librería en tu carpeta de librerías de Arduino.
FUENTES:GRACIAS
No hay comentarios:
Publicar un comentario