Referencias IDE

Referencia II - IDE ARDUINO                                                                                                                                                                          

Referencia > Idioma > Funciones > Digital IO > pinMode

► pinMode()

[E/S digitales]

Descripción:

Configura el pin especificado para que se comporte como una entrada o una salida. Consulte la página Pines digitales para obtener detalles sobre la funcionalidad de los pines.

Es posible habilitar las resistencias pullup internas con el modo INPUT_PULLUP.

Además, el modo INPUT deshabilita explícitamente los pullups internos.

Sintaxis:

pinMode(pin, modo);

Parámetros:

pin: el número de pin de Arduino o la etiqueta del mismo para configurar el modo de uso.

mode: INPUT, OUTPUT, o INPUT_PULLUP.

Devoluciones: Ninguna cosa

Código de ejemplo:

El código hace que el pin digital sea 13 OUTPUT y lo alterna HIGH y LOW

void setup() {

  pinMode(13, OUTPUT);    // setear de pin 13 como salida.

}

void loop() {

  digitalWrite(13, HIGH); // setear en alto

  delay(1000);        // esperar un segundo

  digitalWrite(13, LOW);  // setear en bajo

  delay(1000);        // esperar un segundo

}

Notas y Advertencias:

Los pines de entrada analógica se pueden usar como pines digitales, denominados A0, A1, etc.

Referencia > Idioma > Funciones > Digital IO > digitalWrite

digitalWrite()

[E/S digitales]

Descripción:

Escriba un valor HIGH o un valor LOW en un pin digital.

Si el pin ha sido configurado como OUTPUT con pinMode(), su voltaje se establecerá en el valor correspondiente: 5V (o 3.3V en placas de 3.3V) para HIGH, 0V (tierra) para LOW.

Si no establece el pinMode() en OUTPUT y conecta un LED a un pin, al llamar digitalWrite(HIGH), el LED puede aparecer tenue.

Sin establecer explícitamente pinMode(), digitalWrite()habrá activado la resistencia pull-up interna, que actúa como una gran resistencia limitadora de corriente.

Sintaxis:

digitalWrite(pin, valor);

Parámetros:

pin: el número de pin de Arduino o etiqueta.

value: HIGH o LOW.

Devoluciones: Ninguna cosa

Código de ejemplo:

El código convierte el pin digital 13 en una (salida) OUTPUT y lo cambia alternando entre HIGH y LOW a un ritmo de un segundo.

void setup() {

  pinMode(13, OUTPUT);    // sets the digital pin 13 as output

}

void loop() {

  digitalWrite(13, HIGH); // sets the digital pin 13 on

  delay(1000);        // waits for a second

  digitalWrite(13, LOW);  // sets the digital pin 13 off

  delay(1000);        // waits for a second

}

Notas y Advertencias:

Los pines de entrada analógica se pueden usar como pines digitales, denominados A0, A1, etc. La excepción son los pines A6 y A7 de Arduino Nano, Pro Mini y Mini, que solo se pueden usar como entradas analógicas.

Referencia > Idioma > Funciones > Tiempo > delay()

[Tiempo]

Descripción:

Pausa el programa por la cantidad de tiempo (en milisegundos) especificado como parámetro. (Hay 1000 milisegundos en un segundo.)

Sintaxis:

delay(ms)

Parámetros:

ms: el número de milisegundos para hacer una pausa. Tipos de datos permitidos: unsigned long.

Devoluciones: Ninguna cosa

Código de ejemplo:

El código detiene el programa durante un segundo antes de alternar el pin de salida.

int ledPin = 13;          // LED connected to digital pin 13

void setup() {

  pinMode(ledPin, OUTPUT);    // sets the digital pin as output

}

void loop() {

  digitalWrite(ledPin, HIGH); // sets the LED on

  delay(1000);            // waits for a second

  digitalWrite(ledPin, LOW);  // sets the LED off

  delay(1000);            // waits for a second

}

Notas y Advertencias:

Si bien es fácil crear un LED parpadeante con la función delay() y muchos bocetos usan demoras breves para tareas como la eliminación de rebotes de interruptores, el uso de delay() en un boceto tiene importantes inconvenientes.

Ninguna otra lectura de sensores, cálculos matemáticos o manipulación de pines puede continuar durante la función de retraso, por lo que, en efecto, detiene la mayoría de las actividades.

Para obtener enfoques alternativos para controlar el tiempo, consulte el boceto Blink Without Delay, que realiza un ciclo, sondeando la función millis() hasta que haya transcurrido suficiente tiempo. Los programadores con más conocimientos generalmente evitan el uso de delay()para cronometrar eventos de más de 10 milisegundos, a menos que el boceto de Arduino sea muy simple.

Referencia > Idioma > Variables > Tipos de datos > int

[Tipos de datos]

Descripción:

Los números enteros son su tipo de datos principal para el almacenamiento de números.

En Arduino Uno (y otras placas basadas en ATMega), un int almacena un valor de 16 bits (2 bytes).

► 0000000000000000 16 bits (valor mínimo) - Decimal 0

► 1111111111111111 16 bits (valor máximo) – Decimal 65535 posibilidades diferentes

☼ Conversor de Binario a Decimal: https://es.convertbinary.com/binario-a-decimal/

Esto produce un rango de -32,768 a 32,767 (valor mínimo de -215y valor máximo de (215) - 1).

▬ En caso de necesitar solo numero positivos se puede utilizar unsigned int con un valor máximo de 65534.

Sintaxis:

int var = val;

Parámetros:

var: nombre de la variable.

val: el valor que asignas a esa variable.

Código de ejemplo:

Este código crea un número entero llamado 'countUp', que inicialmente se establece como el número 0 (cero). La variable sube en 1 (uno) cada lazo, mostrándose en el monitor serial.

int countUp = 0;        //crea la varible 'countUp'

void setup() {

  Serial.begin(9600);   // inicia el monitor serial

}

void loop() {

  countUp++;            //se suma 1 a la variable en cada bucle

  Serial.println(countUp);      // imprime la variable en el monitor serial

  delay(1000);

}

Notas y Advertencias:

Cuando se hace que las variables con signo excedan su capacidad máxima o mínima, se desbordan El resultado de un desbordamiento es impredecible, por lo que debe evitarse. Un síntoma típico de un desbordamiento es el "vuelco" de la variable desde su capacidad máxima hasta su mínima o viceversa, pero no siempre es así.

Referencia > Idioma > Variables > Tipos de datos > bool

[Tipos de datos]

Descripción:

La variable bool contiene uno de dos valores, true o false. (Cada variable bool ocupa un byte de memoria).

Sintaxis:

bool var = val;

Parámetros:

var: nombre de la variable.

val: el valor a asignar a esa variable.

Código de ejemplo:

Este código muestra cómo usar el tipo de bool datos.

bool running = false;   

Referencia III - IDE ARDUINO                                                                                                                                                                          

Referencia > Idioma > Estructura > Operadores compuestos.

Operadores Compuestos:

•  ++ (incremento)

Ejemplo: x++;      // incrementa el valor de x en 1

•  += (suma compuesta)

Ejemplo:    x+= 5;      // incrementa el valor de x en 5

•   -- (decremento)

Ejemplo:    x--;          // decremento en el valor de x en 1

•   -= (resta compuesta)

Ejemplo:    x-= 5;      // decremento en el valor de x en 5

Referencia > Idioma > Estructura > Operadores de comparación.

Operadores de comparación:

•  != (no igual a)

Ejemplo: x != 5;      // la condición es true si x no es igual a 5, caso contrario es false.

•  < (menor que)

Ejemplo: x < 5;      // la condición es true si x es menor a 5, caso contrario es false.

• <= (menor que)

Ejemplo: x <= 5;    // la condición es true si x es menor o igual a 5, caso contrario es false.

• == (igual que)

Ejemplo: x == 5;    // la condición es true si x es igual a 5, caso contrario es false.

• > (mayor que)

Ejemplo: x > 5;      // la condición es true si x es mayor a 5, caso contrario es false.

• >= (mayor que)

Ejemplo: x >= 5;    // la condición es true si x es mayor o igual a 5, caso contrario es false.

Referencia > Idioma > Estructura > Operadores de booleanos.

Operadores de booleanos.

• && (AND lógico)

Ejemplo:

(x == 1 && y == 0);

(x == HIGH && y == LOW);

// la condición es true si x es igual a 1 e y es igual a 0, caso contrario es false.

• | | (OR lógico)      Dato: alt+124 ->  |

Ejemplo:

(x == 1 | | y == 0);

(x == HIGH | | y == LOW);

// la condición es true si x es igual a 1 o y es igual a 0, caso contrario es false.

• ! (NOT lógico)     

El NOT lógico da como resultado un true si el operando es false y viceversa.

Ejemplo:

Se puede utilizar para invertir el valor booleano.

x = !y;      // invierte el valor de y, para almacenarlo en x

Referencia > Idioma > Funciones > Digital IO > digitalRead()

digitalRead()

[E/S digitales]

Descripción:

Lee el valor de un pin digital especificado, ya sea HIGH o LOW.

Sintaxis:

digitalRead(pin);

Parámetros:

pin: el número de pin de Arduino que desea leer o la etiqueta definida para ese pin.

Devoluciones:

HIGH o LOW

Observación: la devolución del estado del pin, solo ocurre en el cuándo el bucle pasa por el renglón en el que se encuentra la función digitalRead, no se almacena en ningún lugar, si se desea utilizar como dato debe guardar en una variable como bool.

Código de ejemplo

Establece el pin 13 al mismo valor que el pin 7, declarado como entrada.

int ledPin = 13;           // LED incorporado en el pin 13

int inPin = 7;           // pulsador conectado en el pin 7

int val = 0;             // variable creada e iniciada en cero

void setup() {

  pinMode(ledPin, OUTPUT);      // setear el pin 13 como salida

  pinMode(inPin, INPUT);            // setear el pin 7 como entrada

}

void loop() {

  val = digitalRead(inPin);            // lee en pin 7 y guarda el estado en la variable val.

  digitalWrite(ledPin, val);          // escribe el valor de val en el pin 13

}

Notas y Advertencias

Si el pin no está conectado a nada, digitalRead() puede devolver HIGH o LOW (y esto puede cambiar aleatoriamente).

Los pines de entrada analógica se pueden usar como pines digitales, denominados A0, A1, etc. La excepción son los pines A6 y A7 de Arduino Nano, Pro Mini y Mini, que solo se pueden usar como entradas analógicas.

Referencia > Idioma > Funciones > Comunicación > Serie

Comunicación Serial:

Descripción:

Se utiliza para la comunicación entre la placa Arduino y una computadora u otros dispositivos. Todas las placas Arduino tienen al menos un puerto serie (también conocido como UART o USART) y algunas tienen varios.

UART: Son las siglas en inglés de Universal Asynchronous Receiver-Transmitter, en español: Transmisor-Receptor Asíncrono Universal, es el dispositivo que controla los puertos y dispositivos serie.

En ARDUINO Uno, Nano, Mini y Mega, los pines 0 y 1 se utilizan para comunicarse con la computadora. Conectar cualquier cosa a estos pines puede interferir con esa comunicación, incluso causar cargas fallidas en la placa.

Funciones:

Serial.begin (9600);   // la comunicación serie se inicia en el setup

Establece la velocidad de datos en bits por segundo (baudios) para la transmisión de datos en serie.

Las trasmisiones de datos solicitado se realizan con funciones colocadas en el loop.

Serial.print ();

Imprime datos en el puerto serie como texto ASCII legible por humanos. Este comando puede tomar muchas formas. Los números se imprimen utilizando un carácter ASCII para cada dígito. Los flotantes se imprimen de manera similar como dígitos ASCII, por defecto con dos lugares decimales.

Sintaxis:

Serial.print(val);

Serial.print(val, format);

Serial.println ();

Imprime datos en el puerto serie como texto ASCII legible por humanos seguido de un carácter de nueva línea (ASCII 10 o '\ n'). Este comando tiene las mismas formas que Serial.print ().

Sintaxis:

Serial.println(val);

Serial.println(val, format);

Referencia > Idioma > Funciones > Estructura de control > If

If (…..) {

}

[Estructura de control]

Descripción:

La declaración if compara una condición, si esta es TRUE, ejecuta el código que se encuentra entre las llaves de apertura y cierre del if.

Sintaxis:

if (condición) {

  // código a ejecutar si la condición es TRUE

}

Parámetros:

condición: una expresión booleana (es decir que la respuesta, puede ser true o false).

Ejemplo 1:

if (x == 1 && z == 0) {

digitalWrite(Led1,HIGH);

}

// si la condición es true solo si, x es igual a 1 y z es igual a 0, el Led1 pasaría a estado alto, caso contrario es false, pero no significa que lo apague, ya que no es lo que dice el código entre las llaves. Esto solo lo manda a prender si la condición es verdadera.

Ejemplo 2:

if (x == 1 || z == 0) {

digitalWrite(Led1,HIGH);

}

// si la condición es true solo si, x es igual a 1 o z es igual a 0, el Led1 pasaría a estado alto, caso contrario es false, pero no significa que lo apague, ya que no es lo que dice el código entre las llaves. Esto solo lo manda a prender si la condición es verdadera.

Observación:

La condición if es una de las estructuras más dinámicas ya que continua el bucle y vuelve a comprobar la condición cuando repite el loop.

Referencia IV - IDE ARDUINO                                                                                                                                                                        

Referencia > Idioma > Estructura > Estructura de control > else

[Estructura de control]

Descripción:

El else {} - else if (condición) {} , permite un mayor control sobre el flujo del código, que el básico if, al permitir múltiples pruebas para controlar.

El else {} - ejecutará su código (si existe un else) si la condición en la declaración if da como resultado false.

El else if puede realizar otra prueba if, de modo que se puedan ejecutar múltiples pruebas mutuamente excluyentes al mismo tiempo.

Cada prueba procederá a la siguiente hasta que se encuentre una prueba verdadera. Cuando se encuentra una prueba verdadera, se ejecuta su bloque de código asociado y el programa salta a la línea que sigue a toda la construcción if / else.

Si ninguna prueba resulta ser cierta, else ejecuta el bloque predeterminado, si hay uno, y establece el comportamiento predeterminado.

Tenga en cuenta que un bloque else if se puede utilizar con o sin un bloque else de terminación y viceversa.

El else if permite un número ilimitado de bloques con condiciones diferentes.

Sintaxis 1:

if (condition1) {

  // código A

}

else {

  // código B

}

Sintaxis 2:

if (condition1) {

  // código A

}

else if (condition2) {

  // código B

}

else {

  // código C

}

Referencia > Idioma > Funciones > E/S analógica > analogWrite()

analogWrite();

[E/S analógica]

Descripción:

Escribe un valor analógico (onda PWM) en un pin. Se puede utilizar para encender un LED con distintos brillos o impulsar un motor a distintas velocidades.

Después de una llamada a analogWrite (), el pin generará una onda rectangular constante del ciclo de trabajo especificado hasta la próxima llamada a analogWrite() o una llamada a digitalWrite() en el mismo pin.

No es necesario llamar pinMode() para configurar el pin como salida antes de llamar analogWrite().

La función analogWrite no tiene nada que ver con los pines analógicos o la función analogRead.

Sintaxis:

analogWrite (pin, valor);

Parámetros:

pin: el pin de Arduino para escribir, este tiene que ser apto pasa salida PWM ~.

Tipos de datos permitidos:

valor: int el ciclo de trabajo es entre 0 (siempre apagado) y 255 (siempre encendido). 

Pines PWM en ARDUINO UNO:

-       Pin 3 ~

-       Pin 5 ~

-       Pin 6 ~

-       Pin 9 ~

-       Pin 10 ~

-       Pin 11 ~

Referencia > Idioma > Funciones > E/S analógica > analogRead()

analogRead();

[E/S analógica]

Descripción:

Lee el valor del pin analógico especificado. Las placas Arduino contienen un convertidor analógico a digital multicanal de 10 bits.

Esto significa que mapeará los voltajes de entrada entre 0 y el voltaje de operación (5V o 3.3V) en valores enteros entre 0 y 1023.

En un Arduino UNO, por ejemplo, esto produce una resolución entre lecturas de:

5 voltios / 1024 unidades o, 0,0049 voltios (4,9 mV) por unidad.

Sintaxis:

analogRead(pin);

Parámetros:

pin: el nombre del pin de entrada analógica para leer (A0 a A5 Arduino UNO, A0 a A7 en Nano)

Devoluciones:

La lectura analógica en el pin. Aunque está limitado a la resolución del conversor analógico a digital (0-1023 para 10 bits o 0-4095 para 12 bits).

Tipo de datos: int.

Código de ejemplo:

El código lee el voltaje en analogPin y lo muestra.

int analogPin = A3;     // potenciómetro conectado en el pin 3

int val = 0;                   // variable para guardar la lectura

void setup() {

  Serial.begin(9600);           //  inicia el monitor serie

}

void loop() {

  val = analogRead(analogPin);         // lee el pin de entrada

  Serial.println(val);                        // escribe en el monitor serie el valor de la variable

}

Notas y Advertencias:

Si el pin de entrada analógica no está conectado a nada, el valor devuelto por analogRead() fluctuará en función de una serie de factores (por ejemplo, los valores de las otras entradas analógicas, qué tan cerca está su mano del tablero, etc.).

Referencia V - IDE ARDUINO                                                                                                                                                                     

Referencia > Lenguaje > Funciones > Matemática > map

map();

[Matemáticas]

Descripción:

Vuelve a asignar un número de un rango a otro.

Es decir, un valor de from Low se asignaría a to Low, un valor de from High a to High, valores intermedios a valores intermedios, etc.

Tenga en cuenta que los "límites inferiores" de cualquier rango pueden ser más grandes o más pequeños que los "límites superiores", por lo que la función map()se puede usar para invertir un rango de números, por ejemplo:

y = map(x, 1, 50, 50, 1);

La función también maneja bien los números negativos, por lo que este ejemplo:

y = map(x, 1, 50, 50, -100);

también es válido y funciona bien.

La función map() usa matemáticas enteras, por lo que no generará fracciones, cuando las matemáticas podrían indicar que debería hacerlo. Los restos fraccionarios se truncan y no se redondean ni se promedian.

Sintaxis:

map(value, fromLow, fromHigh, toLow, toHigh);

Parámetros:

value: el número a mapear.

fromLow: el límite inferior del rango actual del valor.

fromHigh: el límite superior del rango actual del valor.

toLow: el límite inferior del rango objetivo del valor.

toHigh: el límite superior del rango objetivo del valor.

Devoluciones:

El valor mapeado.

Código de ejemplo:

/* Map an analog 10 bits -  value to 8 bits (0 to 255) */

void setup() {}

void loop() {

  int val = analogRead(0);

  val = map(val, 0, 1023, 0, 255);

  analogWrite(9, val);

}

Referencia VI - IDE ARDUINO                                                                                                                                                                

Referencia > Idioma > Estructura > Estructura de control > for

for();

[Estructura de control]

Descripción:

La sentencia for se utiliza para repetir un bloque de sentencias entre llaves. 

Normalmente se utiliza un contador de incrementos para incrementar y terminar el ciclo. 

La declaración for es útil para cualquier operación repetitiva y, a menudo, se usa en combinación con matrices para operar en colecciones de datos/pines.

Sintaxis:

for (initialization; condition; increment) {

  // statement(s);

}

Parámetros:

initialization: sucede primero y exactamente una vez, es la condicion para entrar en el bucle del for.

condition: cada vez que pasa por el bucle, se prueba la condition; si es true, se ejecutan las instrucciones entre las llaves y se ejecuta el incremento,

Una vez que se ejecuta el código entre las llaves, la condición se vuelve a probar. 

Cuando la condición se convierte en false, el ciclo termina.

increment: se ejecuta cada vez que pasa por el bucle cuando conditiones true.

☼ Mientras la condicion es verdadera el programa solo ejecuta el código dentro de las llaves del for activo.

Código de ejemplo:

// Dim an LED using a PWM pin

int PWMpin = 10;  // LED in series with 470 ohm resistor on pin 10

void setup() {

  // no setup needed

}

void loop() {

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

    analogWrite(PWMpin, i);

    delay(10);

  }

}

Notas y Advertencias

El bucle for de C++ es mucho más flexible que los bucles for que se encuentran en otros lenguajes informáticos, incluido BASIC. 

Se puede omitir cualquiera de los tres elementos del encabezado o todos ellos, aunque se requieren los puntos y coma. 

Además, las declaraciones de inicialización, condición e incremento pueden ser cualquier declaración de C++ válida con variables no relacionadas y usar cualquier tipo de datos de C++, incluidos los flotantes. 

Estos tipos de declaraciones for inusuales pueden proporcionar soluciones a algunos problemas de programación raros.

Referencia > Idioma > Estructura > Estructura de control > while

while();

[Estructura de control]

Descripción:

Un bucle while se repetirá continuamente, e infinitamente, hasta que la expresión dentro del paréntesis (), se vuelva false. 

Algo debe cambiar la variable probada, o el ciclo while nunca saldrá. 

Esto podría estar en su código, como una variable incrementada o una condición externa, como probar un sensor.

Sintaxis:

while (condition) {

  // statement(s)

}

Parámetros:

condition: una expresión booleana que se evalúa como true o false.

Código de Ejemplo:

int var = 0;

while (var < 200) {

  // do something repetitive 200 times

  // hacer algo repetitivo 200 veces

  var++;

}

Referencia > Idioma > Estructura > Estructura de control > do while

do while();

[Estructura de control]

Descripción:

El ciclo do…​while funciona de la misma manera que el ciclo while, con la excepción de que la condición se prueba al final del ciclo, por lo que el ciclo do siempre se ejecutará al menos una vez.

Sintaxis:

do {

  // statement block

} while (condition);

Parámetros:

condition: una expresión booleana que se evalúa como true o false.

Código de Ejemplo:

int x = 0;

do {

  delay(50);          // wait for sensors to stabilize

  x = readSensors();  // check the sensors

} while (x < 100);

Referencia VI - IDE ARDUINO                                                                                                                                                                

Reference > Language > Structure > Control structure > switch case

switch case

[Estructura de control]

Descripción:

Al igual que las declaraciones if , switch case controla el flujo de programas al permitir que los programadores especifiquen diferentes códigos que deben ejecutarse en varias condiciones. 

En particular, una sentencia switch compara el valor de una variable con los valores especificados en sentencias case. 

Cuando se encuentra una declaración de caso cuyo valor coincide con el de la variable, se ejecuta el código en esa declaración de caso.

La palabra clave break sale de la instrucción switch y normalmente se usa al final de cada caso. 

Sin una sentencia break, la sentencia switch continuará ejecutando las siguientes expresiones ("falling-through") hasta que se alcance una rotura o el final de la sentencia switch.

Sintaxis:

switch (var) {

  case label1:

    // statements

    break;

  case label2:

    // statements

    break;

  default:

    // statements

    break;

}

Parámetros:

var: una variable cuyo valor comparar con varios casos. 

Tipos de datos permitidos: int, char.

label1, label2: constantes. 

Tipos de datos permitidos: int, char.

Devoluciones:

Nada.

Código de ejemplo:

switch (var) {

  case 1:

    //do something when var equals 1

    break;

  case 2:

    //do something when var equals 2

    break;

  default:

    // if nothing else matches, do the default

    // default is optional

    break;

}