Traducido del afrikáans al español - www.onlinedoctranslator.
com
vacíoVamos()
{
escritura digital(pin led,ALTO); // enciende el LED
demora (1000); // murga pora segundo
escritura digital (pin led, BAJO); // el LED
conjuntos apagado
demora (1000); // murga pora segundo
}
Nota
Los pines de entrada analógica se pueden usar como pines digitales, denominados A0, A1, etc.
escritura digital ()
Descripción
Escribe unALTOo unBAJOvalor a un pin digital.
Si el pin ha sido configurado como SALIDA conpinMode(), 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 en el pin de entrada. Se recomienda configurar elpinMode() aENTRADA_PULLUPpara habilitar la
resistencia pull-up interna. Ver eltutorial de pines digitalespara más información.
NOTA: Si no establece pinMode () en SALIDA 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
escritura digital (pin, valor)
Parámetros
pin: el número de pin
valor:ALTOoBAJO
Devoluciones
ninguna
Ejemplo
pin led int = 13; // LED conectado al pin digital 13
configuración vacía ()
pinMode (ledPin, SALIDA); // establece el pin digital como salida
bucle vacío ()
escritura digital (ledPin, ALTO); // enciende el LED
retraso (1000); // espera un segundo
escritura digital (ledPin, BAJO); // apaga el LED
retraso (1000); // espera un segundo
Establece el pin 13 en ALTO, hace un retraso de un segundo y vuelve a establecer el pin en BAJO.
Nota
Los pines de entrada analógica se pueden usar como pines digitales, denominados A0, A1, etc.
lectura digital ()
Descripción
Lee el valor de un pin digital especificado, ya seaALTOoBAJO.
Sintaxis
lectura digital (pin)
Parámetros
pin: el número del pin digital que desea leer (int)
Devoluciones
ALTOoBAJO
Ejemplo
Establece el pin 13 al mismo valor que el pin 7, declarado como entrada.
t led = 13; // LEDconectado a digital alfiler 13
En pasador
En enPin
t = 7; // presionar el botón conectado a digital alfiler 7
En valor
t = 0; // variable para almacenar el valor leído
vacíoconfiguración()
{
pinMode (pin led, PRODUCCIÓN ); // conjuntos el digital 13como
alfiler producción
pinMode (enPin, APORTE ); // conjuntos el digital alfiler 7 como
aporte
vacío Vamos ()
{
caer = lectura digital (enPin); // leer el aporte alfiler
escritura digital (pin led, caer); // el LEDa el botones valor
conjuntos
Nota
Si el pin no está conectado a nada, digitalRead () puede devolver ALTO o BAJO (y esto puede cambiar
aleatoriamente).
Los pines de entrada analógica se pueden usar como pines digitales, denominados A0, A1, etc.
E/S analógica
Referencia analógica ()
Descripción
Configura el voltaje de referencia utilizado para la entrada analógica (es decir, el valor utilizado como la parte superior del rango de
entrada). Las opciones son:
- DEFAULT: la referencia analógica predeterminada de 5 voltios (en placas Arduino de 5 V) o 3,3 voltios (en placas
Arduino de 3,3 V)
- INTERNO: una referencia incorporada, igual a 1,1 voltios en el ATmega168 o ATmega328 y
2,56 voltios en el ATmega8 (no disponible en Arduino Mega)
- INTERNAL1V1: una referencia de 1,1 V integrada (solo Arduino Mega)
- INTERNAL2V56: una referencia de 2,56 V integrada (solo Arduino Mega)
-EXTERNO: el voltaje aplicado al pin AREF (solo 0 a 5V) se usa como referencia.
Sintaxis
analogReference (tipo)
Parámetros
tipo: qué tipo de referencia utilizar (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56 o
EXTERNAL).
Devoluciones
Ninguna.
Nota
Después de cambiar la referencia analógica, las primeras lecturas de analogRead () pueden no ser
precisas.
Advertencia
¡No use nada menos de 0 V o más de 5 V para el voltaje de referencia externo en el pin AREF! Si está
utilizando una referencia externa en el pin AREF, debe establecer la referencia analógica en EXTERNA
antes de llamar a analogRead (). De lo contrario, cortocircuitará el voltaje de referencia activo
(generado internamente) y el pin AREF, lo que posiblemente dañe el microcontrolador. en tu placa
Arduino.
Alternativamente, puede conectar el voltaje de referencia externo al pin AREF a través de una resistencia de
5K, lo que le permite cambiar entre voltajes de referencia internos y externos. Tenga en cuenta que la
resistencia alterará el voltaje que se usa como referencia porque hay una resistencia interna de 32K en el pin
AREF. Los dos actúan como un divisor de voltaje, por lo que, por ejemplo, 2,5 V aplicados a través de la
resistencia producirán 2,5 * 32 / (32 + 5) = ~ 2,2 V en el pin AREF.
lectura analógica ()
Descripción
Lee el valor del pin analógico especificado. La placa Arduino contiene un convertidor analógico a digital
de 6 canales (8 canales en Mini y Nano, 16 en Mega) de 10 bits. Esto significa que asignará voltajes de
entrada entre 0 y 5 voltios a valores enteros entre 0 y 1023. Esto produce una resolución entre lecturas
de: 5 voltios / 1024 unidades o 0,0049 voltios (4,9 mV) por unidad. El rango de entrada y la resolución se
pueden cambiar usandoanalógicoReferencia().
Se tarda unos 100 microsegundos (0,0001 s) en leer una entrada analógica, por lo que la tasa de lectura máxima
es de unas 10.000 veces por segundo.
Sintaxis
lectura analógica (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
Mini y Nano, 0 a 15 en Mega)
Devoluciones
entero (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
En PIN
t analógico = 3; // potenciómetro (medio Terminal) conectado a
limpiaparabrisas cosa análoga alfiler 3
// fuera de Guías a tierra y + 5V
En caer
t = 0; // variable a Tienda el valor leer
vacío ()
configuración
.
De serie comienzo (9600); // configuraciónde serie
vacío Vamos ()
{
caer
= lectura analógica (Pin analógico); // leer el aporte alfiler
.
De serie imprimir (caer); // depurar valor
}
escritura analógica ()
Descripción
Escribe un valor analógico (onda PWM) a un alfiler. Se puede usar para encender un LED con diferentes brillos o impulsar
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 placas Uno y similares, los pines 5 y 6 tienen una frecuencia de aproximadamente
980 Hz. Los pines 3 y 11 del 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 Arduino Mega, funciona en los pines 2 - 13 y 44 - 46. Arduino antiguo Las placas con
un ATmega8 solo admiten escritura analógica () en los pines 9, 10 y 11.
El Arduino Due admite escritura analógica () en los pines 2 a 13, además de 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 configurar 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 resultar en un valor de 0 que no apague completamente la salida en los pines 5 y 6.
Ejemplo
Establece la salida al LED proporcional al valor leído del potenciómetro.
En pasador
t led = 9; // LEDconectado a digital alfiler 9
t analógico = 3; // potenciómetro conectado a cosa análoga
En PIN alfiler 3
En caer
t = 0; // variable a Tienda el leer valor
vacíoconfiguración()
{
pinMode (pin led, PRODUCCIÓN ); // conjuntos el alfiler como
producción
vacíoVamos()
caer
= lectura analógica (Pin analógico); // leer el aporte alfiler
escritura analógica (pin led, / 4); // lectura analógica
caer valores Vamos desde 0 a 1023, escritura analógica valores desde
0 a 255
}
Vencido y cero solamente
resolución de lectura analógica ()
Descripción
analogReadResolution () es una extensión de la API analógica para Arduino Due y Zero.
Establece el tamaño (en bits) del valor devuelto por analogRead(). Tiene un valor predeterminado de 10 bits (devuelve valores entre 0
y 1023) para compatibilidad con versiones anteriores de placas basadas en AVR.
Due y Zero tienen capacidades ADC de 12 bits a las que se puede acceder cambiando la
resolución a 12. Esto devolverá valores de analogRead () entre 0 y 4095.
Sintaxis
resolución de lectura analógica (bits)
Parámetros
bits: determina la resolución (en bits) del valor devuelto por la función analogRead(). Puede configurar este 1 y 32. Puede
configurar resoluciones superiores a 12, pero los valores devueltos por analogRead () sufrirán una aproximación. Consulte la
nota a continuación para obtener más detalles.
Devoluciones
Ninguna.
Nota
Si configura el valor analogReadResolution () en un valor superior a las capacidades de su placa, el
Arduino solo informará a su resolución más alta rellenando los bits adicionales con ceros.
Por ejemplo: usar Due o Zero con analogReadResolution (16) le dará un número aproximado de
16 bits con los primeros 12 bits que contienen la lectura real de ADC y los últimos 4 bits rellenos
con ceros.
Si configura el valor analogReadResolution () en un valor inferior a las capacidades de su placa, los
bits extra menos significativos leídos del ADC se descartarán.
El uso de una resolución de 16 bits (o cualquier resolución superior a las capacidades reales del hardware) le
permite escribir bocetos que manejen automáticamente dispositivos con un ADC de mayor resolución cuando estén
disponibles en placas futuras sin cambiar una línea de código.
Ejemplo
vacío () {
configuración
// abierto a de serie conexión
De serie .comienzo (9600);
vacío () {
Vamos
// leer el aporte A0endefecto resolución (10 bits)
sobre
// y enviar eso
fuera el de serie conexión
resolución de lectura analógica (10);
De serie . impresión ("CAD10 bits (defecto) : ");
De serie . impresión (lectura analógica (A0));
// cambio el resolución a 12 pedacitos y leer A0
resolución de lectura analógica (12);
De serie . impresión (", 12 bits : ");
De serie . impresión (lectura analógica (A0));
// cambio el resolución a dieciséis
pedacitos y leer A0
resolución de lectura analógica (16);
De serie . impresión (", 16 bits : ");
De serie . impresión (lectura analógica (A0));
// cambio el resolución a 8 y
pedacitos leer A0
resolución de lectura analógica (8);
De serie . (", 8 bits : ");
impresión
De serie .imprimir (lectura analógica (A0));
// a pequeño demora a no cerdo de serie monitor
demora (100);
}
resolución de escritura analógica ()
Descripción
analogWriteResolution () es una extensión de la API analógica para Arduino Due, Genuino y
Arduino Zero y MKR1000.
analogWriteResolution () establece la resolución de la función analogWrite (). El valor predeterminado es de 8 bits (valores
entre 0 y 255) para compatibilidad con versiones anteriores de placas basadas en AVR.
El Due tiene las siguientes capacidades más duras:
- 12 pines que por defecto son PWM de 8 bits, como las placas basadas en AVR. Estos se pueden cambiar a una resolución
de 12 bits.
- 2 pines con DAC de 12 bits (convertidor de digital a analógico)
Al configurar la resolución de escritura en 12, puede usar analogWrite () con valores entre 0 y 4095 para
explotar la resolución DAC completa o para configurar la señal PWM sin pasarse.
El Zero tiene las siguientes capacidades más duras:
- 10 pines que por defecto son PWM de 8 bits, como las placas basadas en AVR. Estos se pueden cambiar a una resolución
de 12 bits.
- 1 pin con DAC de 10 bits (convertidor de digital a analógico).
Al configurar la resolución de escritura en 10, puede usar analogWrite () con valores entre 0 y 1023 para
explotar la resolución DAC completa
El MKR1000 tiene las siguientes capacidades más duras:
- 4 pines que por defecto son PWM de 8 bits, como las placas basadas en AVR. Estos se pueden cambiar de 8
(predeterminado) a 12 bits de resolución.
- 1 pin con DAC de 10 bits (convertidor de digital a analógico)
Al configurar la resolución de escritura en 12 bits, puede usar analogWrite () con valores entre 0 y 4095 para
señales PWM; configure 10 bits en el pin DAC para explotar la resolución DAC completa de 1024 valores.
Sintaxis
analogWriteResolution (bits)
Parámetros
bits: determina la resolución (en bits) de los valores utilizados en la función analogWrite(). El valor
puede oscilar entre 1 y 32. Si elige una resolución superior o inferior a la de su placa
capacidades de hardware, el valor utilizado en analogWrite () se truncará si es demasiado alto o se completará con ceros si
es demasiado bajo. Consulte la nota a continuación para obtener más detalles.
Devoluciones
Ninguna.
Nota
Si establece el valor analogWriteResolution () en un valor superior a las capacidades de su placa, la
placa descartará los bits adicionales. Por ejemplo: usando Due con analogWriteResolution (16) en un
pin DAC de 12 bits, solo se usarán los primeros 12 bits de los valores pasados a analogWrite () y los
últimos 4 bits se descartarán.
Si configura el valor analogWriteResolution () en un valor inferior a las capacidades de su placa, los bits
faltantes se rellenarán con ceros para llenar el tamaño requerido de hardware. Por ejemplo: usando Due
con analogWriteResolution (8) en un pin DAC de 12 bits, Arduino agregará 4 bits cero al valor de 8 bits
utilizado en analogWrite () para obtener los 12 bits requeridos.
Ejemplo
vacío configuración () {
// abierto a de serie conexión
De serie .comienzo (9600);
// fabricar digital alfiler unproducción
nuestro
pinMode (11, PRODUCCIÓN );
pinMode (12, PRODUCCIÓN );
pinMode (13, PRODUCCIÓN );
}
vacío Vamos () {
// leer el aporte A0y mapa sobreeso
a a PWM alfiler
// con unadjunto LED
En SensorVal
t = lectura analógica (A0);
De serie . ("Cosa análoga Leer) : ");
impresión
De serie . (sensorVal);
impresión
// el defecto PWM resolución
resolución de escritura analógica (8);
escritura analógica (11,mapa (Valorsensor, 0, 1023, 0 , 255));
De serie .
impresión (" , 8 bits PWM valor : ");
De serie .
impresión (mapa (Valorsensor, 0, 1023, 0 , 255));
// cambio el PWM resolución a 12 pedacitos
// el 12 resolución essolosoportado
completo un poco
// el Vencer
sobre
resolución de escritura analógica (12);
escritura analógica (12,mapa (Valorsensor, 0, 1023, 0, 4095));
De serie . impresión (" , 12 bits PWM valor : ");
De serie . impresión (mapa (Valorsensor, 0, 1023, 0, 4095));
// cambio el PWM resolución a 4 pedacitos
resolución de escritura analógica (4);
(13,mapa
escritura analógica (Valorsensor, 0, 1023, 0, 15));
De serie . (", 4 bits PWM valor : ");
impresión
De serie .imprimir (mapa (Valorsensor, 0, 1023, 0, 15));
demora (5);
}
E/S avanzada
tono ()
Descripción
Genera una onda cuadrada de la frecuencia especificada (y un ciclo de trabajo del 50 %) en un pin. Se puede especificar una
duración; de lo contrario, la onda continúa hasta que se recibe una llamada.ni uno(). El pin se puede conectar a un zumbador
piezoeléctrico u otro altavoz para reproducir tonos.
Solo se puede generar un tono a la vez. Si ya se está reproduciendo un tono en un pin diferente, la llamada al
tono () no tendrá efecto. Si el tono se reproduce en el mismo pin, la llamada establecerá su frecuencia.
El uso de la función de tono () interferirá con la salida PWM en los pines 3 y 11 (en placas que no sean
Mega).
Junta Frecuencia mínima (Hz) Frecuencia máxima (Hz)
Uno, Mega, Leonardo y otros
31 65535
Tableros AVR
Gema No se ha implementado No se ha implementado
Cero 41 275000
Vencer No se ha implementado No se ha implementado
Para detalles técnicos, consulteNotas de Brett Hagman.
NOTA: si desea tocar diferentes tonos en varios pines, debe llamar a noTone () en un pin antes de llamar
a tone () en el siguiente pin.
Sintaxis
tono (pin, frecuencia)
tono (pin, frecuencia, duración)
Parámetros
pin: el pin en el que generar el tono
frecuencia: la frecuencia del tono en hercios - int sin signo
duración: la duración del tono en milisegundos (opcional) - largo sin firmar
Devoluciones
nada
ni uno ()
Descripción
Detiene la generación de una onda cuadrada desencadenada portono(). No tiene efecto si no se genera
ningún tono.
NOTA: si desea tocar diferentes tonos en varios pines, debe llamar a noTone () en un pin antes de llamar
a tone () en el siguiente pin.
Sintaxis
sin tono (pin)
Parámetros
pin: el pin en el que dejar de generar el tono
Devoluciones
nada
desplazar fuera ()
Descripción
Desplaza un byte de datos un bit a la vez. Comienza desde el bit más significativo (es decir, el más a la izquierda) o menos (el
más a la derecha). Cada bit se escribe a su vez en un pin de datos, después de lo cual se pulsa un pin de reloj (se toma alto,
luego bajo) para indicar que el bit está disponible.
Nota: si está interactuando con un dispositivo con flancos ascendentes, deberá asegurarse de que el pin del reloj
esté bajo antes de la llamada a shiftOut (), por ejemplo, con una llamada a digitalWrite (clockPin, LOW).
Esta es una implementación de software; ver también elbiblioteca SPI, que proporciona una implementación de
hardware que es más rápida pero solo funciona en pines específicos.
Sintaxis
shiftOut (Pin de datos, pin de reloj, orden de bits, valor)
Parámetros
dataPin: el pin en el que generar cada bit (int)
clockPin: el pin para alternar una vez que el pin de datos se ha establecido en el valor correcto (int)
bitOrder: en qué orden desplazar los bits; ya sea MSBFIRST o LSBFIRST. (Bit más
significativo primero o bit menos significativo primero)
valor: los datos a desplazar. (byte)
Devoluciones
Ninguna
Nota
El pin de datos y el pin de reloj ya deben estar configurados como salidas mediante una llamada apinMode().
shiftOut actualmente está escrito para generar 1 byte (8 bits), por lo que requiere una operación de dos pasos para generar
valores mayores que 255.
// Haga esto para la serie MSBFIRST
En tdatos = 500;
// desplazar byte alto
desplazar fuera(Pin de datos, reloj,MSBF PRIMERO, (datos >> 8)); //
desplazar byte bajo
desplazar fuera(Pin de datos, reloj,MSBF PRIMERO, datos);
// O haz esto para la serie LSBFIRST
datos = 500;
// desplazar byte bajo
desplazar fuera(Pin de datos, reloj,LSB PRIMERO,
datos); // desplazar byte alto
desplazar fuera (Pin de datos, reloj,LSB PRIMERO, (datos >> 8));
Ejemplo
Para el circuito adjunto, consulte eltutorial sobre el control de un registro de desplazamiento 74HC595.
// *************************************************** * ************ //
// Nombre : shiftOutCode, Hola Mundo //
// Autor : Carlyn fauces, tom yogoe //
// Fecha : 25Oct,2006 //
// Versión : 1.0 //
// notas : Código porutilizando a 74HC595 Cambio Registrarse //
// : a contar desde 0 a 255 //
// *************************************************** * ***************
// Pin conectado a ST_CP de 74HC595 En t
pestilloPin = 8;
// Pin conectado a SH_CP de 74HC595 En
trelojPin = 12;
//// Pin conectado a DS de 74HC595 En t
pin de datos = 11;
vacíoconfiguración() {
// colocar patas a producción porque ellos sondirigido enel principal Vamos
pinMode (pasador de pestillo, ); PRODUCCIÓN
pinMode (pin de reloj, PRODUCCIÓN );
pinMode (Pin de datos, PRODUCCIÓN );
}
vacío Vamos () {
// contar rutina
arriba
por(En jt= 0; j < 256;j++){
// tierra y sostener bajoporcomo
pasador de pestillo pulmón como
Udssontransmitiendo
escritura digital BAJO);
(pasador de pestillo,
desplazar fuera (Pin de datos, pin de reloj, LSB PRIMERO , j);
// regreso el pestillo alfiler alto a señal chipese eso
// No más extenso a escucha porinformación
necesidades
escritura digital ALTO);
(pasador de pestillo,
demora (1000);
}
}
desplazar en ()
Descripción
Cambia en un byte de datos un bit a la vez. Comienza desde el bit más significativo (es decir, el más a la
izquierda) o menos (el más a la derecha). Para cada bit, el pin del reloj se eleva, el siguiente bit se lee de la
línea de datos y luego el pin del reloj se baja.
Si está interactuando con un dispositivo que funciona con flancos ascendentes, deberá asegurarse de que el pin del reloj esté
bajo antes de la primera llamada a shiftIn (), por ejemplo, con una llamada a digitalWrite (clockPin, LOW).
Nota: esta es una implementación de software; Arduino también proporciona unbiblioteca SPIque usa la
implementación de hardware, que es más rápida pero solo funciona en pines específicos.
Sintaxis
byte entrante = shiftIn (dataPin, clockPin, bitOrder)
Parámetros
dataPin: el pin en el que ingresar cada bit (int)
clockPin: el pin para alternar para señalar una lectura de dataPin
bitOrder: qué orden cambiar en los bits; ya sea MSBFIRST o LSBFIRST. (Bit más
significativo primero o bit menos significativo primero)
Devoluciones
el valor leído (byte)
entrada de pulso ()
Descripción
Lee un pulso (ya sea ALTO o BAJO) en un pin. Por ejemplo, si el valor es ALTO, pulseIn () espera a que el pin pase a
ALTO, comienza a cronometrar, luego espera a que el pin pase a BAJO y detiene el cronometraje. Devuelve la duración
del pulso en microsegundos o 0 si no se recibió ningún pulso completo dentro del tiempo de espera.
El tiempo de esta función ha sido determinado empíricamente y probablemente mostrará errores en
pulsos más cortos. Funciona con pulsos de 10 microsegundos a 3 minutos de duración. Tenga en cuenta
también que si el pin ya está alto cuando se llama a la función, esperará a que el pin pase a BAJO y
luego ALTO antes de que comience a contar. Esta rutina se puede usar solo si las interrupciones están
activadas. Además, la resolución más alta se obtiene con intervalos cortos.
Sintaxis
pulseIn (pin, valor)
pulseIn (pin, valor, tiempo de espera)
Parámetros
pin: el número del pin en el que desea leer el pulso. (En t)
valor: tipo de pulso a leer: cualquieraALTOoBAJO. (En t)
tiempo de espera (opcional): el número de microsegundos a esperar para que se complete el pulso: la función devuelve 0
si no se recibió ningún pulso completo dentro del tiempo de espera. El valor predeterminado es un segundo (largo sin
firmar).
Devoluciones
la duración del pulso (en microsegundos) o 0 si no se completa ningún pulso antes del tiempo de espera
(unsigned long)
Ejemplo
En alfiler
t = 7;
no firmado pulmón duración;
vacío ()
configuración
{
pinMode (alfiler, APORTE );
}
vacío Vamos ()
{
duración = entrada de pulso(alfiler, ALTO);
}
Hora
mili ()
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 (largo sin firmar)
Nota:
Tenga en cuenta que el valor devuelto para millis () es un largo sin firmar, pueden ocurrir errores lógicos si un
programador intenta hacer aritmética con tipos de datos más pequeños como int. Incluso firmado largo puede
encontrar errores ya que su valor máximo es la mitad del de su contraparte sin firmar.
Ejemplo
no firmado pulmón hora;
vacío () {
configuración
.
De serie comienzo (9600);
}
vacío Vamos () {
De serie . ("Hora: ");
impresión
hora= mili ();
// imprime horaya que programa empezado
De serie .imprimir (hora);
// Espere a segundo como no a enviar masivo montos o
entonces datos
demora (1000);
micros ()
Descripción
Devuelve el número de microsegundos desde que la placa Arduino comenzó a ejecutar el programa actual. Este
número se desbordará (volverá a cero) después de aproximadamente 70 minutos. En placas Arduino de 16 MHz (por
ejemplo, Duemilanove y Nano), esta función tiene una resolución de cuatro microsegundos (es decir, el valor devuelto
es siempre un múltiplo de cuatro). En placas Arduino de 8 MHz (por ejemplo, LilyPad), esta función tiene una resolución
de ocho microsegundos.
Nota: hay 1.000 microsegundos en un milisegundo y 1.000.000 de microsegundos en un segundo.
Parámetros
Ninguna
Devoluciones
Número de microsegundos desde que se inició el programa (unsigned long)
Ejemplo
mucho tiempo sin firmar;
configuración vacía () {
Serial.begin (9600);
bucle vacío () {
Serial.print ("Hora:");
tiempo = micros ();
// imprime el tiempo desde que se inició el programa
Serial.println (tiempo);
// espera un segundo para no enviar cantidades masivas de datos
retraso (1000);
demora ()
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 hacer una pausa (largo sin firmar)
Devoluciones
nada
Ejemplo
En pasador
t led = 13; // LEDconectado a digital alfiler 13
vacíoconfiguración()
{
pinMode (pin led, PRODUCCIÓN ); // conjuntos el digital alfiler como
producción
vacíoVamos()
{
escritura digital(pin led,ALTO); // enciende el LED
demora (1000); // murga pora segundo
escritura digital (pin led, BAJO); // el LED
conjuntos apagado
demora (1000); // murga pora segundo
}
Advertencia
Si bien es fácil crear un LED parpadeante con la función de retraso (), y muchos bocetos usan retrasos breves para tareas
como la eliminación de rebotes de interruptores, el uso de retraso () en un boceto tiene inconvenientes significativos.
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 demás actividades. Para enfoques alternativos para controlar el
tiempo, consulte elmili ()función y el croquis que se encuentra a continuación. Los programadores con más conocimientos
generalmente evitan el uso de retardo () para cronometrar 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 de retraso () controla el chip Atmega, porque la
función de retraso no desactiva las interrupciones. Se graba la comunicación serial que aparece en el pin RX,
PWM (escritura analógica) se mantienen los valores y estados de los pines, yinterrumpefuncionarán como
deberían.
retrasoMicrosegundos ()
Descripción
Pausa el programa por la cantidad de tiempo (en microsegundos) especificado como parámetro. Hay mil
microsegundos en un milisegundo y un millón de microsegundos en un segundo.
Actualmente, el valor más grande que producirá un retraso preciso es 16383. Esto podría cambiar en futuras
versiones de Arduino. Para retrasos de más de unos pocos miles de microsegundos, debe usar retraso () en su
lugar.
Sintaxis
retrasoMicrosegundos (nosotros)
Parámetros
us: el número de microsegundos para hacer una pausa (int sin firmar)
Devoluciones
Ninguna
Ejemplo
En pin
t de salida = 8; // pin digital 8
vacíoconfiguración()
{
pinMode (outPin, PRODUCCIÓN ); // conjuntos el digital alfiler como
producción
vacíoVamos()
{
escritura digital(outPin,ALTO); // activa el pin
retrasoMicrosegundos (50); // pausas por50 microsegundos
escritura digital (outPin, BAJO); // el alfiler
conjuntos apagado
retrasoMicrosegundos (50); // pausas por50 microsegundos
}
configura el pin número 8 para que funcione como un pin de salida. Envía un tren de pulsos de aproximadamente
100 microsegundos de período. La aproximación se debe a la ejecución de las otras instrucciones en el código.
Advertencias y problemas conocidos
Esta función funciona con mucha precisión en el rango de 3 microsegundos y más. No podemos asegurar que
delayMicroseconds funcione con precisión para tiempos de retraso más pequeños.
A partir de Arduino 0018, delayMicroseconds () ya no desactiva las interrupciones.
Matemáticas
mínimo (x, y)
Descripción
