8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

(https://www.prometec.net)

TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

GUIA A LA PROGRAMACION DE ARDUINO

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
Funciones

SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

FUNCIONES

Vimos al nal de la primera parte (capítulo 5 “Funciones”) en que consistían las funciones en cualquier lenguaje de programación y en concreto
en el Arduino.

Recordamos algunos de los conceptos básicos sobre funciones:

Lo primero que hay que hacer es declarar el tipo de la función (es decir, el tipo de la variable que la función va a devolver con la instrucción
“return” (void si no devuelve ningún valor, o cualquiera de los demás tipos en caso contrario)

Si estás escribiendo una función dale un nombre signi cativo (es decir, que te recuerde claramente que hace esa función, que valor devuelve)

Los datos que se trans eren desde el programa a la función se llaman parámetros, pueden ser uno, varios o ninguno, y de diferentes tipos (con
la excepción de las funciones como setup() y loop() que no utilizan parámetros).

El lenguaje del Arduino incluye una serie de funciones que están incluidas directamente en la librería básica (“Core”) y que podemos usar sin
más. Estas funciones se pueden agrupar en diferentes tipos:

 Funciones de entrada/salida digital (I/O: Input/Output).

 Funciones de entrada/salida analógicas.

 Funciones avanzadas de entrada/salida.

 Funciones de entrada/salida del Arduino Due.

 Funciones temporales.

 Funciones matemáticas.

 Funciones trigonométricas.

 Funciones aleatorias.

 Funciones de manipulación de bits y bytes.

 Funciones de gestión de interrupciones.

 Funciones de gestión de comunicaciones.

 Funciones de gestión del puerto USB (Leonardo y Due solamente).

 Funciones de conversión de tipos.

 Otras funciones.

FUNCIONES DE ENTRADA/SALIDA DIGITAL

La función pinMode()

https://www.prometec.net/funciones1/ 1/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Descripción:

Esta función con gura el pin especi cado para actuar como entrada o salida digital (ver la descripción de los pins digitales del Arduino para
(https://www.prometec.net)
más información sobre la funcionalidad de estos pins). A partir de la version 1.0.1 del Arduino es posible activar las resistencias internas
“pullup” del Arduino con el modo INPUT_PULLUP. Por otra parte, el modo INPUT desactiva explícitamente las resistencias internas “pullup”.

Sintaxis:
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

pinMode(pin, modo)

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
Parámetros:

pin: el número de pin que queremos activar como entrada o salida.

modo: INPUT, OUTPUT,

SUSCRIPCIONES or INPUT_PULLUP (ver la descripción de los pins digitales del Arduino para más información sobre la funcionalidad
(HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

de estos pins).

Devuelve:

Nada (esta función simplemente activa un pin sin devolver ningún valor de retorno)

Ejemplo:

int ledPin = 13; // LED conectado al pin digital 13

void setup()
{
pinMode(ledPin, OUTPUT); // configura el pin como salida
}

void loop()
{
digitalWrite(ledPin, HIGH); // activa el LED (encendido)
delay(1000); //temporizador (espera un segundo)
digitalWrite(ledPin, LOW); // desactiva el LED (apagado)
delay(1000); // temporizador (espera un segundo)
}

Nota:

 Los pins de entrada analógica pueden ser también usados como pins digitales si nos referimos a ellos
como A0, A1, etc.

Ver también:

- constantes
- digitalWrite()
- digitalRead()
- Tutorial: Descripción de los pins del Arduino (https://www.prometec.net/entradas-digitales/).

La función digit alW r it e()

Descripción:

Activa (HIGH) o desactiva (LOW) un pin digital.

Si el pin ha sido con gurado como OUTPUT (salida) con la función pinMode(), su voltaje será activado a 5V (o 3.3V en las tarjetas que
funcionen a 3.3V) si se activa (HIGH) o a 0V (tierra) si se desactiva (LOW).

Si el pin ha sido con gurado como INPUT (entrada), digitalWrite() activará (si la usamos el parámetro HIGH) o desactivará (con LOW) la
resistencia “pullup” del pin de entrada especi cado. Se recomienda activar la resistencia interna “pullup” del pin con la función pinMode(pin,
INPUT_PULLUP). Ver la descripción de los pins digitales del Arduino para más información sobre la funcionalidad de estos pins).

Nota:

Si no con guras el pin como salida (OUTPUT) con la función pinMode() y conectas el pin a un LED, cuando uses la función
digitalWrite(HIGH), el LED no se encenderá. En efecto, si no con guras explícitamente el pin como salida con pinMode(), digitalWrite()
activa la resistencia interna “pullup” que actúa como un potente limitador de corriente.

Sintáxis:

digitalWrite(pin, valor)

Parámetros:

pin: el número de pin

https://www.prometec.net/funciones1/ 2/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
valor: HIGH or LOW

Devuelve:
(https://www.prometec.net)
nada

Ejemplo:
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

int ledPin = 13; // LED conectado al pin digital 13

void setup()
{
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
pinMode(ledPin, OUTPUT); // configura el pin digital pin como salida
}

void loop() (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

SUSCRIPCIONES

{
digitalWrite(ledPin, HIGH); // enciende el LED
delay(1000); // temporizador: espera un Segundo
digitalWrite(ledPin, LOW); //apaga el LED
delay(1000); // temporizador: un segundo
}

Este sketch active el pin 13 (HIGH) espera un Segundo y lo desactiva.

Nota:

Los pins de entrada analógica pueden ser también usados como pins digitales si nos referimos a ellos como A0, A1, etc.

Ver también:

-pinMode()
-digitalRead()
-Tutorial: Digital Pins (https://www.prometec.net/circuito-multiples-leds/)

La funct ion digit alRead()

Descripción:

Lee el valor (HIGH o LOW) del pin digital especi cado.

Sintaxis:

digitalRead(pin)

Parámetros:

pin: el número de pin digital que quieres leer (tipo int)

Devuelve:

HIGH (alta) o LOW (baja/tierra)

Ejemplo:

Activa el pin 13 al mismo valor que el leído en el pin 7 (con gurado como entrada)

int ledPin = 13; // LED conectado al pin digital13

int inPin = 7; // pulsador conectado al pin digital 7
int val = 0; // variable que almacena el valor leído

void setup()
{
pinMode(ledPin, OUTPUT); // configura el pin digital 13 como salida
pinMode(inPin, INPUT); // configura el pin digital 7 como entrada
}

void loop()
{
val = digitalRead(inPin); // lee valor en pin de entrada
digitalWrite(ledPin, val); // active el LED con el valor leído en el pulsador
}

Nota:

Si el pin no está conectado a nada, digitalRead() puede devolver indistintamente HIGH o LOW (y esto puedo cambiar de manera aleatoria).

Los pins de entrada analógica pueden ser también usados como pins digitales si nos referimos a ellos como A0, A1, etc.

https://www.prometec.net/funciones1/ 3/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Ver también:

-pinMode() (https://www.prometec.net)
-digitalWrite()
-Tutorial: Digital Pins (https://www.prometec.net/circuito-multiples-leds/)

TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
FUNCIONES DE ENTRADA/SALIDA ANALÓGICAS

SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

La función analogReference()

Descripción:

Esta función con gura el voltaje de referencia usado como entrada analógica (es decir, el valor que queremos de nir como voltaje máximo
de entrada). Las siguientes opciones son válidas:

-DEFAULT: el valor de referencia por defecto es 5 voltios (en las tarjetas Arduino que funcionan a 5V) o 3.3 voltios (en las Arduino que van
a 3.3V)

-INTERNAL: un valor de referencia interno jado en 1.1 volts en el ATmega168 o ATmega328 y 2.56 volts en el ATmega8 (no disponible en
el Arduino Mega)

-INTERNAL1V1: un valor de referencia interno jado en 1.1V (Solamente en el Arduino Mega)

-INTERNAL2V56: un valor de referencia interno jado en 2.56V (Solamente en el Arduino Mega)

-EXTERNAL: el voltaje aplicado al pin AREF pin (de 0 a 5V sólamente) es usado como referencia máxima.

Sintáxis:

analogReference(tipo)

Parámetros:

tipo: El tipo de referencia usado (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, or EXTERNAL).

Devuelve:

Nada.

Nota:

Las lecturas efectuadas con analogRead() inmediatamente tras cambiar la referencia analógica pueden no ser ables.

Advertencia:

¡No uses menos de 0V o más de 5V como voltaje de referencia externa en el pin AREF! SI estás usando una referencia externa en el pin
AREF debes con gurar la referencia como EXTERNAL antes de usar la función analogRead(). Si no lo haces así cortocircuitarás el voltaje
de referencia activo (generado internamente) y el pin AREF y, muy probablemente dañarás el micro controlador del Arduino.

Por otra parte, puedes conectar el voltaje de referencia externa al pin AREF a través de una resistencia de 5K, lo cual te permitirá pasar de
voltajes de referencia internos a externos. Advierte que la resistencia cambiará el voltaje que es usado como referencia ya que el pin AREF
está conectado internamente a una resistencia de 32K. La combinación de estas dos resistencias (interna y externa) actúa como un divisor
de voltaje. Por ejemplo, 2.5V aplicados a través de la resistencia darán 2.5 * 32 / (32 + 5) = ~2.2V en el pin AREF.

Ver también:

- Descripción de los pins de entrada analógica (https://www.prometec.net/aref/).

- analogRead()

La función analogRead()

Descr ipt ion:

Esta función lee el valor presente en el pin analógico especi cado. El Arduino lleva un convertidor analógico/digital de 10 bits con 6 canales
(8 canales en el Mini y Nano y 16 en el Mega). Esto signi ca que se pueden convertir voltajes que varíen entre 0 y 5 voltios en valores
enteros entre 0 y 1023. Esto equivale a una resolución de 5V/1024 unidades, o lo que es lo mismo 0.0049 Volts (4.9 mV) por unidad. El
rango de entrada y la resolución pueden ser cambiados usando analogReference().

La frecuencia máxima de lectura es de 10,000 veces por segundo (cada lectura dura unos 100 microsegundos).

Sintaxis:

https://www.prometec.net/funciones1/ 4/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

analogRead(pin)

(https://www.prometec.net)
Parámetros:

pin: el número de pin analógico del que se quiere leer la entrada (0 a 5 en la mayor parte de las placas, 0 a 7 en el Mini y Nano, 0 a15 en el
Mega)
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

Devuelve:

int (de 0 a 1023)

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

Nota:

Si el pin de entrada analógico no está conectado a nada, el valor devuelto por la función analogRead() uctuará dependiendo de una serie
de factores (por
SUSCRIPCIONES ejemplo,
(HTTPS:/ los valores de otras entradas analógicas, la proximidad de tu mano a la placa, etc.)
/WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

Ejemplo:

int analogPin = 3; // potenciómetro conectado al pin analógico 3

// variando entre tierra y +5V
int val = 0; // variable de almacenaje del valor leído

void setup()
{
Serial.begin(9600); // inicialización puerto serie a 9600 bps
}

void loop()
{
val = analogRead(analogPin); //leer entrada analógica
Serial.println(val); // mostrar valor leido
}

Ver también:

- analogReference()
- analogReadResolution()
- Tutorial: Analog Input Pins (https://www.prometec.net/puertas-analogicas/)

La función analogW r it e()

Descripción:

Esta función escribe en el pin indicado un valor analógico (mediante un pulso o tren de ondas cuya duración determina el valor analógico
transmitido, también llamado PWM –“Pulse Width Modulation”). Este valor puede ser utilizado para iluminar un LED con una intensidad
variable o hacer rotar el eje de un motor eléctrico a velocidades variables. Cuando usamos esta función el pin generará una onda cuadrada
constante de la duración especi cada hasta la siguiente utilización de la función sobre el mismo pin (o una utilización de digitalRead() o
digitalWrite() sobre el mismo pin). La frecuencia de la la señal PWM en la mayor parte de los pins es aproximadamente 490 Hz. En el Uno y
otras placas similares, los pins 5 y 6 tienen una frecuencia de aproximadamente 980 Hz. Los pins 3 y 4 del Leonardo también funcionan a
980 Hz.

En la mayor parte de las placas Arduino (las que van equipadas con el procesador ATmega 168 o ATmega 328), esta función puede ser
usada con los pins 3, 5, 6, 9, 10 y 11. En el Arduino Mega, funciona con los pins del 2 al 13 y del 44 al 46. Modelos más antiguos de Arduino
con el procesador ATmega8 sólo pueden ejecutar analogWrite() en los pins 9, 10 y 11.

El Arduino Due puede ejecutar analogWrite() sobre los pins del 2 al 13 más los pins DAC0 y DAC1. Contrariamente a los pins PWM, los pins
DAC0 y DAC1 son convertidores Digital -> Analógico y actúan como verdaderas salidas analógicas (es decir, producen una salida
equivalente en voltaje sin codi cación PWM)

No es necesario ejecutar la función de inicialización pinMode() para con gurar el pin como salida antes de ejecutar analogWrite().

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

Sintaxis:

analogWrite(pin, valor)

Parámetros:

pin: el número de pin en el que queremos escribir.

valor: la duración del pulso: entre 0 (OFF continuo) y 255 (ON continuo)

Devuelve:

Nada.

https://www.prometec.net/funciones1/ 5/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Notas:

Las salidas PWM generadas en los pins 5 y 6 tienen una duración mayor que la esperada. Esto es debido a interacciones con las funciones
(https://www.prometec.net)
millis()y delay() que usan el mismo temporizador interno usado para generar las salidas PWN. Este efecto puede ser apreciado
principalmente con duraciones cortas (típicamente de 0 a 10) y puede resultar en valores de 0 que no pongan totalmente a 0 los pines 5 y
6.
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
Ejemplo:

Enciende el LED con una intensidad proporcional al valor leído en la entrada conectada con el potenciómetro.
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

int ledPin = 9; // LED conectado al pin digital 9

int analogPin = 3; // potenciómetro conectado al pin analógico 3
int val = 0; // variable que almacena el valor leído (potenciómetro)
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

void setup()
{
pinMode(ledPin, OUTPUT); // configura el the pin 9 como salida
}
void loop()
{
val = analogRead(analogPin); // lee entrada potenciómetro
analogWrite(ledPin, val / 4); // analogRead oscila de 0 a 1023, analogWrite entre 0 y 255
}

Ver también:

- analogRead()
- analogWriteResolution()
- Tutorial: PWM (https://www.prometec.net/pines-cuasi-analogicos/)

FUNCIONES DE ENTRADA SALIDA DEL ARDUINO DUE

La función analogReadResolut ion()

Descripción:

La function analogReadResolution() es una extensión del API analógico (Application Programme Interface) para elArduino Due. Esta función
se usa para determinar el tamaño (en número de bits) del valor devuelto por la función analogRead(). En otras palabras: la resolución de la
lectura del valor analógico efectuada en el pin. Para asegurar la compatibilidad con los modelos más antiguos (placas basadas en el
procesador AVR) su valor por defecto es de 10 bits (es decir, devuelve valores entre 0 y 1023).

El Due tiene la capacidad de incrementar su capacidad ADC (Analog to Digital Converter) hasta 12 bits. Es decir, analogRead() puede
devolver valores entre 0 y 4095.

Sintaxis:

analogReadResolution(bits)

Parámetros:

bits: determina la resolución (en bits) del valor devuelto por la función analogRead(). Este valor puede oscilar entre 1 y 32. Puedes usar
resoluciones por encima de 12, pero los valores devueltos por analogRead()serán aproximados. Ver la nota más abajo.

Devuelve:

Nada

Nota:

Si usas analogReadResolution()con una resolución superior a la capacidad ADC real de tu placa, el Arduino te devolverá el resultado de la
lectura con su máxima resolución posible y rellenara con ceros el resto de los bits.

Por ejemplo si usamos el Due con analogReadResolution(16) obtendremos una lectura de un valor aproximado de 16 bits con los primeros
12 bits conteniendo la lectura ADC realmente efectuada y los últimos 4 bits puestos a cero.

Si, por el contrario, usas analogReadResolution() con un valor inferior de la capacidad de tu placa, perderás resolución ya que la función te
devolverá menos bits de los que el ADC de la placa obtuvo realmente.

La utilidad de usar resoluciones superiores a las que permite tu placa es que tu programa podrá ser portado a futuras placas con una
resolución ADC mayor que la actual (12) sin cambiar una sóla línea de código.
https://www.prometec.net/funciones1/ 6/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Ejemplo:

void setup() (https://www.prometec.net)

{ Serial.begin(9600); // abrir puerta serie
}

TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

void loop()
{ // leer la entrada en el pin A0 con la resolución estándar (10 bits)
// y escribir el dato obtenido por la puerta serie
analogReadResolution(10);
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
Serial.print("ADC 10-bit (estándar) : ");
Serial.print(analogRead(A0));

// cambiar
SUSCRIPCIONES la/WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
(HTTPS:/ resolución a 12 bits y leer entrada analógica A0
analogReadResolution(12);
Serial.print(", 12-bit : ");
Serial.print(analogRead(A0));

// cambiar la resolución a 16 bits y leer entrada analógica A0

analogReadResolution(16);
Serial.print(", 16-bit : ");
Serial.print(analogRead(A0));

// cambiar la resolución a 8 bits y leer entrada analógica A0

analogReadResolution(8);
Serial.print(", 8-bit : ");
Serial.println(analogRead(A0));

// introducir un a pequeño retraso para no inundar el monitor serie

delay(100);
}

Ver también:

- Descripción de los pins de entrada analógicos

- analogRead()

La función analogW r it eResolut ion()

Descripcion:

analogWriteResolution() es una extensión del API analógico para el Arduino Due. analogWriteResolution() determina la resolución de la
función analogWrite(). Su valor por defecto es 8 bits (valores entre 0 y 255) para asegurar la compatibilidad con las placas basadas en el
AVR.

El Due está equipado con:

 12 pins funcionando en 8-bit PWM, como las antiguas placas basadas en el AVR. La resolución de estos
pins se puede aumentar hasta 12 bits.

 -2 pins equipados con un DAC (Digital-to-Analog Converter) funcionado a 12 bits.

Programando la resolución de escritura a 12 bits, podemos usar analogWrite() con valores entre 0 y 4095 y aprovechar al máximo la
resolución del DAC o usar PWM sin pérdida de resolución.

Sintáxis:

analogWriteResolution(bits)

Parámetros:

bits: determina la resolución (en bits) del valor devuelto por la función analogWrite(). Este valor puede oscilar entre 1 y 32. Si se usan
resoluciones superiores o inferiores a la capacidad de la placa, el valor usado en analogWrite() será truncado si es demasiado alto o
rellenado con ceros si es demasiado baja. Ver la nota más abajo.

Devuelve:

Nada.

Nota:

https://www.prometec.net/funciones1/ 7/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Si usas analogWriteResolution() con una resolución superior a la capacidad ADC real de tu placa, el Arduino descartará los bits sobrantes.
Por ejemplo si usamos el Due con analogWriteResolution(16) sobre un pin equipado con un DAC de 12 bits, solamente los primeros 12 bits
serán transferidos a la función analogWrite() y los últimos 4 bits serán desechados.
(https://www.prometec.net)

Del mismo modo, si usas analogWriteResolution() con una resolución inferior a la capacidad de la placa, los bits que faltan serán rellenados
con ceros. Por ejemplo, si usamos el Due con analogWriteResolution(8) sobre un pin dotado de un DAC de 12 bits, el Arduino añadirá 4 bits
aTIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET)
cero a TIENDA MÉXICO (HTTPS://PROMETEC.MX)
los 8 bits usados por la función analogWrite() para obtener los 12 bits requeridos.

Ejemplo:

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
void setup()
{ // abrir puerto serie
Serial.begin(9600);
// configurar
SUSCRIPCIONES los pins 11, 12 y 13 como salidas
(HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
}
void loop()
{ //Leer la entrada de A0 y escribirla en un pin PWM
// conectado a un LED
int sensorVal = analogRead(A0);
Serial.print("Lectura Analógica) : ");
Serial.print(sensorVal);

// la resolución PWM por defecto

analogWriteResolution(8);
analogWrite(11, map(sensorVal, 0, 1023, 0 ,255));
Serial.print(" , valor 8-bit PWM : ");
Serial.print(map(sensorVal, 0, 1023, 0 ,255));

// cambiar la resolución PWM a 12 bits

// esta resolución se ofrece únicamente en el Due
analogWriteResolution(12);
analogWrite(12, map(sensorVal, 0, 1023, 0, 4095));
Serial.print(" , valor 12-bit PWM : ");
Serial.print(map(sensorVal, 0, 1023, 0, 4095));

// cambiar la resolución PWM a 4 bits

analogWriteResolution(4);
analogWrite(13, map(sensorVal, 0, 1023, 0, 127));
Serial.print(", valor 4-bit PWM : ");
Serial.println(map(sensorVal, 0, 1023, 0, 127));
delay(5);
}

Ver también:

- Descripción de los pins de entrada analógica

- analogWrite()
- analogRead()
- map()

FUNCIONES AVANZADAS DE ENTRADA/SALIDA

La función t one()

Descripcion:

tone() genera una onda cuadrada de la frecuencia especi cada (y un ciclo de trabajo del 50%) en un pin especi cado. La duración puede
ser especi cada también (en caso contrario, la onda continuará hasta recibir una llamada noTone(). El pin puede estar conectado a un
timbre piezoeléctrico o un altavoz.

Sólo podemos generar un tono a la vez. Si un tono está siendo enviado al mismo tiempo a otro pin la llamada a la función tone() no tendrá
ningún efecto (sólo se permite un tono sobre un pin en cada momento). Si el tono está ya siendo enviado a ese pin, una llamada ulterior a
tone() puede variar la frecuencia.

https://www.prometec.net/funciones1/ 8/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
El uso de la función tone() puede causar interferencias con las salidas PWM en los pins 3 y 11 (salvo en la placa Mega).

No es possible generar tonos por debajo de 31 Hz. Para más detalles consultar las notas de Brett Hagman.
(https://www.prometec.net)
Nota:

Si quieres emitir diferentes tonos en diferentes pins (no simultáneamente sino uno tras otro) tienes que ejecutar la función noTone() sobre
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
un pin antes de ejecutarla tone() sobre el siguiente pin.

Sintáxis:

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
tone(pin, frecuencia)
tone(pin, frecuencia, duración)

Parámetros:
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

pin: el pin en el cual se quiere general el tono

frecuencia: la frecuencia del tono en herzios – tipo: unsigned int

duración: la duración del tono en milisegundos (opcional) – tipo: unsigned long

Devuelve:

Nada

Ver también:

- noTone()
- analogWrite()
- Tutorial:Tone
- Tutorial:Pitch follower
- Tutorial:Simple Keyboard
- Tutorial: multiple tones
- Tutorial: PWM

La función noTone()

Descripción

Termina la generación de la onda cuadrada que fue comenzada por una función tone(). No tiene ningún efecto si no se ha ejecutado
ninguna función tone() sobre ese pin antes.

Nota: Si quieres emitir diferentes tonos en diferentes pins (no simultáneamente sino uno tras otro) tienes que ejecutar la función noTone()
sobre un pin antes de ejecutarla tone() sobre el siguiente pin.

Sintáxis:

noTone(pin)

Parámetros:

pin: el pin sobre el cual se quiere detener la generación de tono.

Devuelve:

Nada

Ver también:

- tone()

La función shift Out ()

Descripción

Emite un byte bit a bit por el pin indicado. Se puede emitir empezando por el bit de mayor peso (el primero por la izquierda) o el de menor
peso (el primero por la derecha). Cada bit se emite por riguroso orden en el pin indicado. Una vez que el bit está disponible en el pin, el pin
de reloj (clock pin) conmuta (alta al comienzo, baja a continuación) para indicar que el bit está disponible en pin de salida.

Nota: si estamos comunicando con un dispositivo que funciona con subidas de nivel en el reloj (de baja a alta), necesitarás asegurarte que
el pin de reloj está en baja antes de ejecutar la función shiftOut() con una llamada a la función digitalWrite(clockPin, LOW).

Nota: La función shiftOut() es una implementación de software; si quieres una implementación más rápida (pero que sólo funciona en
ciertos pins) la librería SPI proporciona una implementación hardware de esta funcionalidad.

Sintaxis:

https://www.prometec.net/funciones1/ 9/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

shiftOut(dataPin, clockPin, bitOrder, valor)

(https://www.prometec.net)
Parámetros:

dataPin: el pin que será usado para emitir cada bit. Tipo: int
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
clockPin: el pin usado para enviar la señal de conmutación una vez que el dataPin está emitiendo el bit correcto. Tipo: int

bitOrder: el orden en que los bits serán emitidos; sea MSBFIRST (empezando por el de mayor peso y siguiendo hacia la derecha) o
LSBFIRST (comenzando por el de menor peso y siguiendo hacia la izquierda).
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

valor: el octeto que será emitido. Tipo: byte

Devuelve:
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
Nada

Notas:

Los pins dataPin y clockPin deben de ser con gurados como salidas mediante una llamada a la función pinMode() antes de ejecutar
shiftOut().

shiftOut puede emitir sólamente un byte (octeto = 8 bits) cada vez que es ejecutada, por lo tanto se necesitan dos iteraciones para emitir
valores mayores que 255.

// Para comenzar con el bit de más peso

int data = 500;
// emitir el byte de más peso
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));
// y ahora el de menos peso
shiftOut(dataPin, clock, MSBFIRST, data);

Y este sketch para comenzar con el bit de menor peso

data = 500;
// emitir el byte de menos peso
shiftOut(dataPin, clock, LSBFIRST, data);
// y ahora el de más peso
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));

Ejemplo:

Para el circuito que acompaña a este ejemplo ver el tutorial “controlling a 74HC595 shift register (https://www.prometec.net/shift-
registers/)”.

https://www.prometec.net/funciones1/ 10/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

//**************************************************************//
// Name : shiftOutCode, Hello World //
// Author : Carlyn Maw,Tom Igoe (https://www.prometec.net)
//
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes
TIENDA ESPAÑA:(HTTPS:/
Code /STORE.PROMETEC.NET)
for using a 74HC595 Shift Register
TIENDA //
MÉXICO (HTTPS://PROMETEC.MX)
// : to count from 0 to 255 //
//****************************************************************
//Pin connected to ST_CP of 74HC595
int latchPin
TUTORIALES = 8;/STORE.PROMETEC.NET/TUTORIALES/)
(HTTPS:/

//Pin connected to SH_CP of 74HC595

int clockPin = 12;
////Pin connected to DS of 74HC595
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
int dataPin = 11;

void setup()
{ //set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}

void loop()
{ //count up routine
for (int j = 0; j < 256; j++)
{ //ground latchPin and hold low for as long as you are transmitting
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, LSBFIRST, j);
//return the latch pin high to signal chip that it
//no longer needs to listen for information
digitalWrite(latchPin, HIGH);
delay(1000);
}
}

Ver también:

- shiftIn()
- SPI

La función shift In()

Descripción:

Esta es la función inversa de la anterior (shiftOut). La función shiftIn() lee un byte bit a bit del pin de entrada especi cado. Como en la
función anterior (shiftout) podemos especi car el sentido de lectura (de izquierda a derecha o viceversa). Cada operación de lectura se
realiza así: cuando el pin reloj (“clock pin”) se pone en alta (HIGH) se procede a leer el bit en el pin, a continuación el pin reloj se pone en
baja tensión (LOW).

Si estamos comunicando con un dispositivo que funciona con subidas de nivel en el reloj (de baja a alta), necesitarás asegurarte que el pin
de reloj está en baja antes de ejecutar la función shiftIn() con una llamada a la función digitalWrite(clockPin, LOW).

La función shiftIn() es una implementación de software; si quieres una implementación más rápida (pero que sólo funciona en ciertos pins)
la librería SPI proporciona una implementación hardware de esta funcionalidad.

Sintaxis:

byte leido = shiftIn(dataPin, clockPin, bitOrder)

Parámetros:

dataPin: el pin que será usado para leer cada bit. Tipo: int

clockPin: el pin usado para enviar la señal de conmutación una vez que el dataPin ha leido el bit correcto. Tipo: int

bitOrder: el orden en que los bits serán emitidos; sea MSBFIRST (empezando por el de mayor peso y siguiendo hacia la derecha) o
LSBFIRST (comenzando por el de menor peso y siguiendo hacia la izquierda). (Most Signi cant Bit First, or, Least Signi cant Bit First

Devuelve:

Nada

Ver también:

https://www.prometec.net/funciones1/ 11/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

- shiftOut()
- SPI
(https://www.prometec.net)

La función pulseIn()
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

Descripción:

Lee un pulso (HIGH o LOW) de un pin determinado. Por ejemplo, si el valor especi cado como parámetro es HIGH, pulseIn() espera a que el
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
pin esté en HIGH, en ese momento comienza la cuenta (timing) hasta que la tensión en el pin esté en LOW momento en que cesa la
cuenta. pulseIn() devuelve la duración del pulso en microsegundos. Asimismo, pulseIn() devuelve control con un cero como return si el pulso
no comienza dentro de un periodo especi cado (time out)
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
El resultado de esta función ha sido determinado de manera empírica y probablemente muestra errores cuando los pulsos son demasiado
largos. pulseIn() funciona con pulsos desde 10 microsegundos hasta 3 minutos de duración.

Sintaxis:

pulseIn(pin, value)
pulseIn(pin, value, timeout)

Parámetros:

pin: El número del pin del que se quiere leer el la duración del pulso. Tipo: int

value: El tipo de pulso que se quiere leer (HIGH o LOW). Tipo: int

timeout (opcional): el número de microsegundos que se quiere esperar para que comienze el pulso; por defecto es un segundo. Tipo:
unsigned long

Devuelve:

La duración del pulso (en microsegundos) o 0 si el pulso no comenzó antes del tiempo límite (time out). Tipo: unsigned long

Ejemplo:

int pin = 7;
unsigned long duration;
void setup()
{ pinMode(pin, INPUT);
}
void loop()
{
duration = pulseIn(pin, HIGH);
}

FUNCIONES DE TIEMPO

La función millis()

Descripción:

Esta función devuelve el número de milisegundos transcurridos desde que el Arduino comenzó a ejecutar el programa en curso. Este
número será puesto a cero de nuevo cada 50 días (aproximadamente).

Parámetros:

Ninguno

Devuelve:

Número de milisegundos transcurridos desde que el Arduino comenzó a ejecutar el programa en curso. Tipo: unsigned long

Ejemplo:

https://www.prometec.net/funciones1/ 12/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

unsigned long time;

void setup()
{ Serial.begin(9600); (https://www.prometec.net)
}
void loop()
{ Serial.print("Tiempo:
TIENDA ");
ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
time = millis();
//muestra el tiempo transcurrido desde que comenzó el programa
Serial.println(time);
// espera
TUTORIALES un
(HTTPS:/ Segundo para no inundar la pantalla de datos.
/STORE.PROMETEC.NET/TUTORIALES/)

delay(1000);
}

SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
Nota:

Ten en cuenta que millis() devuelve un unsigned long, se producirán errores si tratas a este número como si tuviera otro tipo (por ejemplo
int).

Ver también:

- micros()
- delay()
- delayMicroseconds()
- Tutorial: Blink Without Delay

La función micros()

Descripción:

Esta función devuelve el número de microsegundos transcurridos desde que el Arduino comenzó a ejecutar el programa en curso. Este
número será puesto a cero de nuevo cada 70 minutos (aproximadamente). En las placas que funcionan a 16 MHz (por ejemplo el
Duemilanove y el Nano), esta función tiene una resolución de 4 microsegundos (es decir, el valor devuleto es siempre un múltiplo de 4). En
placas Arduino funcionando a 8 MHz (por ejemplo el LilyPad), esta función tiene una resolución de 8 microsegundos.

Parámetros:

Ninguno

Devuelve:

Número de microsegundos transcurridos desde que el Arduino comenzó a ejecutar el programa en curso. Este número será puesto a cero
de nuevo cada 70 minutos (aproximadamente). Tipo: unsigned long.

Nota: un milisegundo tiene 1,000 microsegundos y un segundo 1,000,000 de microsegundos.

Ejemplo:

unsigned long time;

void setup()
{ Serial.begin(9600);
}
void loop()
{ Serial.print("Tiempo: ");
time = micros(); // muestra el tiempo transcurrido desde que comenzó el programa
Serial.println(time);
// espera un Segundo para no inundar la pantalla de datos.
delay(1000);
}

Ver también:

- millis()
- delay()
- delayMicroseconds

La función delay ()

Description:

Introduce una pausa en el programa de una duración especi cada (en milisegundos) como parámetro. (1 segundo = 1000 milisegundos)

Sintaxis:

delay(ms)

https://www.prometec.net/funciones1/ 13/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Parámetros:

ms: la duración de la pausa en número de milisegundos. Tipo: unsigned long

(https://www.prometec.net)
Devuelve:

Nada.
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
Ejemplo:

int ledPin = 13; // LED conectado al pin digital13

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
void setup()
{ pinMode(ledPin, OUTPUT); // configura el pin digital como salida
}
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
void loop()
{
digitalWrite(ledPin, HIGH); // enciende el LED
delay(1000); // pausa de 1 segundo
digitalWrite(ledPin, LOW); // apaga el LED
delay(1000); // otra pausa de 1 segundo
}

Nota:

Es relativamente fácil programar un LED intermitente con la función delay(). De hecho muchos sketches usan esta función con similares
propósitos.

Sin embargo el uso de delay() tiene algunos inconvenientes. Por ejemplo, durante el tiempo que el sketch está es estado de pausa no se
puede leer la entrada de sensores, ni realizar cálculos o manipular pins. En otras palabras la función delay() prácticamente paraliza toda
actividad en el Arduino.

Para paliar este problema los programadores usan la función millis() (ver el sketch citado más abajo). Sin embargo, las interrupciones no
quedan bloqueadas por la función delay(). Las comunicaciones en serie vía el pin RX quedan registradas y los valores y estados de los pins
PWM (analogWrite) se mantiene durante la pausa.

Ver también:

- millis()
- micros()
- delayMicroseconds()
- Blink Without Delay example

La función delay Microseconds()

Descripción:

Esta función detiene la ejecución del programa durante el tiempo (en microsegundos) indicado por el parámetro.

De momento el valor máximo para el parámetro tiempo es de 16383 microsegundos (aunque esto puede cambiar en futuras versiones del
Arduino). Para pausas de más de unos cuantos miles de microsegundos se debe usar delay() en vez de esta función.

Sintaxis:

delayMicroseconds(us)

Parámetros:

us: el número de microsegundos que dura la pausa. Tipo: unsigned int

Devuelve:

Nada.

Ejemplo:

https://www.prometec.net/funciones1/ 14/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

int outPin = 8; // pin digital 8

void setup()
{ (https://www.prometec.net)
pinMode(outPin, OUTPUT); // configura el pin digital como salida
}
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
void loop()
{
digitalWrite(outPin, HIGH); // Pone el pin en alta
delayMicroseconds(50);
TUTORIALES // Pausa de 50
(HTTPS://STORE.PROMETEC.NET/TUTORIALES/) microsegundos
digitalWrite(outPin, LOW); // Pone el pin en baja
delayMicroseconds(50); // Pausa de 50 microsegundos
}
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

Este sketch con gura el pin número 8 como un pin de salida y envía un tren de pulsos con un periodo de 100 microsegundos.

Problemas conocidos:

Esta function es muy able a partir de 3 microsegundos. No se garantiza que delayMicroseconds funcione de forma precisa con tiempos
inferiores a éste.

A partir del modelo0018 del Arduino, delayMicroseconds() no desactiva las interrupciones.

Ver también:

- millis()
- micros()
- delay()

FUNCIONES MATEMÁTICAS

La función min(x , y)

Descripción:

Calcula el mínimo de dos números.

Parámetros:

x: el primer número (de cualquier tipo)

y: el segundo número (de cualquier tipo)

Devuelve:

El menor de los dos números.

Ejemplo:

sensVal = min(sensVal, 100); // asigna a la variable sensVal el menor de sensVal y 100

// sirve también para asegurarse que la variable nunca supera el valor 100.

Nota:

Por extraño que parezca, la función max() se usa a menudo para limitar el valor mínimo de una variable y la min() para limitar el máximo.

Advertencia:

Debido a la manera en que la función min() ha sido implementada es recomendable evitar usar otras funciones dentro de los paréntesis
conteniendo los parámetros. Por ejemplo:

min(a++, 100); // es a evitar ya que devuelve resultados incorrectos.

Esta otra manera de usarla es, en cambio, más segura:

a++;

min(a, 100); // usar esta modalidad. ¡No incluir funciones dentro del paréntesis!

Ver también:

https://www.prometec.net/funciones1/ 15/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

- max()
- constrain()
usando (https://www.prometec.net)

TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

La función max (x , y)

Descripción:Calcula el máximo de dos números.

Parámetros:
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

x: el primer número (de cualquier tipo)

y: el segundo número
SUSCRIPCIONES (de cualquier tipo)
(HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

Devuelve:

El mayor de los dos números.

Ejemplos:

sensVal = max(sensVal, 20); // asigna a la variable sensVal el mayor de sensVal y 20

// sirve también para asegurarse que la variable nunca es inferior a 20

Nota:

Por extraño que parezca, la función max() se usa a menudo para limitar el valor mínimo de una variable y la min() para limitar el máximo.

Advertencia:

Debido a la manera en que la función max() ha sido implementada es recomendable evitar usar otras funciones dentro de los paréntesis
conteniendo los parámetros. Por ejemplo:

max(a–, 100); // es a evitar ya que devuelve resultados incorrectos.

Esta otra manera de usarla es, en cambio, más segura:

a–;

min(a, 100); // usar esta modalidad. ¡No incluir funciones dentro del paréntesis!

Ver también:

- min()
- constrain()

La función abs(x )

Descripción:

Calcula el valor absoluto de un número.

Parámetros:

x: el número

Devuelve:

x: si x es mayor o igual que 0.

-x: si x es menor que 0.

Advertencia:

Debido a la manera en que la función abs() ha sido implementada es recomendable evitar usar otras funciones dentro de los paréntesis
conteniendo los parámetros. Por ejemplo:

abs(a++); // es a evitar ya que devuelve resultados incorrectos.

a++; // usa esta modalidad

abs(a); //¡no incluir funciones dentro de abs()!

La función const rain(x , a, b)

Descripción:

Limita a un número a permanecer dentro de un rango.

Parámetros:

https://www.prometec.net/funciones1/ 16/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
x: El número a limitar (de cualquier tipo)

a: El límite inferior (de cualquier tipo)

(https://www.prometec.net)
b: El límite superior (de cualquier tipo).

Devuelve:
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
x: si x está entre a y b

a: si x < a
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
b: si x > b

Ejemplo:
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
sensVal = constrain(sensVal, 10, 150);
// limita el range de valores leidos del sensor entre 10 y 150

Ver también:

- min()
- max()

La función map(v alue, fromLow, fromHigh, t oLow, t oHigh)

Descripción:

Trasforma un número de una escala a otra. Es decir, un valor (“value”) igual a “fromLow” se transformaría en “toLow” y un valor igual a
“fromHigh” se transformaría en “toHigh”. Los valores dentro del rango fromLow-fromHigh se transformarían proporcionalmente en valores
dentro del rango toLow-toHigh.

Esta función no limita a los valores a estar dentro del rango (si es esto lo que quieres conseguir, debes de usar la función constrain()). En
efecto, a veces es útil trabajar con valores fuera de rango.

El límite inferior de cualquiera de los dos rangos puede ser menor o mayor que el límite superior. De hecho esto puede ser muy útil cuando
queremos usar la función map() para invertir un rango. Por ejemplo para transformar un valor de un rango creciente a otro decreciente,
como por ejemplo:

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

La función map() puede manejar también rangos que empiezan o terminan en la zona negativa, como por ejemplo:

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

La función map() trabaja con números enteros y por lo tanto no genera números fraccionarios. Los restos fraccionarios son truncados (no
redondeados).

Parámetros:

value: el valor a transformar de escala.

fromLow: el límite inferior del rango origen

fromHigh: el límite superior del rango origen

toLow: el límite inferior del rango destino

toHigh: el límite superior del rango destino

Devuelve:

El valor transformado en el rango de destino.

Ejemplo:

/* Transforma un valor analógico (entre 0 y 1023) a un valor en 8 bits (0 to 255) */

void setup() {}
void loop()
{ int val = analogRead(0);
val = map(val, 0, 1023, 0, 255);
analogWrite(9, val);
}

Apéndice:

Para los a cionados a las matemáticas, ahí va el código de esta función:

https://www.prometec.net/funciones1/ 17/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

long map(long x, long in_min, long in_max, long out_min, long out_max)
{ return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
} (https://www.prometec.net)

Ver también:
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
– constrain()

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
La función pow(base, ex ponent )

Descripción

Calcula el valor(HTTPS:/
SUSCRIPCIONES de un /WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
número elevado a una potencia. Pow() puede ser usado también para elevar un número a una potencia fraccional.
Esto es muy útil para generar los valores de una curva (que generalmente se expresa en términos de exponentes fraccionales).

Parámetros:

base: el número. Tipo: oat

exponent: la potencia a la que la base es elevada. Tipo: oat

Devuelve:

El resultado de la exponenciación. Tipo: double

Ejemplo:

Ver la función “fscale” de la librería “code”.

Ver también:

– sqrt()

– oat

– double

La función sqr t (x )

Descripción:

Calcula la raíz cuadrada de un número.

Parámetros:

x: el número (de cualquier tipo)

Devuelve:

La raíz cuadrada del número. Tipo: double

Ver también:

- pow()
- sq()

La función sin(rad)

Descripción:

Calcula el seno de un ángulo (expresado en radianes). El resultado estará comprendido entre -1 y 1.

Parámetros:

rad: el ángulo en radianes. Tipo: oat

Devuelve:

El seno del ángulo. Tipo: double

Ver también:

- cos()
- tan()
- float
- double

La función cos(rad)

https://www.prometec.net/funciones1/ 18/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

Descripción:

Calcula el coseno de un ángulo (expresado en radianes). El resultado estará comprendido entre -1 y 1.

(https://www.prometec.net)

Parámetros:

rad: el ESPAÑA
TIENDA ángulo en radianes.
(HTTPS:/ Tipo: oat
/STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

Devuelve:

El coseno del ángulo. Tipo: double

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

Ver también:

-sin()
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
-tan()
-float
-double

La función t an(rad)

Descripción:

Calcula la tangente de un ángulo (expresado en radianes). El resultado estará comprendido entre -∞ y +∞.

Parámetros:

rad: el ángulo en radianes. Tipo: oat

Devuelve:

La tangente del ángulo. Tipo: double

Ver también:

-sin()
-cos()
-float
-double

FUNCIONES ALEATORIAS

La función randomSeed(seed)

Descripción:

randomSeed() sirve para inicializar el pseudo generador de números aleatorios. El parámetro le dice a la función en que punto de la
secuencia debe de comenzar. Esta secuencia, que es muy larga y aleatoria es siempre la misma.

En caso de que necesitemos que la secuencia de números generados por la función random() sea diferente en diferentes ejecuciones del
mismo sketch se recomienda el uso de randomSeed() para inicializar el generador de números aleatorios con una entrada (seed) más o
menos aleatoria (como por ejemplo la lectura de analogRead() en un pin libre).

Por otra parte, puede ser interesante en ciertas ocasiones disponer de series de números pseudo aleatorios que se repiten exactamente de
la misma manera. Esto puede conseguirse llamando a randomSeed() con número jo antes de comenzar la secuencia aleatoria.

Parámetros:

seed: número de base para establecer la secuencia. Tipo: long, int

Devuelve:

Nada

Ejemplo:

https://www.prometec.net/funciones1/ 19/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

long randNumber;
void setup()
{ Serial.begin(9600); (https://www.prometec.net)
randomSeed(analogRead(0));
}
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
void loop()
{ randNumber = random(300);
Serial.println(randNumber);
delay(50);
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

Ver también:
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

- random

La función random()

Descripción:

La función random() general números pseudo-aleatorios.

Sintaxis:

random(max)
random(min, max

Parámetros:

min – límite inferior del valor aleatorio, inclusive (opcional)

max – límite superior de valor aleatorio, exclusive

Devuelve:

Un número aleatorio entre min y max-1 (tipo: long)

Nota:

En caso de que necesitemos que la secuencia de números generados por la función random() sea diferente en diferentes ejecuciones del
mismo sketch se recomienda el uso de randomSeed() para inicializar el generador de números aleatorios con una entrada (seed) más o
menos aleatoria (como por ejemplo la lectura de analogRead() en un pin libre).

Por otra parte, puede ser interesante en ciertas ocasiones disponer de series de números pseudo aleatorios que se repiten exactamente de
la misma manera. Esto puede conseguirse llamando a randomSeed() con número jo antes de comenzar la secuencia aleatoria.

Ejemplo:

long randNumber;

void setup()
{ Serial.begin(9600);
// si el pin de entrada analógica 0 no está conectado, el ruido aleatorio analógico
// origina que la llamada a randomSeed() genere
// números de inicialización (seed) diferentes cada vez que se ejecute el sketch.
// randomSeed() hará que la función random() devuelva diferentes secuencias.

randomSeed(analogRead(0));
}

void loop()
{ // imprimir un número aleatorio comprendido entre 0 y 299
randNumber = random(300);
Serial.println(randNumber);
// imprimir un número aleatorio comprendido entre 10 y 19
randNumber = random(10, 20);
Serial.println(randNumber);
delay(50);
}

Ver también:

- randomSeed()

https://www.prometec.net/funciones1/ 20/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

(https://www.prometec.net)
FUNCIONES CON BITS Y BYTES

TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

La función lowBy t e()

Descripción:
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

Extrae el octeto (byte) de menor peso de una variable (el byte más a la derecha).

Sintaxis:
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

lowByte(x)

Parámetros:

x: un valor de cualquier tipo.

Devuelve:

Un byte

Ver también:

– highByte()

– word()

La función highBy t e()

Descripción:

Extrae el octeto (byte) de mayor peso de una palabra (o el segundo byte de menor peso de un tipo de datos de mayor tamaño).

Sintaxis:

highByte(x)

Parámetros:

x: un valor de cualquier tipo.

Devuelve:

Un byte

Ver también:

- lowByte()
- word()

La función bit Read()

Descripción:

Lee un bit de un número en una posición especi cada.

Sintáxis:

bitRead(x, n)

Parámetros:

x: el número delque se lee el bit.

n: la posición de bit que se quiere leer dentro del número. Comenzando por la derecha (posición 0)

Devuelve:

El valor del bot (0 or 1).

Ver también:

https://www.prometec.net/funciones1/ 21/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

- bit()
- bitWrite()
- bitSet() (https://www.prometec.net)
- bitClear()

TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

La función bitW r it e()

Descripción:
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

Escribe un bit en una variable numérica en una posición especi cada.

Sintaxis
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

bitWrite(x, n, b)

Parámetros:

x: La variable numérica en la cual se desea escribir.

n: La posición de bit en la que se quiere escribir dentro del número. Comenzando por la derecha (posición 0).

b: El valor que se quiere escribir en esa posición de bit (0 o 1)

Devuelve:

Nada

Ver también:

- bit()
- bitRead()
- bitSet()
- bitClear()

La función bit Set ()

Descripción:

Pone a 1 el bit especi cado en una variable.

Sintaxis:

bitSet(x, n)

Parámetros:

x: La variable numérica en la cual se desea poner a 1 un bit especi cado.

n: La posición del bit que se quiere poner a 1. Comenzando por la derecha (posición 0).

Devuelve:

nada

Ver también:

- bit()
- bitRead()
- bitWrite()
- bitClear()

La función bit Clear ()

Descripción:

Pone a 0 el bit especi cado en una variable.

Sintaxis:

bitClear(x, n)

Parámetros:

x: La variable numérica en la cual se desea poner a 0 un bit especi cado.

n: La posición del bit que se quiere poner a 0. Comenzando por la derecha (posición 0).

https://www.prometec.net/funciones1/ 22/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Devuelve:

nada
(https://www.prometec.net)
Ver también:

- bit()
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
- bitRead()
- bitWrite()
- bitSet()
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

La función bit ()
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
Descripción:

Calcula el valor del bit especi cado (el bit 0 vale 1, el bit 1 vale 2, el bit 2 vale 4, etc.).

Sintaxis:

bit(n)

Parámetros:

n: la posición del bit cuyo valor queremos calcular

Devuelve:

El valor del bit especi cado

Ver también:

- bitRead()
- bitWrite()
- bitSet()
- bitClear()

INTERRUPCIONES EXTERNAS

La función at t achInt er r upt ())

Descripción:

Esta función determina la rutina (programa) que se ha de ejecutar cuando se presenta una interrupción. La ejecución de attachInterrupt()
reemplaza cualquier otra función de interrupción que estuviera asociada con esa interrupción. La mayor parte de las placas Arduino tiene
dos entradas para interrupciones externas: la número 0 (asociada con el pin digital No 2) y la número 1 (asociada al pin digital número 3).
La tabla de abajo muestra los pins disponibles para interrupciones en las diferentes placas:

Board int.0 int.1 int.2 int.3 int.4 int.5

UnoEthernet 2 3
Mega2560 2 3 21 20 19 18
Leonardo 3 2 0 1 7

El Arduino Due tiene muchas más posibilidades ya que nos permite asociar una función de interrupción a cualquier pin disponible. Para
hacerlo basta con especi car directamente el número de pin en la función attachInterrupt().

Nota:

Dentro de la función asociada (ISR = Interrupt Service Routine) la función delay() no puede funcionar y el valor devuelto por millis() no se
incrementará. Los datos recibidos por la puerta serie mientras la rutina ISR es ejecutada se perderán. Todas las variables que deban de ser
modi cadas por la rutina ISR deben de ser declaradas como “volatile”. Ver las explicaciones sobre las rutinas ISR a continuación.

Usando Interrupciones:

Las interrupciones son una técnica muy útil para que ciertas cosas se hagan automáticamente (por ejemplo para detectar entradas de
usuario o leer variaciones en un codi cador angular y además pueden ayudar a resolver problemas de temporización y sincronización.

Si, por ejemplo, quieres activar el procesador del Arduino solamente cuando suceda un cierto evento: un sensor que detecta la caída de
una moneda, o una entrada desde el teclado, o un cambio en el pulso emitido por un codi cador angular, el uso de interrupciones puede
liberar al microprocesador para realizar otras tareas mientras no se presenta la interrupción (en vez de estar muestreando todo el tiempo

https://www.prometec.net/funciones1/ 23/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
para ver el estado de un determinado pin).

Rutinas de Interrupción (ISR = “Interrupt Service Routines”):

(https://www.prometec.net)
Las rutinas ISRs son funciones especiales que tienen algunas limitaciones con respecto a una función normal. Por ejemplo, una ISR no
puede tener parámetros y no devuelve nada.
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
Generalmente una ISR debe de ser tan corta y rápida como posible. Si tu sketch usa varias ISR, sólo una puede ser ejecutada a la vez,
todas las demás interrupciones serán desactivadas hasta que la que está en curso haya sido tratada.

Como las funciones Como las funciones delay() y millis() están basadas en el uso de interrupciones, no pueden funcionar mientras una ISR
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
esté siendo ejecutada. Sin embargo delayMicroseconds(), que no utiliza interrupciones, funcionará normalmente.

Normalmente se usan variables gobales para pasar datos entre la ISR y el programa principal. Para asegurarse de que las variables usadas
dentro de una ISR son actualizadas correctamente hay que declararlas como “volatile”.
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

Para más información sobre interrupciones ver las notas de Nick Gammon sobre este tema.

Sintaxis:

attachInterrupt(interrupt, ISR, mode)

attachInterrupt(pin, ISR, mode) (sólo en el Arduino Due)

Parámetros:

interrupt: el número de interrupción. Tipo: int

pin: el número de pin (sólo en el Arduino Due only)

ISR: La rutina ISR que debe de ser llamada cuando esta interrupción se active; esta función no usa parámetros y no devuelve ningún valor.

mode: de ne cuándo se activa la interrupción. Hay cuatro casos prede nidos:

 LOW activa la interrupción siempre que el pin esté en baja (LOW)

 CHANGE activa la interrupción cuando el pin cambia de estado (de alta a baja o viceversa)

 RISING activa la interrupción cuando el pin pasa de baja a alta (low -> high)

 FALLING activa la interrupción cuando el pin pasa de alta a baja (high -> low)

El Due permite también:

 HIGH activa la interrupción siempre que el pin esté en alta (HIGH).(Arduino Due only)

Devuelve:

Nada

Ejemplo:

int pin = 13;

volatile int state = LOW;
void setup()
{ pinMode(pin, OUTPUT);
attachInterrupt(0, blink, CHANGE);
}
void loop()
{ digitalWrite(pin, state);
}
void blink()
{ state = !state;
}

Ver también:

- detachInterrupt

La función det achInt er r upt ()

Descripción:

Desactiva una interrupción dada.

Sintaxis:

https://www.prometec.net/funciones1/ 24/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

detachInterrupt(interrupt)

(https://www.prometec.net)
detachInterrupt(pin) (sólo en el Arduino Due)

Parámetros:
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

interrupt: el número de interrupción a desactivar (ver attachInterrupt() para más información).

pin: el número de number de la interrupción a desativar (sólo en el Arduino Due)

TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

Ver también:

- attachInterrupt()
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

FUNCIONES DE INTERRUPCIÓN

La función int er r upt s()

Descripción:

Esta función vuelve a activar las interrupciones (tras que éstas hayan sido desactivadas por la función noInterrupts()). Las interrupciones
permiten la ejecución de ciertas tareas importantes mientras el procesador ejecuta un sketch y están activadas por defecto.

Algunas funciones no podrán ser llamadas mientras las interrupciones estén desactivadas (porque utilizan interrupciones) y las
comunicaciones de entrada no serán leídas. Las interrupciones pueden incrementar el tiempo de ejecución del código principal. Por esta
razón puede ser recomendable desactivarlas durante la ejecución de partes particularmente importantes del código de nuestro sketch.

Parámetros:

Ninguno

Devuelve:

Nada

Ejemplo:

void setup() {}

void loop()
{ noInterrupts();
//incluir aquí el código crucial que no puede verse interrumpido.
interrupts();
//el resto del código aquí
}

Ver también:

- noInterrupts()
- attachInterrupt()
- detachInterrupt()

La funciónn oIint er r upt s()

Descripción:

Esta función desactiva las interrupciones (puedes activarlas con la función interrupts() que acabamos de ver). Las interrupciones permiten la
ejecución de ciertas tareas importantes mientras el procesador ejecuta un sketch y están activadas por defecto.

Algunas funciones no podrán ser llamadas mientras las interrupciones estén desactivadas (porque utilizan interrupciones) y las
comunicaciones de entrada no serán leídas. Las interrupciones pueden incrementar el tiempo de ejecución del código principal.

Por esta razón puede ser recomendable desactivarlas durante la ejecución de partes particularmente importantes del código de nuestro
sketch.

Parámetros:

Ninguno

https://www.prometec.net/funciones1/ 25/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Devuelve:

Nada
(https://www.prometec.net)
Ejemplo:

void setup()
TIENDA {}
ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
void loop()
{ noInterrupts();
//incluir aquí el código crucial que no puede verse interrumpido.
interrupts();
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)

//el resto del código aquí

}

SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
Ver también:

- interrupts()
- attachInterrupt()
- detachInterrupt()

FUNCIONES DE COMUNICACIONES

Funciones de comunicaciones en ser ie (ser ial)

Los puertos de comunicación serie se usan para la comunicación entre el Arduino y un ordenador u otros dispositivos. Todos los Arduinos tienen
por lo menos un puerto serie (también conocido como UART o USART). El Arduino usa los pins digitales 0 (RX) y 1 (TX) como puerto serie
(llamado “serial”).

También se puede usar la salida USB para comunicar en serie con el ordenador vía el USB. Recuerda que si utilizas la función serial no puedes
usar los pins 0 y 1 como entrada o salida digital. (RX es el pin de recepción y TX en de transmisión)

Puedes usar el monitor serie incorporado en el ambiente de programación del Arduino para comunicar con un Arduino. Haz clic el botón serial
del monitor en la barra de herramientas y selecciona la misma velocidad usada con la función begin().

El Arduino Mega tiene tres puertos serie adicionales: Serial1 en los pins 19 (RX) y 18 (TX), Serial2 en los pins 17 (RX) y 16 (TX), Serial3 en los
pins 15 (RX) y 14 (TX). Para utilizar estos pins para comunicar con tu ordenador, necesitarás un adaptador USB-serie adicional, pues no están
conectados con el adaptador USB-serie del Mega.

Si los quieres usar para comunicar con un dispositivo serial externo TTL, conecta el pin de TX con el pin del RX del dispositivo externo, el RX
con el pin del TX del dispositivo externo, y la tierra del mega con la tierra del dispositivo externo. (importante: no conectes estos pins
directamente con un puerto serie RS232 ya estos funcionan a +/- 12V y pueden dañar tu Arduino).

El Arduino Due tiene tres puertos serie TTL a 3.3V adicionales: Serial1 en los pins 19 (RX) y 18 (TX); Serial2 en los pins 17 (RX) y 16 (TX), Serial3
en los pins 15 (RX) y 14 (TX). Los pins 0 y 1 también están conectados con los pins correspondientes del microprocesador serial de ATmega16U2
USB-TTL, que está conectado con el puerto “debug” del USB. Además, hay un puerto serie USB nativo en el microprocesador de SAM3X.

El Arduino Leonardo utiliza Serial1 para comunicar vía serie TTL #5V# en los pins 0 (RX) y 1 (TX). Serial está reservado para la comunicación de
la CDC del USB. Para más información, acceda a la documentación del Leonardo.

La función if(Ser ial)

Description:

Esta función (introducida con el Arduino 1.0.1) indica si el puerto serie especi cado está activado.

En el Leonardo esta función indica si la conexión serie USB CDC está activada. En todos los demás casos, incluyendo if(Serial1) en el
Leonardo, esta función devolverá siempre “true”.

Sintaxis:

Para todos los modelos:

if (Serial)

Para el Arduino Leonardo:

if (Serial1)

https://www.prometec.net/funciones1/ 26/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino
Para el Arduino Mega:

if (Serial1) (https://www.prometec.net)
if (Serial2)
if (Serial3)

TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)

Parámetros:

ninguno
TUTORIALES (HTTPS://STORE.PROMETEC.NET/TUTORIALES/)
Devuelve:

Un valor tipo boolean : “true” si el puerto serie especi cado está disponible. En el Leonardo esta función sólo devolverá “false” si la
conexión serie USB CDC no está activada.
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)

Ejemplo:

void setup()
{ //Initializar puerto serie y esperar a que esté activado:
Serial.begin(9600);
while (!Serial)
{ ; //esperar a que el puerto se abra. Necesario sólo en el Leonardo
}
}

void loop()
{ //aqui va el programa de comunicaciones…
}

Ver también:

- begin()
- end()
- available()
- read()
- peek()
- flush()
- print()
- println()
- write()
- SerialEvent()

La función av ailable()

Descripción:

Esta función devuelve el número de bytes (caracteres u octetos) disponibles para su lectura desde el puerto serie. Estos son los bytes que
han llegado ya al puerto serie y ha sido almacenados en el buffer de recepción en serie (que tiene una capacidad total de 64 bytes). La
función available() hereda de la clase Stream.

Sintaxis:

Serial.available()

Para l Arduino Mega solamente:

Serial1.available()
Serial2.available()
Serial3.available()

Parámetros:

none

Devuelve:

El número de bytes disponibles para su lectura.

Ejemplo:

https://www.prometec.net/funciones1/ 27/28
8/11/2019 GUIA A LA PROGRAMACION DEL ARDUINO | Tienda y Tutoriales Arduino

int incomingByte = 0; // para datos llegando por el puerto serie.

void setup() (https://www.prometec.net)

{ Serial.begin(9600); // abre el Puerto serie y la configura a 9600 bps
}
TIENDA ESPAÑA (HTTPS://STORE.PROMETEC.NET) TIENDA MÉXICO (HTTPS://PROMETEC.MX)
void loop()
{ // enviar datos solo cuando los has recibido:
if (Serial.available() > 0)
{ //
TUTORIALES (HTTPS:/ lee el byte que ha llegado:
/STORE.PROMETEC.NET/TUTORIALES/)

incomingByte = Serial.read();
// muestra lo que has recibido:
Serial.print("He recibido: ");
SUSCRIPCIONES (HTTPS://WWW.PROMETEC.NET/CUENTA-DE-MEMBRESIA/TIPOS-DE-SUSCRIPCION/)
Serial.println(incomingByte, DEC);
}
}

Ejemplo para el Arduino Mega:

void setup()
{ Serial.begin(9600);
Serial1.begin(9600);
}

void loop()
{ // read from port 0, send to port 1:
if (Serial.available())
{ int inByte = Serial.read();
Serial1.print(inByte, BYTE);
}
// read from port 1, send to port 0:
if (Serial1.available())
{
int inByte = Serial1.read();
Serial.print(inByte, BYTE);
}
}

Ver también:

-begin()
-end()
-available()
-read()
-peek()
-flush()
-print()
-println()
-write()
-SerialEvent()
-Stream.available()

Copyright Prometec (https://www.prometec.net) (https (https (https

https://www.prometec.net/funciones1/ 28/28