Referencia para el programador del lenguaje Arduino


arduino-referencia

Os presentamos una referencia 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 un "chuletario" orientado 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. Si no es vuestro caso, os recomendamos que empecéis aprendiendo a programar en C++ en alguno de los muchos cursos disponibles gratuitamente en Internet.

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;

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 float
float(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 x
bitSet(x, n);

//pone a 0 el bit n de la variable x
bitClear(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 uso
nuevotipo variable;

Clases

Ejemplo de uso de clase

class MiRobot;

//definicion de clase ejemplo
class MiRobot
{
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
int 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;
}

MiRobot robot;
void setup(){
  Serial.println("Iniciando");
  Serial.begin(9600); 

  robot.saludar(); 	//se muestra hola
}

void loop(){
  robot.incCont();	//se incrementa el contador
  robot.sayCont();	//muestra el valor
  delay(1000);
}
Si te ha gustado esta entrada y quieres leer más sobre Arduino puedes consultar la sección Tutoriales de Arduino
5 5 votes
Article Rating

Anuncio:

Previous Compilar C# desde consola, sin Visual Studio
Next Dual Boot Windows/Linux (1 de 2) - Redimensionar partición de Windows
6 Comments
oldest
newest
Inline Feedbacks
View all comments
Charly
3 years ago

Sinceramente me parece la mejor síntesis de C/C++ para arduino que he visto. Muy útil.

Enhorabuena por la web 🙂

Fernando
2 years ago

impresionante! copie todo y estoy armando un pdf con esta info, cuando lo termine te lo envio si te interesa.

Diego
2 years ago
Reply to  Fernando

Es genial esta web ! Estoy iniciándome en este mundillo y es perfecto. Muchas gracias por las clases.
Por cierto Fernando, ¿Tienes ya el pdf montado? A mi si me interesa

Jose Luis Garcia
2 years ago

Sin duda, la mejor sintesis que he visto

Jhonny Omar
8 months ago

Gracias Luis, excelente trabajo, es de gran ayuda. Un abrazo desde Perú

jospicant
8 months ago

Me encanta!
Gracias