Vistas de página en total

viernes, 27 de abril de 2018

EJEMPLO 2 ARDUINO: ENCENDIDO DE UN LED CON PULSADOR




Figura Configuración de ejemplo 2 (Esquema hecho con Fritzing)  

Este ejemplo consiste en el encendido de un led a través de un pulsador, es decir, que cuando presionemos el pulsador el led encenderá y cuando lo dejemos de pulsar se apagará.


IGNITION OF A LED WITH BUTTON

This example consists of the activation of a button through a pushbutton, that is, when we press the pushbutton the led in the output and when we leave it, it will turn off.






/*
 -----------------------------------
  Encendido de un LED con pulsador
 -----------------------------------
Se encenderá el led cuando presionemos el pulsador y se apagara cuando dejemos de presionarlo 

*/

int pulsador=2;//Declaramos el pin 2 como pulsador
int led=9;     //declaramos el pin 9 como led

//------------------------------------
//Función principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(pulsador, INPUT);//Configuramos pulsador como entrada
pinMode(led,OUTPUT);     //Configuramos LED como salida
}

void loop() // bucle
{            
   //pregunta por estado del pulsador
   if (digitalRead(pulsador)==HIGH) //Pulsador oprimido
   {
     digitalWrite(led,HIGH); //Enciende el LED
   }
   else//Pulsador NO oprimido
   {
     digitalWrite(led,LOW);  //Apaga el LED
   }
}

//Fin programa


ARDUINO 1: INICIANDO CON ARDUINO

ARDUINO 2: SOFTWARE ARDUINO

ARDUINO 3: PROGRAMACIÓN ARDUINO

EJEMPLO 1 ARDUINO: ENCENDIDO Y APAGADO DE UN LED

EJEMPLO 2 ARDUINO: ENCENDIDO DE UN LED CON PULSADOR

EJEMPLO 3 CONVERSION ANALOGICA DIGITAL Y ENCENDIDO DE LEDS

EJEMPLO 4 ESCRITURA SERIAL

EJEMPLO 5 MANEJO DE LCD

ARDUINO UNO PLACA DE DESARROLLO

martes, 24 de abril de 2018

EJEMPLO 1 ARDUINO: ENCENDIDO Y APAGADO DE UN LED


El primer ejemplo es muy sencillo y muestra cómo poner un pin de la placa arduino en 5V o 0V, es decir, en alto o bajo, esto se muestra a través de un led haciendo pausas de 1 seg para pasar de un estado a otro.



EXAMPLE 1 ARDUINO: ON AND OFF A LED

The first example is very simple and shows how to put a pin of the arduino board in 5V or 0V, that is, in high or low, this is shown through a led by pauses of 1 sec to move from one state to another.


Configuración de ejemplo 1 (Esquema hecho con Fritzing) 

/*
 -----------------------------------
  ENCENDIDO Y APAGADO DE UN LED
 -----------------------------------

 Enciende un LED por un segundo y lo apaga por el mismo tiempo
  
*/

int led = 9; // nombramos al pin 9 de la placa como led

//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta una vez
{
   pinMode(led,OUTPUT);//Inicializa el pin 9 como una salida 
}                         

//------------------------------------
//Bucle
//------------------------------------
void loop()    // Siempre se ejecuta este bloque de
{              // instrucciones
  digitalWrite(led,HIGH);  // Enciende el LED
  delay(1000);         // pausa de 1 seg
  digitalWrite(led,LOW);   // Apaga el LED
  delay(1000);         // Pausa de 1 seg
}

// Fin del programa


ARDUINO 1: INICIANDO CON ARDUINO

ARDUINO 2: SOFTWARE ARDUINO

ARDUINO 3: PROGRAMACIÓN ARDUINO

EJEMPLO 1 ARDUINO: ENCENDIDO Y APAGADO DE UN LED

EJEMPLO 2 ARDUINO: ENCENDIDO DE UN LED CON PULSADOR

EJEMPLO 3 CONVERSION ANALOGICA DIGITAL Y ENCENDIDO DE LEDS

EJEMPLO 4 ESCRITURA SERIAL

EJEMPLO 5 MANEJO DE LCD

ARDUINO UNO PLACA DE DESARROLLO

sábado, 21 de abril de 2018

ARDUINO 3: PROGRAMACIÓN ARDUINO


Los programas en arduino se dividen en tres partes, la estructura, los valores (Variables y constantes) y las funciones.

ESTRUCTURA

La estructura de programación arduino es idéntica a la mayoría de compiladores para microcontroladores. Esta consta de dos partes una de inicialización que se ejecuta una vez y una que se repite, es decir, un bucle.

La de inicialización es la función setup( ) contiene la asignación inicial de cualquier variable, se declaran el modo de los pines a usar (Si son salidas, entradas, análogos, etc.) y algunas configuraciones (Velocidad del puerto serial, etc.). Es el primer bloque de programa que se ejecuta.

El bucle es la función loop( ) este se ejecuta después del setup, y contiene el código que ejecuta continuamente el microcontrolador.



Figura1 Estructura básica de un boceto 

 ARDUINO PROGRAMMING

The programs in arduino are divided in three parts, the structure, the values ​​(Variables and constants) and the functions.

STRUCTURE
The arduino programming structure is identical to most compilers for microcontrollers. This consists of two parts, one of initialization that is executed once and one that is repeated, that is, a loop.

The initialization is the function setup () contains the initial assignment of any variable, they are declared the mode of the pins to be used (If they are outputs, inputs, analogs, etc.) and some configurations (Serial port speed, etc.) . It is the first program block that is executed.

The loop is the loop () function, which is executed after the setup, and contains the code that the microcontroller continuously executes.

  TIPOS DE DATOS

El programa acepta diferentes tipos de datos con diferentes longitudes de bits, entre ellos está el byte , float, char, long, int, entre otras.

  Ø  Boolean
Un dato booleano tiene dos valores posibles: verdadero o falso (puede ser 1 o 0).
Sintaxis
boolean estado = false;

  Ø  Byte
Un byte es un dato conformado por 8 bits y almacena números sin signo o decimales, puede almacenar números de 0 a 255.
Sintaxis
byte variable = 200;

  Ø  Char
También está conformado por 8 valores y almacena caracteres, estos se escriben entre comillas para ser asignados a las variables.
Sintaxis
char letra = ‘A’;

  Ø  Long
Son variables de tamaño extendido para almacenamiento de números, consumen 32 bits (4 bytes), acepta números desde -2,147,483,648 hasta 2,147,483,647.
Sintaxis
long var =-356;

  Ø  Float
El tipo variable para los números en coma flotante (número decimal). Estos números son usados, habitualmente, para aproximar valores analógicos y continuos, debido a que ofrecen una mayor resolución que los enteros. Las variables tipo float tienen el valor máximo , y como mínimo pueden alacanzar el - . Ocupan 4bytes (32bits).

Los floats tienen una precisión de 6 o 7 dígitos decimales. Esto significa el número total de dígitos, no el número a la derecha de la coma decimal. Al contrario que en otras plataformas, donde se podría obtener mayor precisión usando una variable tipo double (por ejemplo, por encima de 15 dígitos), en Arduino los double tienen el mismo tamaño que los float.

Los números en coma flotante no son exactos, y muchos proporcionan falsos resultados cuando son comparados. Por ejemplo, 6.0 / 3.0 puede no ser igual a 2.0. Debes comprobar que el valor absoluto de la diferencia entre los números pertenezca a un rango pequeño.

La matemática en coma flotante es mucho más lenta que la matemática de enteros para realizar operaciones, por lo que deberías evitarla si, por ejemplo, un bucle tiene que ejecutarse a la máxima velocidad para funciones con temporizaciones precisas. Los programadores normalmente suelen asignar unas longitudes para convertir las operaciones de coma flotante en cálculos con enteros, para aumentar la velocidad.

Sintaxis
float pi = 3.1415;

  Ø  String
Los datos tipo string representan cadenas de caracteres y se definen como vectores o matrices de caracteres, no utilizan una cantidad fija de bytes. Para definir una palabra completa en la variable se utiliza doble comillas (“”), y para un solo carácter se usa comilla sencilla (‘’).
Sintaxis
 char Str1[15];
 char Str2[8]  = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
 char Str3[8]  = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
 char Str4[ ]  = "arduino";
 char Str5[8]  = "arduino";
 char Str6[15] = "arduino";

  Ø  Arrays
Es una matriz (o vector) que permite almacenar una colección de variables, a los cuales podemos acceder mediante subíndices.
Sintaxis
  /*Declarar una matriz en los corchetes se indica la cantidad de términos*/
  int matriz[6];
  int matriz[]  = {1, 2, 3, 4, 5};
  int matriz[6] = {1, 2, 3, 4, 5, 6};

// Para leer una posición de la matriz
x = matriz [4];

TIPOS DE VARIABLES

Una variable es una forma de llamar y almacenar un valor numérico para usarse después por el programa. Como su nombre indica, las variables son números que pueden cambiarse continuamente al contrario que las constantes, cuyo valor nunca cambia. Una variable necesita ser declarada y, opcionalmente, asignada al valor que necesita para ser almacenada.

DECLARAR UNA VARIABLE
Todas las variables tienen que ser declaradas antes de que puedan ser usadas. Declarar una variable significa definir su tipo de valor, como int, long, float, etc., definir un nombre específico, y, opcionalmente, asignar un valor inicial. Esto sólo necesita hacerse una vez en un programa, pero el valor puede cambiarse en cualquier momento usando aritmética y varias asignaciones.

Una variable puede ser declarada en un número de posiciones en todo el programa y donde esta definición tiene lugar determina que partes del programa pueden usar la variable. Es recomendable declarar las variables antes de la función setup( ), para que puedan ser usadas en todo el programa a estas variables les llamamos variables globales.

Sintaxis

int variable = 2;// se declara una variable de tipo entero
                 //y le asignamos el valor de dos

INSTRUCCIONES BÁSICAS

Las instrucciones del lenguaje de programación de Arduino se pueden clasificar en operadores matemáticos, operadores constantes, de control, dirigidos a pines, sintácticos, entre otros.

OPERADORES MATEMÁTICOS

En este grupo encontramos los operadores aritméticos, de asignación y comparación.

OPERADORES ARITMETICOS

Los operadores aritméticos están conformados por la suma, resta, multiplicación y división, devuelven el valor de la suma, diferencia, producto o cociente (respectivamente) de dos operandos (que pueden ser una variable con una constante o dos variables).
a = a+3;
a = a-b;
a = a*6;
a = a/c;

OPERADORES DE ASIGNACIÓN

Las comparaciones de una variable o constante con otra se usan a menudo en declaraciones if para comprobar si una condición específica es cierta.
a == b; //a es igual a b
a != b; //a no es igual a b
a < b;  //a es menor que b
a > b;  //a es mayor que b
a <= b; //a es menor o igual que b
a >= b; //a es mayor o igual que b

OPERADORES DE COMPARACIÓN

Los operadores lógicos son normalmente una forma de comparar dos expresiones y devuelven TRUE o FALSE dependiendo del operador. Hay tres operadores lógicos, AND, OR y NOT, que se usan a menudo en declaraciones if.
//AND lógico:
if(a>0 && a<5) //verdadero sólo si las dos expresiones son ciertas
//OR lógico:
if(a>0 || b>0) //verdadero si al menos una expresión es cierta
//NOT lógico:
if(!(a>0)) //verdadero sólo si la expresión es falsa

OPERADORES CONSTANTES

El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados constantes. Se utilizan para hacer los programas más fáciles de leer. Las constantes se clasifican en grupos.

CIERTO/FALSO (TRUE/FALSE)

Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos se refieren al estado de las salidas digitales. FALSE se asocia con 0 (cero), mientras que TRUE se asocia con 1, pero TRUE también puede ser cualquier otra cosa excepto cero.

Sintaxis
if (x == TRUE);
{
//Ejecuta las instrucciones dentro de las llaves
}

ALTO/BAJO (HIGH/LOW)

Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura o la escritura digital para las patillas. ALTO se define como en la lógica de nivel 1, ON, ó 5 voltios, mientras que BAJO es lógica nivel 0, OFF, o 0 voltios.

Sintaxis
digitalWrite(13, HIGH); // activa la salida 13 con un  nivel
                        // alto (5V)

INPUT/OUTPUT

Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de los pines mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT o una salida OUTPUT.

Sintaxis
pinMode(13, OUTPUT); // designamos el pin 13 como salida

OPERADORES DE CONTROL

Estas instrucciones nos permiten determinar el orden en que se ejecutan las líneas de código en el bucle loop ( ). A este conjunto de instrucciones pertenecen if, if… else, for, while, do … while, entre otras.

 IF (SI)

Es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, como por ejemplo averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de declaraciones (operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la condición no se cumple) el programa salta y no ejecuta las operaciones que están dentro de las llaves, El formato para if es el siguiente:

Sintaxis
if (h==100)
{
//Ejecuta las instrucciones aquí contenidas
}

IF … ELSE (SI … SINO)

Esta instrucción nos permite elegir entre dos grupos de líneas de código, basándose en una pregunta, si se cumple la condición se ejecutan las instrucciones a continuación del if, sino se cumple ejecuta las instrucciones a continuación del else.

Sintaxis
if (h == 100)
{
//si se cumple la condición ejecuta estas instrucciones
}
else
{
//sino se cumple ejecuta estas instrucciones
}

GOTO (IR)

Transfiere el puntero del programa a un punto definido.
Sintaxis
etiqueta:

goto etiqueta;// envía el puntero a etiqueta

FOR (PARA)

La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición. La declaración for tiene tres partes separadas por (;), tiene una inicialización donde le decimos de donde comenzar, una condición donde se indica hasta donde llegar y una expresión o incremento en la variable

Sintaxis
for (      i=0     ; i=100    ;    i++   )
//  (inicialización; condición; expresión)
{
//bloque de Instrucciones;
}

WHILE (MIENTRAS QUE)

Es un bucles que se repite de forma continua e infinita, hasta que la condición dentro del paréntesis () se convierte en falsa.
Sintaxis
Var=0;
while(Var<=100)
{
//bloque de instrucciones
Var++;
}

DO WHILE (HAGA… MIENTRAS QUE)

Es un bucle que se ejecuta en forma continua e infinita hasta que la condición que hace que se ejecute el bloque de programa se convierta en falsa, funciona en forma idéntica al while con la diferencia que la pregunta se hace al final del bloque de instrucciones.


Sintaxis
Var=0;
do
{
//bloque de instrucciones
Var++;
} while(Var<=100);

INSTRUCCIONES DIRIGIDAS A PINES

 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).

Sintaxis
pinMode(13, OUTPUT); // configura el pin 13 como salida

digitalRead(pin)

Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW (bajo). El pin se puede especificar ya sea como una variable o una constante (0-13).

Sintaxis
valor = digitalRead(13); // hace que valor sea igual
                         // al estado leído en el Pin 13

digitalWrite(pin, value)

Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la salida). El pin se puede especificar ya sea como una variable o como una constante (0-13).

Sintaxis
digitalWrite(13, HIGH); // deposita en el pin 13 un
                         //valor de 5V

OPERADORES DE TIEMPO

millis ()

Devuelve el número de milisegundos desde que la placa Arduino inició la ejecución del programa en curso. Se desbordará este número (volvera cero), después de aproximadamente 50 días.



Sintaxis
void setup () {
  Serial.begin (9600);
}
void loop () {
  Serial.print ("Tiempo:");
  tiempo = millis ();
  // Imprime el tiempo desde que el programa comenzó
  Serial.println (tiempo);
  // Esperar un segundo a fin de no enviar cantidades   
  //masivas de datos
  delay (1000);
}

delay(ms)

Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la propia instrucción. De tal manera que 1000 equivale a 1seg.

Sintaxis
delay(1000); // espera 1 segundo

delayMicroseconds (us)

Hace una pausa en el programa para la cantidad de tiempo (en microsegundos) especificado como parámetro. 

Sintaxis
delayMicroseconds(1000); // espera 1 milisegundo

OPERADORES SINTACTICOS

Existen algunas reglas sintácticas en el compilador, haciéndose necesario conocerlas, algunas son:
Bloque de comentario: /*… */ Son bloques de texto ignoradas por el programa.
Comentario: // significa que el texto en la línea que sigue después es ignorado por el programa.
Llaves { }: Definen el comienzo y el final de bloques de función y bloques de declaraciones como void loop() y sentencias for e if. Las llaves deben estar balanceadas (a una llave de apertura {debe seguirle una llave de cierre}).

Punto y coma ; : Un punto y coma debe usarse al final de cada declaración y separa los elementos del programa.

COMUNICACIÓN SERIE

Serial.begin(rate)

Abre el puerto serie y fija la velocidad en baudios para la transmisión de datos en serie. El valor típico de velocidad para comunicarse con el ordenador es 9600, aunque otras velocidades pueden ser soportadas.

Sintaxis
void setup()
{
Serial.begin(9600); // abre el Puerto serie
}                   // configurando la velocidad en 9600 bps

Nota: Cuando se utiliza la comunicación serie los pins digital 0 (RX) y 1 (TX) no puede utilizarse al mismo tiempo.

Serial.println(data)

Imprime los datos en el puerto serie, seguido por un retorno de carro automático y salto de línea. Este comando toma la misma forma que Serial.print(), pero es más fácil para la lectura de los datos en el Monitor Serie del software.

Sintaxis
Serial.println(analogValue); // envía el valor
// 'analogValue' al
// puerto

Nota: Para obtener más información sobre las distintas posibilidades de Serial.println () y Serial.print () puede consultarse el sitio web de Arduino. El siguiente ejemplo toma de una lectura analógica pin0 y envía estos datos al ordenador cada 1 segundo.

void setup()
{
Serial.begin(9600); // configura el puerto serie a
                    // 9600bps
}
void loop()
{
Serial.println(analogRead(0)); // envía valor analógico
delay(1000);                   // espera 1 segundo
}

Serial.print(data, data type)

Vuelca o envía un número o una cadena de caracteres, al puerto serie. Dicho comando puede tomar diferentes formas, dependiendo de los parámetros que utilicemos para definir el formato de volcado de los números.


Parámetros
data: el número o la cadena de caracteres a volcar o enviar.
data type: determina el formato de salida de los valores numéricos (decimal, octal, binario, etc...) DEC, OCT, BIN, HEX, BYTE , si no se pone nada vuelva ASCII

Serial.avaible()
Devuelve Un entero con el número de bytes disponibles para leer desde el buffer serie, o 0 si no hay ninguno. Si hay algún dato disponible, SerialAvailable() será mayor que 0. El buffer serie puede almacenar como máximo 64 bytes.

CONVERSIÓN ANALOGICA DIGITAL

Las placas arduino permiten realizar la conversión analógica digital con una resolución de 10bits, existen muchas instrucciones especializadas para poder utilizar de manera eficaz el conversor.

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.

Sintaxis
valor = analogRead(13); // asigna a valor lo que lee
                         // en el pin 13

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 “pin PWM”. El más reciente Arduino, que implementa el chip ATmega168, 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, solo 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.

Sintaxis
analogWrite(13, var); // escribe el valor de var en el pin 13
                      // definido como analógico

analogReference (tipo)

Configura la tensión de referencia utilizado para la entrada analógica (es decir, el valor que se utiliza como la parte superior del rango de entrada). Las opciones son:

·         DEFAULT: la referencia analógica por defecto de 5 voltios (en los tablones de 5V Arduino) o 3,3 V (3,3 V en los tablones de Arduino)
·         INTERNO: una función de referencia, igual a 1,1 voltios en el ATmega168 o ATmega328 y 2,56 voltios en el ATmega8( no disponible en el Arduino Mega )
·         INTERNAL1V1 : un sistema incorporado en la referencia 1.1 V ( sólo Arduino Mega )
·         INTERNAL2V56 : un sistema incorporado en la referencia 2.56V ( sólo Arduino Mega )
EXTERNO: el voltaje aplicado al pin AREF ( 0 a 5V solamente ) se utiliza como la referencia.





ARDUINO 1: INICIANDO CON ARDUINO

ARDUINO 2: SOFTWARE ARDUINO

ARDUINO 3: PROGRAMACIÓN ARDUINO

EJEMPLO 1 ARDUINO: ENCENDIDO Y APAGADO DE UN LED

EJEMPLO 2 ARDUINO: ENCENDIDO DE UN LED CON PULSADOR

EJEMPLO 3 CONVERSION ANALOGICA DIGITAL Y ENCENDIDO DE LEDS

EJEMPLO 4 ESCRITURA SERIAL

EJEMPLO 5 MANEJO DE LCD

ARDUINO UNO PLACA DE DESARROLLO