Referencias Arduino

OPERADORES Y COMPARADORES

COMPARADORES

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

//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

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

//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

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

//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

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--   //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

1 2 3 4 5 6 7 8

//not !a   //and a && b   //or a || b

OPERADORES DE ACCESO

1 2 3 4 5

//operacion indirección *variable   //operacion dirección &variable

DECLARACIÓN Y CONVERSIÓN DE TIPOS DE VARIABLES

1 2	//tipo vacio (solo para funciones) void

BOOLEANOS

1 2	//booleano, false o true boolean = false;

ENTEROS

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

//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

1 2 3 4 5

//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

1 2 3 4 5

//8 bits, de 0 a 255 byte var = B10010;   //16bits, sin signo, de 0 a 65535 word var = 10000;

CARACTERES

1 2 3 4 5

//8 bits, de -128 a 127 char var = 'A';   //8 bits, de 0 a 255 unsigned char var = 240;

CONVERSIÓN ENTRE VARIABLES

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

//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

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

//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

1 2 3 4 5 6 7 8

//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

1 2 3 4 5

//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

1 2 3 4 5 6 7 8 9 10

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

1 2 3 4 5 6 7 8 9 10 11

// 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

1	condition ? true : false;

CONDICIONAL IF

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

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

1 2 3 4 5 6 7 8 9 10

switch (variable) {    case 1:      // accion A      break;    case 2:      //  accion B      break;    default:      // caso por defecto (opcional) }

BUCLES

BUCLE FOR

1 2 3

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

BUCLE WHILE

1 2 3 4 5 6

variable = 0;   while(variable < 100){    // accion    variable++; }

BUCLE DO WHILE

1 2 3 4 5

do {    //accion    variable++; } while (variable < 100);

FUNCIONES MATEMÁTICAS

FUNCIONES DE RANGO

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

//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

1 2 3 4 5

//devuelve a^b (ambos tipo float) pow(a,b);   //devuelve la raiz cuadrada de a sqrt(a);

NÚMEROS ALEATORIOS

1 2 3 4 5

//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

1 2 3 4 5 6 7 8

//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

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

//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

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

//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

1 2 3 4 5 6 7 8 9

//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

1 2 3 4 5 6 7 8

//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

1 2 3 4 5 6 7 8 9 10

//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

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

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

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

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

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

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

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

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

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

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

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

//declaracion enum miEnumeracion {   opcion1,   opcion2,   opcion3 };   //ejemplo de uso miEnumeracion variable = opcion2;   if (variable==opcion2){   //accion }

ESTRUCTURAS

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

//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

1 2 3 4 5 6 7

//declaraciones typedef int nuevotipo; typedef enum miEnumeracion nuevotipo; typedef struct miEstructura nuevotipo;   //ejemplo de uso nuevotipo variable;

CLASES

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 49 50 51

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 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); }