Los programas en arduino se dividen en tres partes, la estructura, los valores
(Variables y constantes) y las funciones.
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.
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];
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
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.
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
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
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);
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
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
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.
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.
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
}
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.
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.
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
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
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
