LUIS LLAMAS

INGENIERA, INFORMTICA Y DISEO

TUTORIALES ARDUINO

REFERENCIA PARA EL
PROGRAMADOR DEL LENGUAJE
ARDUINO
4 NOVIEMBRE, 2013

SHARE ON:

Os presentamos una referencia para el programador del lenguaje Arduino, con las distintas
instrucciones y sentencias disponibles en el lenguaje, organizados por categoras y con un ejemplo
de cada caso.
Operadores y comparadores

Seleccionar

Ocultar

COMPARADORES
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//xigualay
x==y

//xdistintodey
x!=y

//xmenorquey
x<y

//xmayorquey
x>y

//xmenoroigualquey
x<=y

//xmayoroigualquey
x>=y

OPERADORES ARITMTICOS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//operadordeasignacin
a=b

//adicin
a+b

//substraccin
ab

//multiplicacin
a*b

//divisin
a/b

//modulo
a%b

OPERADORES DE BITS
1
2
3
4
5
6
7
8
9
10
11
12
13

//andbinario
a&b

//orbinario
a|b

//xorbinario
a^b

//notbinario
a~b

//desplazamientoaizquierda

14
15
16
17

a<<b

//desplazamientoaderecha
a>>b

OPERADORES COMPUESTOS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//incremento
a++

//decremento
a

//adicincompuesta
a+=b

//substraccincompuesta
a=b

//multiplicacincompuesta
a*=b

//divisincompuesta
a/=b

//andcompuesto
a&=b

//orcompuesto
a|=b

OPERADORES BOOLEANOS
1
2
3
4
5
6
7
8

//not
!a

//and
a&&b

//or
a||b

OPERADORES DE ACCESO
1
2
3
4
5

//operacionindireccin
*variable

//operaciondireccin
&variable

Declaracin y conversin de tipos de variables

1

//tipovacio(soloparafunciones)

Seleccionar

Ocultar

void

BOOLEANOS
1
2

//booleano,falseotrue
boolean=false;

ENTEROS
1
2
3
4
5
6
7
8
9
10
11
12
13
14

//entero,16bits,de32,768a32,767
intvar=100;

//entero,16bits,de0a65535(exceptoenDue,dondeson32bits)
unsignedintvar=100;

//entero,16bits,de0a65535
shortvar=100;

//entero,32bits,de2,147,483,648a2,147,483,647
longvar=100000L;

//entero,32bits,de0a4,294,967,295
unsignedlongvar=100000L;

COMA FLOTANTE
1
2
3
4
5

//comafloante,32bits,de3.4028235E+38a3.4028235E+38.Precision6digitos
floatvar=1.117;

//idnticoafloat,exceptoenArduinoDuedondeesflotantede64bits
doublevar=1.117;

BYTES
1
2
3
4
5

//8bits,de0a255
bytevar=B10010;

//16bits,sinsigno,de0a65535
wordvar=10000;

CARACTERES
1
2
3
4
5

//8bits,de128a127
charvar='A';

//8bits,de0a255
unsignedcharvar=240;

CONVERSIN ENTRE VARIABLES

1

//convierteachar

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

char(variable);

//convierteabyte
byte(variable);

//convierteaint
int(variable);

//convierteaword
word(variable);

//conviertealong
long(variable);

//convierteafloat
float(variable);

CUALIFICADORES DE VARIABLES
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//STATIC
//Variablesvisiblesnicamenteenelinteriordeunafuncin,
//ycuyovalorsemantieneentrellamadasalamisma.
staticintvariable;

//CONST
//Variablescuyovalornopuedeserredefinidotraslainicializacin
constfloatpi=3.14;

//VOLATILE
//Variablesenlasqueseindicaalcompiladorquenoguardeenlosregistros
//delmicroprocesador,sinoquefuerzalaactualizacinenmemoria.Estose
//hacecuandoexistelaposibilidaddequeelvalordelavariablesea
//modificadoporotroprocesoqueseejecutaconcurrentementeconelactual
//(porejemplocuandoseempleanhilosointerrupciones)
volatileintvariable=LOW;

Vectores

CREACIN DE VECTORES
1
2
3
4
5
6
7
8

//declararvector
intmiArray[5];

//iniciarvector
intmiArray[]={2,4,8,3,6};

//declarareiniciarvector
intmiArray[5]={2,4,8,3,2};

MANIPULACIN VECTORES
1
2

//asignarvaloraelementodelvector
miArray[0]=10;

Seleccionar

Ocultar

3
4
5

//obtenervalordeelementodelvector
x=miArray[4];

Cadenas de texto

Seleccionar

Ocultar

Seleccionar

Ocultar

TEXTOS COMO VECTOR DE CARACTERES

1
2
3
4
5
6
7
8
9
10

charcadena1[15];
charcadena2[8]={'a','r','d','u','i','n','o'};
charcadena3[8]={'a','r','d','u','i','n','o','\0'};
charcadena4[]="texto";
charcadena5[8]="texto";
charcadena6[15]="texto";

//vectordecadenas
char*cadenaArray[]={"Cadena1","Cadena2","Cadena3",
"Cadena4","Cadena5","Cadena6"};

TEXTOS COMO OBJETO STRING

1
2
3
4
5
6
7
8
9
10
11

//literaldecadenadetexto
StringtxtMsg="Hola";

//convirtiendouncharaString
StringtxtMsg=String('a');

//convirtiendounliteralaString
StringtxtMsg=String("Texto");

//concatenandodosliteralesaString
StringtxtMsg=String("texto1"+"texto2");

Condicionales

CONDICIONAL ABREVIADO
1

condition?true:false;

CONDICIONAL IF
1
2
3
4
5
6
7
8
9

if(variable<10)
{

//accionA
}

if(variable<10)
{

//accionA

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

}
else
{

//accionB
}

if(variable<10)
{

//accionA
}
elseif(variable>=100)
{

//accionB
}
else
{

//accionC
}

CONDICIONAL SWITCH / CASE OF

1
2
3
4
5
6
7
8
9
10

switch(variable){

case1:

//accionA

break;

case2:

//accionB

break;

default:

//casopordefecto(opcional)
}

Bucles

BUCLE FOR
1
2
3

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

//accion
}

BUCLE WHILE
1
2
3
4
5
6

variable=0;

while(variable<100){

//accion

variable++;
}

BUCLE DO WHILE

Seleccionar

Ocultar

1
2
3
4
5

do
{

//accion

variable++;
}while(variable<100);

Funciones matemticas

FUNCIONES DE RANGO
1
2
3
4
5
6
7
8
9
10
11
12
13
14

//devuelvemnimoentraayb
min(a,b);

//devuelvemximoentraayb
max(a,b);

//devuelvevalorabsolutodea
abs(a);

//devuelvexrestringidoa(a,b)
constrain(x,a,b);

//interpolalinealmenteyentrex1,y1x2,y2
map(x,x1,x2,y1,y2);

POTENCIACIN
1
2
3
4
5

//devuelvea^b(ambostipofloat)
pow(a,b);

//devuelvelaraizcuadradadea
sqrt(a);

NMEROS ALEATORIOS
1
2
3
4
5

//inicializalasemilladelgeneradordenumerospseudoaleatorios
randomSeed(semilla);

//devuelveunnumeroaleatorioentreayb(ambostipolong)
random(a,b);

TRIGONOMETRIA
1
2
3
4
5
6
7
8

//devuelveelsenodea(atipofloatyenradianes)
sin(a);

//devuelveelcosenodea(atipofloatyenradianes)
cos(a);

//devuelvelatangentedea(atipofloatyenradianes)
tan(a);

FUNCIONES DE BITS Y BYTES

Seleccionar

Ocultar

FUNCIONES DE BITS Y BYTES

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//devuelveelbytemenossigniticativodeunapalabraovariable.
lowByte(variable);

//devuelveelbytemssignificativodeunapalabra
//(oelsegundobytemenossignificativoenvariablesmayores)
highByte(variable);

//devuelveelbitndeunavariablex
//(siendoelbit0elmenossignificativo)
bitRead(x,n);

//escribeelbitndelavariablexconelvalorb
//(siendoelbit0elmenossignificativo)
bitWrite(x,n,b);

//ponea1elbitndelavariablex
bitSet(x,n);

//ponea0elbitndelavariablex
bitClear(x,n);

//obtieneelvalordelbitn(idnticoa2^n)
bit(n);

Funciones de textos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//delvuelveelcaracterenlaposicin3(idnticoatxtMsg[3];)
txtMsg.charAt(3);

//sustituyeelcaracterenlaposicin3por"A"(idnticoatxtMsg[3]="A";)
txtMsg.setCharAt("A",3);

//concatenatexto1ytexto2(idnticoatexto1=texto1+texto2;)
texto1.concat("texto2");

//devuelvelalongituddelacadena
txtMsg.length();

//devuelvelacadenaconvertidaenminsculas
txtMsg.toLowerCase();

//devuelvelacadenaconvertidaenmaysculas
txtMsg.toUpperCase();

//eliminaespaciosycarcteresincorrectos
txtMsg.trim();

//devuelvelacadenadetextocomoentero
txtMsg.toInt();

COMPARACIN
1
2

Seleccionar

//comparadoscadenas.Devuelve1sitexto1esmayorquetexto2,
//0sisoniguales,y1encasocontrario

Ocultar

3
4
5
6
7
8
9

texto1.compareTo(texto2);

//comparasidoscadenassoniguales(idnticoatexto1==texto2)
texto1.equals(texto2);

//comparasidoscadenassoniguales,ignorandomaysculasyminsculas
texto1.equalsIgnoreCase(texto2);

SUBCADENAS
1
2
3
4
5
6
7
8

//devuelveunasubcadenadelaposicion3ala10
txtMsg.substring(3,10);

//compruebasilacadenaempiezapor"texto",conoffset3
txtMsg.startsWith("texto",3);

//compruebasilacadenaempiezapor"texto",conoffset3
txtMsg.endsWith("texto");

BSQUEDA Y SUSTITUCIN
1
2
3
4
5
6
7
8
9
10

//devuelveelndicedelaprimeraocurrenciade'A',
//apartirdelaposicinoffset
txtMsg.indexOf('A',offset);

//devuelveelndicedelaltimaocurrenciade'A'
//previaalaposicinoffset
txtMsg.lastIndexOf('A',offset);

//sustituyelasocurrenciasde"texto1"por"texto2"
txtMsg.replace("texto1","texto2");

Funciones de usuario

VARIABLES GLOBALES
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

intoption=1;

intcambiar(){
option=4;
}

voidsetup(){
Serial.begin(9600);
}

voidloop(){
cambiar();
Serial.print(option);//muestra4
delay(10000);
}

PASO DE PARMETROS POR VALOR

Seleccionar

Ocultar

PASO DE PARMETROS POR VALOR

1
2
3
4
5
6
7
8
9
10
11
12
13
14

intcambiar(var){
var=4;
}

voidsetup(){
Serial.begin(9600);
}

voidloop(){
intoption=1;
cambiar(option);
Serial.print(option);//muestra1
delay(10000);
}

PASO DE PARMETROS POR REFERENCIA

1
2
3
4
5
6
7
8
9
10
11
12
13
14

intcambiar(int&var){
var=4;
}

voidsetup(){
Serial.begin(9600);
}

voidloop(){
intoption=1;
cambiar(option);
Serial.print(option);//muestra4
delay(10000);
}

PASO DE PARMETROS POR PUNTERO

1
2
3
4
5
6
7
8
9
10
11
12
13
14

intcambiar(int*var){
*var=4;
}

voidsetup(){
Serial.begin(9600);
}

voidloop(){
intoption=1;
cambiar(&option);
Serial.print(option);//muestra4
delay(10000);
}

DEVOLUCIN DE VALORES
1
2

intcambiar(){
intvar=4;

3
4
5
6
7
8
9
10
11
12
13
14
15

returnvar;
}

voidsetup(){
Serial.begin(9600);
}

voidloop(){
intoption=1;
option=cambiar();
Serial.print(option);//muestra4
delay(10000);
}

Tipos datos avanzados (Enum / Struct / Typedef)

ENUMERACIONES
1
2
3
4
5
6
7
8
9
10
11
12
13

//declaracion
enummiEnumeracion{
opcion1,
opcion2,
opcion3
};

//ejemplodeuso
miEnumeracionvariable=opcion2;

if(variable==opcion2){
//accion
}

ESTRUCTURAS
1
2
3
4
5
6
7
8
9
10
11
12

//declaracion
structmiEstructura
{
intcampo1;
intcampo2;
charcampo3;
};

//ejemplodeuso
structmiEstructuravariable;

variable.campo1=10;

DEFINICION DE TIPOS DE DATOS DE USUARIO

1
2
3
4

//declaraciones
typedefintnuevotipo;
typedefenummiEnumeracionnuevotipo;
typedefstructmiEstructuranuevotipo;

Seleccionar

Ocultar

5
6
7

//ejemplodeuso
nuevotipovariable;

Clases

Seleccionar

EJEMPLO DE USO DE CLASE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

classMiRobot;

//definiciondeclaseejemplo
classMiRobot
{
public:
voidsaludar(); //muestra"Hola"
voidincCont(); //incrementacontador
intgetCont(); //devuelvecontador
voidsayCont(); //muestravalorcontador
voidsetCont(int);//inicializacontadoraunvalor
private:
intcont=0;
//variablecontadorprivada
};

//muestra"Hola"
voidMiRobot::saludar(){
Serial.println("Hola");
}

voidMiRobot::incCont(){
this>cont++;
}

//devuelvecontador
voidMiRobot::getCont(){
returnthis>cont;
}

//muestravalorcontador
voidMiRobot::sayCont(){
Serial.println(this>cont);
}

//inicializacontadoraunvalor
voidMiRobot::setCont(int_cont){
this>cont=_cont;
}

voidsetup(){
Serial.println("Iniciando");
Serial.begin(9600);
MiRobotrobot;
robot.saludar();//semuestrahola
}

voidloop(){
robot.incCont(); //seincrementaelcontador

Ocultar

49
50
51

robot.sayCont(); //muestraelvalor
delay(1000);
}

Esta referencia no es un manual de programacin. Es un chuletario orientado a gente

que ya sabe programar, que sirve para aprendizaje rpido, consulta, y compendio de la
sintaxis de programacin del lenguaje Arduino. Si no es vuestro caso, os recomendamos que
empezis aprendiendo a programar en C++ en alguno de los muchos cursos disponibles
gratuitamente en Internet.

Si te ha gustado esta entrada y quieres leer ms puedes consultar el resto de tutoriales de

Arduino
TAGS:
ARDUINO

ARDUINO BASICO

PREVIOUS POST

COMPILAR C# DESDE CONSOLA, SIN

VISUAL STUDIO

NEXT POST

DUAL BOOT WINDOWS/LINUX (1 DE

2) - REDIMENSIONAR PARTICIN DE
WINDOWS

RELATED POSTS
MEDIR LA HUMEDAD DEL SUELO CON ARDUINO E HIGRMETRO FC-28

CONTROLAR ARDUINO CON C# Y EL PUERTO DE SERIE

CONTROLAR ARDUINO CON C# Y EL PUERTO DE SERIE

EL MEJOR IDE PARA ARDUINO. VISUAL STUDIO CON VISUAL MICRO

0Comentarios
Recomendar

LuisLlamas

Compartir

Ordenarporlosmsnuevos

Iniciaeldebate...

Selprimeroencomentar.

Suscrbete

Acceder

AadeDisqusatusitiowebAddDisqusAdd

Privacidad

Search

SIGUENOS EN

TWITTER

G+

LINKEDIN

SIGUE LEYENDO

TUTORIALES ARDUINO
ltimas entradas de Arduino
MEDIR LA HUMEDAD DEL SUELO CON ARDUINO E HIGRMETRO FC-28

CONTROLAR ARDUINO CON C# Y EL PUERTO DE SERIE

EL MEJOR IDE PARA ARDUINO. VISUAL STUDIO CON VISUAL MICRO

SALIDA ANALGICA MEDIANTE PWM Y FILTRO PASO BAJO

USAR UN INTERRUPTOR MAGNTICO CON ARDUINO (MAGNETIC REED)

RSS

OTRAS CATEGORIAS
DISEO

INFORMTICA

INGENIERIA

PROGRAMACION

ZONA GEEK

FREEWARE

LICENCIA
Excepto notacin expresa, los contenidos de este sitio se ofrecen bajo licencia Creative Commons
License BY-NC-SA.

Ms informacin

ENTRADAS RECIENTES
Medir la humedad del suelo con Arduino e higrmetro FC-28
Nuestro primer programa en Python
Controlar Arduino con C# y el puerto de serie
El mejor IDE para Arduino. Visual Studio con Visual Micro
Feliz Navidad! 2015

POLTICA DE COOKIES
Este web utiliza cookies propias y de terceros para ofrecerle una mejor experiencia y servicio. Al
navegar o utilizar nuestros servicios el usuario acepta el uso de las mismas. El usuario tiene la opcin
de impedir la generacin de cookies y la eliminacin de las mismas mediante la seleccin de la
correspondiente opcin en su navegador.

Copyright , All Rights Reserved.

Back to top