preparar()

La función setup () se llama cuando comienza un boceto. Úselo para inicializar variables, modos de
pin, comenzar a usar bibliotecas, etc. La función de configuración solo se ejecutará una vez,
después de cada encendido o reinicio de la placa Arduino.

Ejemplo

int buttonPin = 3;

configuración nula ()

Serial.begin (9600);

pinMode (buttonPin, INPUT);

bucle vacío ()

// ...

lazo()

Después de crear una función setup (), que inicializa y establece los valores iniciales, la función
loop () hace exactamente lo que sugiere su nombre y realiza bucles consecutivos, permitiendo que
su programa cambie y responda. Úselo para controlar activamente la placa Arduino.

Ejemplo

const int buttonPin = 3;

// setup inicializa serial y el pin del botón

configuración nula ()

Serial.begin (9600);

pinMode (buttonPin, INPUT);

// loop comprueba el pin del botón cada vez,

// y enviará en serie si se presiona

bucle vacío ()
{

if (digitalRead (buttonPin) == ALTO)

Serial.write ('H');

más

Serial.write ('L');

retraso (1000);

if (condicional) y ==,! =, <,> (operadores de comparación)

if, que se usa junto con un operador de comparación, prueba si se ha alcanzado una determinada
condición, como una entrada que está por encima de un cierto número. El formato para una
prueba if es:

if (someVariable> 50)

// haz algo aquí

El programa prueba para ver si someVariable es mayor que 50. Si es así, el programa toma una
acción particular. Dicho de otra manera, si la declaración entre paréntesis es verdadera, se
ejecutan las declaraciones dentro de los corchetes. Si no, el programa salta el código.

Los corchetes pueden omitirse después de una declaración if. Si se hace esto, la siguiente línea
(definida por el punto y coma) se convierte en la única declaración condicional.

if (x> 120) digitalWrite (LEDpin, HIGH);

si (x> 120)

digitalWrite (LEDpin, ALTO);

if (x> 120) {digitalWrite (LEDpin, HIGH); }

si (x> 120) {

digitalWrite (LEDpin1, HIGH);

digitalWrite (LEDpin2, HIGH);

} // todas son correctas

si / si no

if / else permite un mayor control sobre el flujo de código que la instrucción if básica, al permitir
que se agrupen varias pruebas. Por ejemplo, podría probarse una entrada analógica y tomarse una
acción si la entrada fuera menor que 500, y tomar otra acción si la entrada fuera 500 o mayor. El
código se vería así:

if (pinFiveInput <500)

// acción A

más

// acción B

de lo contrario, puede continuar con 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 es verdadera, se ejecuta el
bloque else predeterminado, si hay uno presente, y establece el comportamiento
predeterminado.

Tenga en cuenta que un bloque else se puede usar con o sin un bloque de terminación else y
viceversa. Un número ilimitado de tales si se permiten sucursales.

if (pinFiveInput <500)

// hacer la cosa A

más si (pinFiveInput> = 1000)

// hacer la cosa B

más

// hacer cosa C

}
para declaraciones

Descripción

La declaración for se usa para repetir un bloque de declaraciones encerradas entre llaves. Un
contador de incremento se usa generalmente 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.

Hay tres partes en el encabezado del bucle for:

para (inicialización; condición; incremento) {

// declaración (s);

La inicialización ocurre primero y exactamente una vez. Cada vez a través del ciclo, se prueba la
condición; si es cierto, el bloque de instrucción y el incremento se ejecuta, entonces la condición
se prueba nuevamente. Cuando la condición se vuelve falsa, el ciclo termina.

Ejemplo

// Atenúa un LED con un pin PWM

int PWMpin = 10; // LED en serie con resistencia de 470 ohm en el pin 10

configuración nula ()

// no se necesita configuración

bucle vacío ()

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

analogWrite (PWMpin, i);

retraso (10);

} Definición de niveles de pin: ALTO y BAJO

Al leer o escribir en un pin digital, solo hay dos valores posibles que un pin puede tomar /
configurar: ALTO y BAJO.

ALTO

El significado de ALTO (en referencia a un pin) es algo diferente dependiendo de si un pin está
configurado como ENTRADA o SALIDA. Cuando un pin se configura como una ENTRADA con
pinMode () y se lee con digitalRead (), el Arduino (Atmega) informará ALTO si:

un voltaje mayor a 3 voltios está presente en el pin (tableros de 5V);

un voltaje mayor a 2 voltios está presente en el pin (placas de 3.3V);

Un pin también puede configurarse como una ENTRADA con pinMode (), y posteriormente
hacerse ALTO con digitalWrite (). Esto habilitará las resistencias pullup internas de 20K, que
elevarán el pin de entrada a una lectura ALTA, a menos que sea tirado BAJO por un circuito
externo. Así es como funciona INPUT_PULLUP y se describe a continuación con más detalle.

Cuando un pin está configurado para SALIDA con pinMode (), y configurado en ALTO con
digitalWrite (), el pin está en:

5 voltios (tableros de 5V);

3,3 voltios (placas de 3,3 V);

En este estado puede generar corriente, p. encienda un LED que está conectado a través de una
resistencia en serie a tierra.

BAJO

El significado de BAJO también tiene un significado diferente dependiendo de si un pin está

configurado como ENTRADA o SALIDA. Cuando un pin se configura como una ENTRADA con
pinMode (), y se lee con digitalRead (), el Arduino (Atmega) informará BAJO si:

un voltaje de menos de 3 voltios está presente en el pin (tableros de 5V);

hay un voltaje de menos de 2 voltios en el pin (placas de 3.3V);

Cuando un pin se configura en SALIDA con pinMode (), y se establece en BAJO con digitalWrite (),
el pin está a 0 voltios (ambas tarjetas de 5V y 3.3V). En este estado puede hundir corriente, p.
encienda un LED que esté conectado a través de una resistencia en serie a +5 voltios (o +3.3
voltios).

Definición de modos de pines digitales: INPUT, INPUT_PULLUP y OUTPUT

Los pines digitales se pueden usar como INPUT, INPUT_PULLUP o OUTPUT. Cambiar un pin con
pinMode () cambia el comportamiento eléctrico del pin.

Pines configurados como ENTRADA

Se dice que los pines Arduino (Atmega) configurados como ENTRADA con pinMode () están en un
estado de alta impedancia. Los pines configurados como ENTRADA hacen demandas
extremadamente pequeñas en el circuito que están muestreando, equivalente a una resistencia en
serie de 100 megaohmios en frente del pin. Esto los hace útiles para leer un sensor.

Si tiene su pin configurado como ENTRADA y está leyendo un interruptor, cuando el interruptor
está en estado abierto, el pin de entrada estará "flotando", lo que dará como resultado resultados
impredecibles. Para asegurar una lectura adecuada cuando el interruptor está abierto, se debe
usar una resistencia pull-up o pull-down. El propósito de esta resistencia es llevar el pin a un
estado conocido cuando el interruptor está abierto. Por lo general, se elige una resistencia de 10 K
ohmios, ya que es un valor lo suficientemente bajo como para evitar de manera confiable una
entrada flotante, y al mismo tiempo un valor lo suficientemente alto como para no consumir
demasiada corriente cuando el interruptor está cerrado. Consulte el tutorial de lectura digital en
serie para obtener más información.

Si se usa una resistencia desplegable, el pin de entrada será BAJO cuando el interruptor esté
abierto y ALTO cuando el interruptor esté cerrado.

Si se usa una resistencia pull-up, el pin de entrada será ALTO cuando el interruptor esté abierto y
BAJO cuando el interruptor esté cerrado.

Pines configurados como salidas

Se dice que los pines configurados como SALIDA con pinMode () están en un estado de baja
impedancia. Esto significa que pueden proporcionar una cantidad sustancial de corriente a otros
circuitos. Los pines Atmega pueden generar (proporcionar corriente) o hundirse (absorber
corriente) hasta 40 mA (miliamperios) de corriente a otros dispositivos / circuitos. Esto los hace
útiles para alimentar LED porque los LED generalmente usan menos de 40 mA. Las cargas
superiores a 40 mA (p. Ej., Motores) requerirán un transistor u otro circuito de interfaz.

Los pines configurados como salidas pueden dañarse o destruirse si están conectados a la tierra oa
los rieles de alimentación positiva.

Definición de elementos integrados: LED_BUILTIN

La mayoría de las placas Arduino tienen un pin conectado a un LED integrado en serie con una
resistencia. La constante LED_BUILTIN es el número del pin al que está conectado el LED
integrado. La mayoría de las placas tienen este LED conectado al pin digital 13.

Ver también

pinMode ()

Constantes enteras

variables booleanas

Inicio de referencia

Las correcciones, sugerencias y nueva documentación deben publicarse en el Foro.

El texto de la referencia de Arduino está licenciado bajo una licencia Creative Commons
Attribution-ShareAlike 3.0. Los ejemplos de código en la referencia se liberan al dominio público.
vacío

La palabra clave nula se usa solo en declaraciones de funciones. Indica que se espera que la
función no devuelva información a la función desde la que se llamó.

Ejemplo:

// las acciones se realizan en las funciones "setup" y "loop"

// pero no se informa ninguna información al programa más grande

configuración nula ()

  // ...

bucle vacío ()

  // ...

carbonizarse

Descripción

Un tipo de datos que ocupa 1 byte de memoria que almacena un valor de caracteres. Los literales
de caracteres se escriben entre comillas simples, así: 'A' (para varios caracteres - cadenas - use
comillas dobles: "ABC").

Sin embargo, los caracteres se almacenan como números. Puede ver la codificación específica en
el gráfico ASCII. Esto significa que es posible hacer aritmética en caracteres, en los que se usa el
valor ASCII del carácter (por ejemplo, 'A' + 1 tiene el valor 66, ya que el valor ASCII de la letra
mayúscula A es 65). Consulte la referencia de Serial.println para obtener más información sobre
cómo se traducen los caracteres a números.

El tipo de datos char es un tipo con signo, lo que significa que codifica números del -128 al 127.
Para un tipo de datos sin signo de un byte (8 bits), use el tipo de datos byte.

Ejemplo

char myChar = 'A';

char myChar = 65; // ambos son equivalentes

byte
Descripción

Un byte almacena un número sin signo de 8 bits, de 0 a 255.

Ejemplo

byte b = B10010; // "B" es el formateador binario (B10010 = 18 decimal)

Ver también

palabra

byte()

Declaración Variable

pinMode ()

Descripción

Configura el pin especificado para que se comporte como entrada o salida. Consulte la descripción
de los pines digitales para obtener detalles sobre la funcionalidad de los pines.

A partir de Arduino 1.0.1, es posible habilitar las resistencias pullup internas con el modo
INPUT_PULLUP. Además, el modo INPUT inhabilita explícitamente los pullups internos.

Sintaxis

pinMode (pin, modo)

Parámetros

pin: el número del pin cuyo modo desea establecer

modo: INPUT, OUTPUT o INPUT_PULLUP. (consulte la página de pines digitales para obtener una
descripción más completa de la funcionalidad).

Devoluciones

Ninguna

Ejemplo

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

configuración nula ()

{
 pinMode (ledPin, OUTPUT); // establece el pin digital como salida

bucle vacío ()

digitalWrite (ledPin, HIGH); // enciende el LED

retraso (1000); // espera un segundo

digitalWrite (ledPin, LOW); // apaga el LED

retraso (1000); // espera un segundo

digitalWrite ()

Descripción

Escriba un valor ALTO o BAJO en un pin digital.

Si el pin se ha configurado como una SALIDA con pinMode (), su voltaje se establecerá en el valor
correspondiente: 5V (o 3.3V en placas de 3.3V) para ALTO, 0V (tierra) para BAJO.

Si el pin está configurado como ENTRADA, digitalWrite () habilitará (ALTO) o deshabilitará (BAJO) el
pullup interno del pin de entrada. Se recomienda establecer el pinMode () en INPUT_PULLUP para
habilitar la resistencia de pull-up interna. Consulte el tutorial de pines digitales para obtener más
información.

NOTA: Si no establece el pinMode () en OUTPUT y conecta un LED a un pin, cuando llame a

digitalWrite (HIGH), el LED puede aparecer tenue. Sin establecer explícitamente pinMode (),
digitalWrite () habrá habilitado 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

valor: ALTO o BAJO

Devoluciones

ninguna

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

configuración nula ()

pinMode (ledPin, OUTPUT); // establece el pin digital como salida

bucle vacío ()

digitalWrite (ledPin, HIGH); // enciende el LED

retraso (1000); // espera un segundo

digitalWrite (ledPin, LOW); // apaga el LED

retraso (1000); // espera un segundo

Establece el pin 13 en ALTO, hace un retraso de un segundo y establece el pin nuevamente en

BAJO.

digitalRead ()

Descripción

Lee el valor de un pin digital especificado, ya sea ALTO o BAJO.

Sintaxis

digitalRead (pin)

Parámetros

pin: el número del pin digital que desea leer (int)

Devoluciones

Alto o bajo

Ejemplo

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

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

int inPin = 7; // pulsador conectado al pin digital 7

int val = 0; // variable para almacenar el valor de lectura

configuración nula ()

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

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

bucle vacío ()

val = digitalRead (inPin); // lee el pin de entrada

digitalWrite (ledPin, val); // establece el LED al valor del botón

analogWrite ()

Descripción

Escribe un valor analógico (onda PWM) en un pin. Se puede usar para encender un LED con
diferentes brillos o conducir un motor a varias velocidades. Después de una llamada a analogWrite
(), el pin generará una onda cuadrada constante del ciclo de trabajo especificado hasta la próxima
llamada a analogWrite () (o una llamada a digitalRead () o digitalWrite () en el mismo pin). La
frecuencia de la señal PWM en la mayoría de los pines es de aproximadamente 490 Hz. En las
tarjetas Uno y similares, los pines 5 y 6 tienen una frecuencia de aproximadamente 980 Hz. Los
pines 3 y 11 en el Leonardo también funcionan a 980 Hz.

En la mayoría de las placas Arduino (aquellas con ATmega168 o ATmega328), esta función
funciona en los pines 3, 5, 6, 9, 10 y 11. En el Arduino Mega, funciona en los pines 2 - 13 y 44 - 46.
Arduino más antiguo Las placas con ATmega8 solo admiten analogWrite () en los pines 9, 10 y 11.

El Arduino Due admite analogWrite () en los pines 2 a 13, más los pines DAC0 y DAC1. A diferencia
de los pines PWM, DAC0 y DAC1 son convertidores de digital a analógico y actúan como
verdaderas salidas analógicas.

No necesita llamar a pinMode () para establecer el pin como salida antes de llamar a 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 para escribir.

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

Devoluciones

nada

Notas y problemas conocidos

Las salidas PWM generadas en los pines 5 y 6 tendrán ciclos de trabajo más altos de lo esperado.
Esto se debe a las interacciones con las funciones millis () y delay (), que comparten el mismo
temporizador interno utilizado para generar esas salidas PWM. Esto se notará principalmente en
configuraciones de ciclo de trabajo bajo (por ejemplo, 0-10) y puede dar como resultado que un
valor de 0 no apague completamente la salida en los pines 5 y 6.

Ejemplo

Establece la salida en el LED proporcional al valor leído desde el potenciómetro.

  

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

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

int val = 0; // variable para almacenar el valor de lectura

configuración nula ()

{
  pinMode (ledPin, OUTPUT); // establece el pin como salida

bucle vacío ()

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

  analogWrite (ledPin, val / 4); // los valores de analogRead van de 0 a 1023, los valores de
analogWrite de 0 a 255

analogRead ()

Descripción

Lee el valor del pin analógico especificado. La placa Arduino contiene un convertidor analógico a
digital de 10 bits (8 canales en Mini y Nano, 16 en Mega). Esto significa que asignará los voltajes de
entrada entre 0 y 5 voltios en valores enteros entre 0 y 1023. Esto produce una resolución entre
lecturas de: 5 voltios / 1024 unidades o, .0049 voltios (4.9 mV) por unidad. El rango de entrada y la
resolución se pueden cambiar usando analogReference ().

Se necesitan aproximadamente 100 microsegundos (0,0001 s) para leer una entrada analógica, por
lo que la velocidad máxima de lectura es de aproximadamente 10,000 veces por segundo.

Sintaxis

analogRead (pin)

Parámetros
pin: el número del pin de entrada analógica para leer (0 a 5 en la mayoría de las placas, 0 a 7 en el
Mini y Nano, 0 a 15 en el Mega)

Devoluciones

int (0 a 1023)

Nota

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 de la placa, etc.).

Ejemplo

int analogPin = 3; // limpiador de potenciómetro (terminal central) conectado al pin analógico 3

// afuera conduce a tierra y + 5V

int val = 0; // variable para almacenar el valor leído

configuración nula ()

Serial.begin (9600); // configuración serial

}
bucle vacío ()

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

Serial.println (val); // valor de depuración

retrasar()

Descripción

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

Sintaxis

retraso (ms)

Parámetros

ms: el número de milisegundos para pausar (sin signo largo)

Devoluciones

nada

Ejemplo

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

configuración nula ()

pinMode (ledPin, OUTPUT); // establece el pin digital como salida

bucle vacío ()
{

digitalWrite (ledPin, HIGH); // enciende el LED

retraso (1000); // espera un segundo

digitalWrite (ledPin, LOW); // apaga el LED

retraso (1000); // espera un segundo

[Obtener código]

Consideración

Si bien es fácil crear un LED parpadeante con la función delay (), y muchos bocetos usan retrasos
cortos para tareas tales como la eliminación del rebote del interruptor, el uso de delay () en un
boceto tiene inconvenientes significativos. Ninguna otra lectura de sensores, cálculos matemáticos
o manipulación de clavijas puede continuar durante la función de retraso, por lo que, en efecto,
detiene la mayoría de las otras actividades. Para enfoques alternativos para controlar el tiempo,
vea la función millis () y el boceto ubicado a continuación. Los programadores con más
conocimientos generalmente evitan el uso de delay () para la sincronización de eventos de más de
10 milisegundos, a menos que el boceto de Arduino sea muy simple.

Sin embargo, ciertas cosas continúan mientras la función delay () controla el chip Atmega, porque
la función delay no desactiva las interrupciones. Se registra la comunicación en serie que aparece
en el pin RX, se mantienen los valores PWM (analogWrite) y los estados del pin, y las
interrupciones funcionarán como deberían.

millis ()

Descripción

Devuelve el número de milisegundos desde que la placa Arduino comenzó a ejecutar el programa
actual. Este número se desbordará (volverá a cero), después de aproximadamente 50 días.

Parámetros

Ninguna

Devoluciones

Número de milisegundos desde que se inició el programa (sin firmar durante mucho tiempo)

Nota:

Tenga en cuenta que el valor de retorno para millis () es un largo sin signo, pueden producirse
errores lógicos si un programador intenta hacer aritmética con tipos de datos más pequeños como
int. Incluso los largos firmados pueden encontrar errores, ya que su valor máximo es la mitad del
de su contraparte sin firmar.
Ejemplo

sin firmar mucho tiempo;

configuración nula () {

Serial.begin (9600);

bucle vacío () {

Serial.print ("Tiempo:");

tiempo = millis ();

// imprime el tiempo desde que comenzó el programa

Serial.println (tiempo);

// espera un segundo para no enviar grandes cantidades de datos

retraso (1000);