Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.

El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos de entrada/salida. Los microcontroladores más usados son el Atmega168, Atmega328, Atmega1280, ATmega8 por su sencillez y bajo coste que permiten el desarrollo de múltiples diseños. Por otro lado el software consiste en un entorno de desarrollo que implementa el lenguaje de programación Processing/Wiring y el cargador de arranque (boot loader) que corre en la placa.

Arduino se puede utilizar para desarrollar objetos interactivos autónomos o puede ser conectado a software del ordenador (por ejemplo: Macromedia Flash, Processing, Max/MSP, Pure Data). Las placas se pueden montar a mano o adquirirse. El entorno de desarrollo integrado libre se puede descargar gratuitamente.

Al ser open-hardware, tanto su diseño como su distribución es libre. Es decir, puede utilizarse libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.

REFERENCIA PARA EL PROGRAMADOR DEL LENGUAJE ARDUINO

Referencias para el programador del lenguaje Arduino, con las distintas instrucciones y sentencias disponibles en el lenguaje, organizados por categorías y con un ejemplo de cada caso.

Esta referencia no es un manual de programación. Es una orientacion a gente con conocimientos de programación, que sirve para aprendizaje rápido, consulta, y compendio de la sintaxis de programación del lenguaje Arduino.

OPERADORES Y COMPARADORES

COMPARADORES

//x igual a y

x == y 

//x distinto de y

x != y 

//x menor que y 

 x < y 

 //x mayor que y

x > y 

//x menor o igual que y

x <= y 

//x mayor o igual que y

x >= y  

OPERADORES ARITMÉTICOS

//operador de asignación

a = b 

//adición

a + b 

//substracción

a - b 

//multiplicación

a * b 

//división

a / b 

//modulo

a % b

OPERADORES DE BITS

/ /and binario

a & b 

 //or binario

a ' b 

 //xor binario

a ^ b 

 //not binario

a ~ b

 //desplazamiento a izquierda

a << b 

 //desplazamiento a derecha

a >> b  

OPERADORES COMPUESTOS

//incremento

a++ 

//decremento

a-- 

//adición compuesta

a += b 

//substracción compuesta

a -= b

//multiplicación compuesta

a *= b 

//división compuesta

a /= b 

//and compuesto

a &= b 

//or compuesto

a '= b

OPERADORES BOOLEANOS

//not

!a 

//and

a && b 

//or

a '' b 

OPERADORES DE ACCESO

//operacion indirección

*variable 

//operacion dirección

&variable 

DECLARACIÓN Y CONVERSIÓN DE TIPOS DE VARIABLES

//tipo vacio (solo para funciones)

void 

BOOLEANOS

//booleano, false o true

boolean = false;

o

boolean = true;  

ENTEROS

//entero, 16 bits, de -32,768 a 32,767

int var = 100; 

//entero, 16 bits, de 0 a 65535 (excepto en Due, donde son 32 bits)

unsigned int var = 100; 

//entero, 16 bits, de 0 a 65535

short var = 100; 

//entero, 32 bits, de -2,147,483,648 a 2,147,483,647

long var = 100000L; 

//entero, 32bits, de 0 a 4,294,967,295

unsigned long var = 100000L;

COMA FLOTANTE

//coma floante, 32 bits, de -3.4028235E+38 a 3.4028235E+38. Precision 6 digitos

float var = 1.117; 

//idéntico a float, excepto en Arduino Due donde es flotante de 64 bits

double var = 1.117;

BYTES

//8 bits, de 0 a 255

byte var = B10010; 

//16bits, sin signo, de 0 a 65535

word var = 10000; 

CARACTERES

//8 bits, de -128 a 127

char var = 'A'; 

//8 bits, de 0 a 255

unsigned char var = 240;

CONVERSIÓN ENTRE VARIABLES

//convierte a char

char(variable); 

//convierte a byte

byte(variable); 

//convierte a int

int(variable); 

//convierte a word

word(variable); 

//convierte a long

long(variable); 

//convierte a floa

tfloat(variable); 

CUALIFICADORES DE VARIABLES

//STATIC: Variables visibles únicamente en el interior de una función, y cuyo valor se mantiene entre llamadas a la misma.

static int variable; 

//CONST//Variables cuyo valor no puede ser redefinido tras la inicialización

const float pi = 3.14; 

//VOLATILE: Variables en las que se indica al compilador que no guarde en los registros del microprocesador, sino que fuerza la actualización en memoria. Esto se hace cuando existe la posibilidad de que el valor de la variable sea modificado por otro proceso que se ejecuta concurrentemente con el actual (por ejemplo cuando se emplean hilos o interrupciones)

volatile int variable = LOW; 

VECTORES

CREACIÓN DE VECTORES

//declarar vector

int miArray[5]; 

//iniciar vector

int miArray[] = {2, 4, 8, 3, 6}; 

//declarar e iniciar vector

int miArray[5] = {2, 4, -8, 3, 2}; 

MANIPULACIÓN VECTORES

//asignar valor a elemento del vector

miArray[0] = 10; 

//obtener valor de elemento del vector

x = miArray[4]; 

CADENAS DE TEXTO

TEXTOS COMO VECTOR DE CARACTERES

char cadena1[15];

char cadena2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};

char cadena3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};

char cadena4[ ] = "texto";

char cadena5[8] = "texto";

char cadena6[15] = "texto"; 

//vector de cadenas

char* cadenaArray[]={"Cadena 1", "Cadena 2", "Cadena 3","Cadena 4", "Cadena 5", "Cadena 6"}; 

TEXTOS COMO OBJETO STRING

// literal de cadena de texto

String txtMsg = "Hola";

 // convirtiendo un char a String

String txtMsg = String('a'); 

// convirtiendo un literal a String

String txtMsg = String("Texto"); 

// concatenando dos literales a String

String txtMsg = String("texto1" + "texto2"); 

CONDICIONALES

CONDICIONAL ABREVIADO

condition ? true : false;

CONDICIONAL IF

if (variable < 10){ 

 // accion A

}

 if (variable < 10){ 

 // accion A

}else{ 

 // 

accion B

} 

 if (variable < 10){ 

 // accion A

}else if (variable >= 100){ 

 // accion B

}else{ 

 // accion C

} 

CONDICIONAL SWITCH / CASE OF

switch (variable) { 

 case 1: 

 // accion A 

 break; 

 case 2: 

 // accion B 

 break; 

 default: 

 // caso por defecto (opcional)} 

BUCLES

BUCLE FOR

for (int i=0; i <= 100; i++){ 

 // accion

}  

BUCLE WHILE

variable = 0; 

while(variable < 100){ 

 // accion 

 variable++;

} 

BUCLE DO WHILE

do

{ 

 //accion 

 variable++;

} 

while (variable < 100); 

FUNCIONES MATEMÁTICAS

FUNCIONES DE RANGO

//devuelve mínimo entra a y b

min(a,b); 

//devuelve máximo entra a y b

max(a,b); 

//devuelve valor absoluto de a

abs(a); 

//devuelve x restringido a (a,b)

constrain(x, a, b); 

//interpola linealmente y entre x1,y1 x2,y2

map(x, x1, x2, y1, y2); 

POTENCIACIÓN

//devuelve a^b (ambos tipo float)

pow(a,b); 

//devuelve la raiz cuadrada de a

sqrt(a); 

NÚMEROS ALEATORIOS

//inicializa la semilla del generador de numeros pseudo aleatorios

randomSeed(semilla); 

//devuelve un numero aleatorio entre a y b (ambos tipo long)

random(a, b); 

TRIGONOMETRIA

//devuelve el seno de a (a tipo float y en radianes)

sin(a);

//devuelve el coseno de a (a tipo float y en radianes)

cos(a); 

//devuelve la tangente de a (a tipo float y en radianes)

tan(a); 

FUNCIONES DE BITS Y BYTES

//devuelve el byte menos signiticativo de una palabra o variable.

lowByte(variable); 

//devuelve el byte más significativo de una palabra (o el segundo byte menos significativo en variables mayores)

highByte(variable); 

//devuelve el bit n de una variable x (siendo el bit 0 el menos significativo)

bitRead(x, n); 

//escribe el bit n de la variable x con el valor b (siendo el bit 0 el menos significativo)

bitWrite(x, n,b ); 

//pone a 1 el bit n de la variable 

xbitSet(x, n); 

//pone a 0 el bit n de la variable 

xbitClear(x, n); 

//obtiene el valor del bit n (idéntico a 2^n)

bit(n); 

FUNCIONES DE TEXTOS

//delvuelve el caracter en la posición 3 (idéntico a txtMsg[3];)

txtMsg.charAt(3); 

//sustituye el caracter en la posición 3 por "A" (idéntico a txtMsg[3]="A";)

txtMsg.setCharAt("A", 3); 

//concatena texto 1 y texto 2 (idéntico a texto1=texto1+texto2;)

texto1.concat("texto2"); 

//devuelve la longitud de la cadena

txtMsg.length(); 

//devuelve la cadena convertida en minúsculas

txtMsg.toLowerCase(); 

//devuelve la cadena convertida en mayúsculas

txtMsg.toUpperCase(); 

//elimina espacios y carácteres incorrectos

txtMsg.trim(); 

//devuelve la cadena de texto como entero

txtMsg.toInt(); 

COMPARACIÓN

//compara dos cadenas. Devuelve 1 si texto1 es mayor que texto2, 0 si son iguales, y -1 en caso contrario

texto1.compareTo(texto2); 

//compara si dos cadenas son iguales (idéntico a texto1==texto2)

texto1.equals(texto2); 

//compara si dos cadenas son iguales, ignorando mayúsculas y minúsculas

texto1.equalsIgnoreCase(texto2);

SUBCADENAS

//devuelve una subcadena de la posicion 3 a la 10

txtMsg.substring(3, 10); 

//comprueba si la cadena empieza por "texto", con offset 3

txtMsg.startsWith("texto", 3); 

//comprueba si la cadena empieza por "texto", con offset 3

txtMsg.endsWith("texto"); 

BÚSQUEDA Y SUSTITUCIÓN

//devuelve el índice de la primera ocurrencia de 'A', a partir de la posición offset

txtMsg.indexOf('A', offset); 

//devuelve el índice de la última ocurrencia de 'A' previa a la posición offset

txtMsg.lastIndexOf('A', offset); 

//sustituye las ocurrencias de "texto1" por "texto2"

txtMsg.replace("texto1", "texto2"); 

FUNCIONES DE USUARIO

VARIABLES GLOBALES

int option=1; 

int cambiar(){ 

 option=4;

} 

void setup(){ 

 Serial.begin(9600);

} 

void loop(){ 

 cambiar(); 

 Serial.print(option);  //muestra 4 

 delay(10000);

} 

PASO DE PARÁMETROS POR VALOR

int cambiar(var){ 

 var=4;

} 

void setup(){ 

 Serial.begin(9600);

} 

void loop(){ 

 int option=1; 

 cambiar(option); 

 Serial.print(option); //muestra 1 

 delay(10000);

} 

PASO DE PARÁMETROS POR REFERENCIA

int cambiar(int &var){ 

 var=4;

} 

void setup(){ 

 Serial.begin(9600);

} 

void loop(){ 

 int option=1; 

 cambiar(option); 

 Serial.print(option); //muestra 4 

 delay(10000);

} 

PASO DE PARÁMETROS POR PUNTERO

int cambiar(int* var){

 *var=4;

} 

void setup(){ 

 Serial.begin(9600);

} 

void loop(){ 

 int option=1; 

 cambiar(&option); 

 Serial.print(option); //muestra 4 

 delay(10000);

} 

DEVOLUCIÓN DE VALORES

int cambiar(){ 

 int var=4; return var;

} 

void setup(){ 

 Serial.begin(9600);

} 

void loop(){ 

 int option=1; 

 option=cambiar(); 

 Serial.print(option); //muestra 4 

 delay(10000);

} 

TIPOS DATOS AVANZADOS (ENUM / STRUCT / TYPEDEF)

ENUMERACIONES

//declaracion

enum miEnumeracion { 

 opcion1, 

 opcion2, 

 opcion3

}; 

//ejemplo de uso

miEnumeracion variable = opcion2; 

if (variable==opcion2){

 //accion

} 

ESTRUCTURAS

//declaracion

struct miEstructura

{ 

 int campo1; 

 int campo2; 

 char campo3;

}; 

//ejemplo de uso

struct miEstructura variable; 

variable.campo1=10; 

DEFINICION DE TIPOS DE DATOS DE USUARIO

//declaraciones

typedef int nuevotipo;

typedef enum miEnumeracion nuevotipo;

typedef struct miEstructura nuevotipo; 

//ejemplo de usonuevo

tipo variable; 

CLASES

EJEMPLO DE USO DE CLASE

class MiRobot;

//definicion de clase ejemplo

{

public:

void saludar(); //muestra "Hola"

void incCont(); //incrementa contador

int getCont(); //devuelve contador

void sayCont(); //muestra valor contador

void setCont(int); //inicializa contador a un valor

private:

int cont=0; //variable contador privada

};

//muestra "Hola"

void MiRobot::saludar(){

Serial.println("Hola");

}

void MiRobot::incCont(){

this->cont++;

}

//devuelve contador

void MiRobot::getCont(){

return this->cont;

}

//muestra valor contador

void MiRobot::sayCont(){

Serial.println(this->cont);

}

//inicializa contador a un valor

void MiRobot::setCont(int _cont){

this->cont=_cont;

}

void setup(){

Serial.println("Iniciando");

Serial.begin(9600);

MiRobot robot;

robot.saludar(); //se muestra hola

}

void loop(){

robot.incCont(); //se incrementa el contador

robot.sayCont(); //muestra el valor

delay(1000);

}