Cordial saludo,

int prenderled= 7;
int prenderled1= 8;

void setup() {
pinMode (prenderled,OUTPUT);
pinMode (prenderled1,OUTPUT);
}

void loop() {
digitalWrite (prenderled,HIGH);
delay (500);

digitalWrite (prenderled,LOW);
delay (500);

digitalWrite (prenderled1,HIGH);
delay (500);

digitalWrite (prenderled1,LOW);
delay (500);

}
-----------------------------------------------------------------------------------------------------------------
int encenderled= 4;
void setup() {
pinMode (encenderled,OUTPUT);
}

void loop() {
digitalWrite (encenderled,HIGH);
delay (500);
digitalWrite (encenderled,LOW);
delay (500);
}
--------------------------------------------------------------------------------------------
int prenderled= 7;
int prenderled1= 8;

void setup() {
pinMode (prenderled,OUTPUT);
pinMode (prenderled1,OUTPUT);
}

void loop() {
digitalWrite (prenderled,HIGH);

digitalWrite (prenderled1,HIGH);
delay (500);

digitalWrite (prenderled,LOW);
digitalWrite (prenderled1,LOW);
delay (500);

}
------------------------------------------------------------------------------------------------------------------

Estimados estudiantes, para la tercera entrega (ACA 3) se debe tener en cuenta los
siguiente.

1. Plano de la situación problema dé los tres dispositivos con compuertas lógicas trabajo
que se realiza en clase.

2. Consultar sobre los microprocesadores, su arquitectura y los fabricantes. PRINCIPALES

MARCAS

3. Averiguar toda la Referencia lingüística, tener en cuenta que los programas de Arduino
se pueden dividir en tres partes principales: estructura, valores (variables y constantes) y
funciones.
Referencia lingüística
El lenguaje de programación Arduino se puede dividir en tres partes principales:
funciones, valores (variables y constantes) y estructura.

Funciones:
Controla Arduino y realizar cálculos digitales Descripción Lee el valor de un pin digital
especificado, ya sea o .HIGHLOW

Sintaxis
digitalRead(pin)

Parámetros
pin: el número de pin de Arduino que desea leer

Devuelve
HIGH o LOW
digitalWrite()
[E/S digital]
Descripción
Escriba un o un valor en un pin digital.HIGHLOW

Si el pin se ha configurado como un con , su voltaje se establecerá en el valor

correspondiente: 5V (o 3.3V en placas de 3.3V) para , 0V (tierra) para
.OUTPUTpinMode()HIGHLOW

Si el pin está configurado como un , habilitará () o deshabilitará () el pullup interno en el

pin de entrada. Se recomienda configurar el para habilitar la resistencia pull-up interna.
Consulte el tutorial de Pines digitales para obtener más
información.INPUTdigitalWrite()HIGHLOWpinMode()INPUT_PULLUP

Si no establece el en , y conecta un LED a un pin, al llamar , el LED puede aparecer tenue.

Sin configurar explícitamente , se habrá habilitado la resistencia pull-up interna, que actúa
como una gran resistencia limitante de
corriente.pinMode()OUTPUTdigitalWrite(HIGH)pinMode()digitalWrite()

Sintaxis
digitalWrite(pin, value)
pinMode()
[E/S digital]
Descripción
Configura el pin especificado para que se comporte como entrada o salida. Consulte la
página 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 .
Además, el modo deshabilita explícitamente las pullups internas.INPUT_PULLUPINPUT

Sintaxis
pinMode(pin, mode)

E/S analógicasanalogRead()
[E/S analógicas]
Descripción
Lee el valor del pin analógico especificado. Las placas Arduino contienen un convertidor
analógico a digital multicanal de 10 bits. Esto significa que asignará voltajes de entrada
entre 0 y el voltaje de funcionamiento (5V o 3.3V) en valores enteros entre 0 y 1023. En
un Arduino UNO, por ejemplo, esto produce una resolución entre lecturas de: 5 voltios /
1024 unidades o, 0.0049 voltios (4.9 mV) por unidad. Consulte la tabla a continuación
para conocer los pines utilizables, el voltaje de funcionamiento y la resolución máxima
para algunas placas Arduino.

El rango de entrada se puede cambiar usando analogReference(),mientras que la

resolución se puede cambiar (solo para placas Zero, Due y MKR) usando
analogReadResolution().

En las placas basadas en ATmega (UNO, Nano, Mini, Mega), se necesitan unos 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)
analogReference()
[E/S analógicas]
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:

Placas Arduino AVR (Uno, Mega, Leonardo, etc.)

DEFAULT: la referencia analógica predeterminada de 5 voltios (en placas Arduino de 5V)

o 3.3 voltios (en placas Arduino de 3.3V)

INTERNO: una referencia incorporada, igual a 1,1 voltios en el ATmega168 o

ATmega328P y 2,56 voltios en el ATmega32U4 y ATmega8 (no disponible en el Arduino
Mega)

INTERNAL1V1: una referencia incorporada de 1.1V (solo Arduino Mega)

INTERNAL2V56: una referencia incorporada de 2.56V (solo Arduino Mega)

EXTERNO: se utiliza como referencia la tensión aplicada al pin AREF (solo de 0 a 5V).

Placas SAMD Arduino (Cero, etc.)

AR_DEFAULT: la referencia analógica predeterminada de 3.3V

AR_INTERNAL: una referencia incorporada de 2.23V

AR_INTERNAL1V0: una referencia incorporada de 1.0V

AR_INTERNAL1V65: una referencia incorporada de 1.65V

AR_INTERNAL2V23: una referencia incorporada de 2.23V

AR_EXTERNAL: se utiliza como referencia la tensión aplicada al pin AREF

Placas Arduino megaAVR (Uno WiFi Rev2)

DEFAULT: una referencia incorporada de 0.55V

INTERNAL: una referencia incorporada de 0.55V

VDD: Vdd del ATmega4809. 5V en el Uno WiFi Rev2

INTERNAL0V55: una referencia incorporada de 0.55V

INTERNAL1V1: una referencia incorporada de 1.1V

INTERNAL1V5: una referencia incorporada de 1.5V

INTERNAL2V5: una referencia incorporada de 2.5V

INTERNAL4V3: una referencia incorporada de 4.3V

EXTERNO: se utiliza como referencia la tensión aplicada al pin AREF (solo de 0 a 5 V)

Placas ARduino SAM (Due)

AR_DEFAULT: la referencia analógica predeterminada de 3.3V. Esta es la única opción

admitida para el Due.
Arduino Mbed OS Nano Boards (Nano 33 BLE), Arduino Mbed OS Edge Boards (Edge
Control)

AR_VDD: la referencia predeterminada de 3,3 V

AR_INTERNAL: referencia incorporada de 0,6 V

AR_INTERNAL1V2: referencia de 1,2 V (referencia interna de 0,6 V con ganancia de 2x)

AR_INTERNAL2V4: referencia de 2,4 V (referencia interna de 0,6 V con ganancia de 4x)

Sintaxis
analogReference(type)
analogWrite()
[E/S analógicas]
Descripción
Escribe un valor analógico(onda PWM)en un pin. Se puede utilizar para encender un LED
a diferentes brillos o accionar un motor a varias velocidades. Después de una llamada a ,
el pin generará una onda rectangular constante del ciclo de trabajo especificado hasta la
siguiente llamada a (o una llamada a o ) en el mismo
pin.analogWrite()analogWrite()digitalRead()digitalWrite()
Sintaxis
analogWrite(pin, value)
Familia Zero, Due & MKR:
analogReadResolution()
[Familia Zero, Due & MKR]
Descripción
analogReadResolution() es una extensión de la API analógica para la familia Zero, Due,
MKR, Nano 33 (BLE e IoT) y Portenta.
Establece el tamaño (en bits) del valor devuelto por . El valor predeterminado es de 10
bits (devuelve valores entre 0-1023) para la compatibilidad con versiones anteriores de
placas basadas en AVR.analogRead()

Las placas Zero, Due, MKR family y Nano 33 (BLE e IoT) tienen capacidades ADC de 12
bits a las que se puede acceder cambiando la resolución a 12. Esto devolverá valores de
entre 0 y 4095.
El Portenta H7 tiene un ADC de 16 bits, que permitirá valores entre 0 y
65535.analogRead()

Sintaxis
analogReadResolution(bits)

analogWriteResolution()
[Familia Zero, Due & MKR]
Descripción
analogWriteResolution() es una extensión de la API analógica para Arduino Due.

analogWriteResolution() establece la resolución de la función. El valor predeterminado

es de 8 bits (valores entre 0-255) para la compatibilidad con versiones anteriores de
placas basadas en AVR.analogWrite()

El Due tiene las siguientes capacidades de hardware:

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 (digital-to-analog converter)

Al establecer la resolución de escritura en 12, puede usar con valores entre 0 y 4095
para aprovechar la resolución DAC completa o para configurar la señal PWM sin
voltear.analogWrite()

El Zero tiene las siguientes capacidades de hardware:

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 (Digital-to-Analog Converter).

Al establecer la resolución de escritura en 10, puede usar con valores entre 0 y 1023
para aprovechar la resolución DAC completaanalogWrite()

La familia de placas MKR tiene las siguientes capacidades de hardware:

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 establecer la resolución de escritura en 12 bits, puede usar con valores entre 0 y 4095
para señales PWM; establezca 10 bits en el pin DAC para aprovechar la resolución DAC
completa de 1024 valores.analogWrite()

Sintaxis
analogWriteResolution(bits)

E/S avanzadas:
noTone()
[E/S avanzadas]
Descripción
Detiene la generación de una onda cuadrada desencadenada por . No tiene ningún
efecto si no se genera ningún tono.tone()

Sintaxis
noTone(pin)

pulseIn()
[E/S avanzadas]
Descripción
Lee un pulso (ya sea o ) en un alfiler. Por ejemplo, si es , espera a que el pin vaya de a ,
comienza a cronometrar, luego espera a que el pin se vaya y detiene el tiempo.
Devuelve la longitud del pulso en microsegundos o cede y devuelve 0 si no se recibió
ningún pulso completo dentro del tiempo de
espera.HIGHLOWvalueHIGHpulseIn()LOWHIGHLOW

El tiempo de esta función se ha determinado empíricamente y probablemente mostrará

errores en pulsos más largos. Trabaja en pulsos de 10 microsegundos a 3 minutos de
duración.

Nota
si se utiliza el tiempo de espera opcional, el código se ejecutará más rápido.
Sintaxis
pulseIn(pin, value)
pulseIn(pin, value, timeout)
pulseInLong()
[E/S avanzadas]
Descripción
pulseInLong() es una alternativa a pulseIn() que es mejor para manejar escenarios
afectados por pulsos largos e interrupciones.

Lee un pulso (ya sea o ) en un alfiler. Por ejemplo, si es , espera a que el pin vaya de a ,
comienza a cronometrar, luego espera a que el pin se vaya y detiene el tiempo.
Devuelve la longitud del pulso en microsegundos o cede y devuelve 0 si no se recibió
ningún pulso completo dentro del tiempo de
espera.HIGHLOWvalueHIGHpulseInLong()LOWHIGHLOW

El tiempo de esta función se ha determinado empíricamente y probablemente mostrará

errores en pulsos más cortos. Trabaja en pulsos de 10 microsegundos a 3 minutos de
duración. Esta rutina solo se puede utilizar si se activan las interrupciones. Además, la
resolución más alta se obtiene con grandes intervalos.

Sintaxis
pulseInLong(pin, value)
pulseInLong(pin, value, timeout)

shiftIn()
[E/S avanzadas]
Descripción
Cambia un byte de datos de un bit a la vez. Comienza desde el bit más significativo (es
decir, el más a la izquierda) o el menos (a la derecha). Para cada bit, el pin del reloj se
tira alto, el siguiente bit se lee desde la línea de datos y luego el pin del reloj se toma
bajo.

Si está interactuando con un dispositivo que está marcado por bordes ascendentes,
deberá asegurarse de que el pin del reloj esté bajo antes de la primera llamada a , por
ejemplo, con una llamada a .shiftIn()digitalWrite(clockPin, LOW)
Nota: esta es una implementación de software; Arduino también proporciona una
biblioteca SPI que utiliza la implementación de hardware, que es más rápida pero solo
funciona en pines específicos.

Sintaxis
byte incoming = shiftIn(dataPin, clockPin, bitOrder)

shiftOut()
[E/S avanzadas]
Descripción
Desplaza un byte de datos de un bit a la vez. Comienza desde el bit más significativo (es
decir, el más a la izquierda) o el menos (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 (tomado alto, luego bajo) para
indicar que el bit está disponible.

Nota: si está interactuando con un dispositivo que está marcado por bordes
ascendentes, deberá asegurarse de que el pin del reloj esté bajo antes de la llamada a ,
por ejemplo, con una llamada a .shiftOut()digitalWrite(clockPin, LOW)

Esta es una implementación de software; consulte también la biblioteca SPI,que

proporciona una implementación de hardware que es más rápida pero que solo
funciona en pines específicos.

Sintaxis
shiftOut(dataPin, clockPin, bitOrder, value)

tono()
[E/S avanzadas]
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 una
llamada a noTone(). El pin se puede conectar a un timbre piezoeléctrico u otro altavoz
para reproducir tonos.

Solo se puede generar un tono a la vez. Si un tono ya se está reproduciendo en un pin

diferente, la llamada a no tendrá ningún efecto. Si el tono se reproduce en el mismo pin,
la llamada establecerá su frecuencia.tone()

El uso de la función interferirá con la salida PWM en los pines 3 y 11 (en placas que no
sean mega).tone()

No es posible generar tonos inferiores a 31Hz. Para más detalles técnicos, véanse las
notas de Brett Hagman.

Sintaxis
tone(pin, frequency)
tone(pin, frequency, duration)
Hora
delay()
[Tiempo]
Descripción
Pausa el programa durante la cantidad de tiempo (en milisegundos) especificada como
parámetro. (Hay 1000 milisegundos en un segundo).

Sintaxis
delay(ms)

delayMicroseconds()
[Tiempo]
Descripción
Pausa el programa durante la cantidad de tiempo (en microsegundos) especificada por
el parámetro. Hay mil microsegundos en un milisegundo y un millón de microsegundos
en un segundo.

Actualmente, el mayor valor que producirá un retraso preciso es 16383; los valores más
grandes pueden producir un retraso extremadamente corto. Esto podría cambiar en
futuras versiones de Arduino. Para retrasos de más de unos pocos miles de
microsegundos, debe usar en su lugar.delay()

Sintaxis
delayMicroseconds(us)

micros()
[Tiempo]
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 las placas de la familia Arduino Portenta esta función
tiene una resolución de un microsegundo en todos los núcleos. 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 las
placas Arduino de 8 MHz (por ejemplo, el LilyPad), esta función tiene una resolución de
ocho microsegundos.

Sintaxis
time = micros()
millis()
[Tiempo]
Descripción
Devuelve el número de milisegundos pasados 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.
Sintaxis
time = millis()
Matemática:
Descripción
Calcula el valor absoluto de un número.

Sintaxis
abs(x)
constrain()
[Matemáticas]
Descripción
Restringe un número para que esté dentro de un rango.

Sintaxis
constrain(x, a, b)

Descripción
Vuelva a mapea un número de un rango a otro. Es decir, un valor de fromLow se asignaría
a toLow,un valor de fromHigh a toHigh,valores intermedios a valores intermedios, etc.

No restringe los valores dentro del rango, porque los valores fuera del rango a veces son
intencionados y útiles. La función se puede utilizar antes o después de esta función, si se
desean límites a los rangos.constrain()

Tenga en cuenta que los "límites inferiores" de cualquiera de los rangos pueden ser más
grandes o más pequeños que los "límites superiores", por lo que la función se puede
utilizar para invertir un rango de números, por ejemplo.map()
y = map(x, 1, 50, 50, 1);

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

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

también es válido y funciona bien.

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

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

máx()
[Matemáticas]
Descripción
Calcula el máximo de dos números.

Sintaxis
max(x, y)

min()
[Matemáticas]
Descripción
Calcula el mínimo de dos números.
Sintaxis
min(x, y)

pow()
[Matemáticas]
Descripción
Calcula el valor de un número elevado a una potencia. se puede usar para elevar un
número a una potencia fraccionaria. Esto es útil para generar un mapeo exponencial de
valores o curvas.pow()

Sintaxis
pow(base, exponent)

sq()
[Matemáticas]
Descripción
Calcula el cuadrado de un número: el número multiplicado por sí mismo.

Sintaxis
sq(x)

sqrt()
[Matemáticas]
Calcula la raíz cuadrada de un número.

Descripción
Sintaxis
sqrt(x)
Trigonometría:
cos()
[Trigonometría]
Descripción
Calcula el coseno de un ángulo (en radianes). El resultado será entre -1 y 1.

Sintaxis
cos(rad)
pecado()
[Trigonometría]
Descripción
Calcula el seno de un ángulo (en radianes). El resultado será entre -1 y 1.

Sintaxis
sin(rad)

Descripción
Calcula la tangente de un ángulo (en radianes). El resultado será entre infinito negativo
e infinito.

Sintaxis
tan(rad)
Caracteres
Descripción
Analiza si un char es alfa (es decir, una letra). Devuelve true si thisChar contiene una
letra.

Sintaxis
isAlpha(thisChar)
isAlphaNumeric():
[Personajes]
Descripción
Analice si un char es alfanumérico (es decir, una letra o un número). Devuelve true si
thisChar contiene un número o una letra.

Sintaxis
isAlphaNumeric(thisChar)

isAscii()
[Personajes]
Descripción
Analiza si un char es Ascii. Devuelve true si thisChar contiene un carácter Ascii.

Sintaxis
isAscii(thisChar)
isControl()
[Personajes]
Descripción
Analice si un char es un carácter de control. Devuelve true si thisChar es un carácter de
control.

Sintaxis
isControl(thisChar)
isDigit():
[Personajes]
Descripción
Analice si un char es un dígito (es decir, un número). Devuelve true si thisChar es un
número.

Sintaxis
isDigit(thisChar)

isGraph()
[Personajes]
Descripción
Analice si un char es imprimible con algún contenido (el espacio es imprimible pero no
tiene contenido). Devuelve true si thisChar es imprimible.

Sintaxis
isGraph(thisChar)

isHexadecimalDigit()
[Personajes]
Descripción
Analice si un char es un dígito hexadecimal (A-F, 0-9). Devuelve true si thisChar contiene
un dígito hexadecimal.

Sintaxis
isHexadecimalDigit(thisChar)

isLowerCase()
[Personajes]
Descripción
Analiza si un char es minúscula (es decir, una letra en minúsculas). Devuelve true si
thisChar contiene una letra en minúsculas.
Sintaxis
isLowerCase(thisChar)
isPrintable()
[Personajes]
Descripción
Analice si un char es imprimible (es decir, cualquier carácter que produzca una salida,
incluso un espacio en blanco). Devuelve true si thisChar es imprimible.

Sintaxis
isPrintable(thisChar)
isPunct()
[Personajes]
Descripción
Analice si un carácter es puntuación (es decir, una coma, un punto y coma, un signo de
exclamación, etc.). Devuelve true si thisChar es puntuación.

Sintaxis
isPunct(thisChar)
isSpace()
[Personajes]
Descripción
Analice si un carácter de espacio en blanco es un carácter de espacio en blanco.
Devuelve true si el argumento es un espacio, una fuente de formulario (), una nueva
línea (), un retorno de carro (), una ficha horizontal () o una ficha vertical
().'\f''\n''\r''\t''\v'

Sintaxis
isSpace(thisChar)
isUpperCase()
[Personajes]
Descripción
Analiza si un char es mayúscula (es decir, una letra en mayúsculas). Devuelve true si
thisChar está en mayúsculas.

Sintaxis
isUpperCase(thisChar)

Números aleatorios
aleatorio()
[Números aleatorios]
Descripción
La función aleatoria genera números pseudoaleatorios.

Sintaxis
random(max)
random(min, max)
randomSeed()
[Números aleatorios]
Descripción
randomSeed() inicializa el generador de números pseudoaleatorios, haciendo que
comience en un punto arbitrario de su secuencia aleatoria. Esta secuencia, aunque muy
larga y aleatoria, es siempre la misma.

Si es importante que una secuencia de valores generados por difiera, en ejecuciones

posteriores de un boceto, use randomSeed() para inicializar el generador de números
aleatorios con una entrada bastante aleatoria, como en un pin no
conectado.random()analogRead()

Por el contrario, ocasionalmente puede ser útil usar secuencias pseudoaleatorios que se
repiten exactamente. Esto se puede lograr llamando con un número fijo, antes de
comenzar la secuencia aleatoria.randomSeed()

Sintaxis
randomSeed(seed)
Bits y bytes
bit()
[Bits y bytes]
Descripción
Calcula el valor del bit especificado (el bit 0 es 1, el bit 1 es 2, el bit 2 es 4, etc.).

Sintaxis
bit(n)

bitClear()
[Bits y bytes]
Descripción
Borra (escribe un 0 en) un bit de una variable numérica.

Sintaxis
bitClear(x, n)
bitRead()
[Bits y bytes]
Descripción
Lee un poco de un número.

Sintaxis
bitRead(x, n)

bitSet()
[Bits y bytes]
Descripción
Establece (escribe un 1 en) un bit de una variable numérica.

Sintaxis
bitSet(x, n)
bitWrite()
[Bits y bytes]
Descripción

Escribe un poco de una variable numérica.

Sintaxis
bitWrite(x, n, b)

highByte()
[Bits y bytes]
Descripción
Extrae el byte de orden alto (el más a la izquierda) de una palabra (o el segundo byte
más bajo de un tipo de datos más grande).
Sintaxis
highByte(x)

Interrupciones externas
attachInterrupt()
[Interrupciones externas]
Descripción
Pines digitales con interrupciones

El primer parámetro es un número de interrupción. Normalmente, debe usar para traducir

el pin digital real al número de interrupción específico. Por ejemplo, si se conecta al pin 3,
utilice como primer parámetro para
.attachInterrupt()digitalPinToInterrupt(pin)digitalPinToInterrupt(3)attachInterrupt()

Sintaxis
attachInterrupt(digitalPinToInterrupt(pin), ISR, mode) (recomendado)
(no recomendado)
(No recomendado. Además, esta sintaxis solo funciona en placas SAMD Arduino, Uno WiFi
Rev2, Due y 101).attachInterrupt(interrupt, ISR, mode)attachInterrupt(pin, ISR, mode)

noInterrupciones()
[Interrupciones]
Descripción
Deshabilita las interrupciones (puede volver a habilitarlas con ). Las interrupciones
permiten que ciertas tareas importantes ocurran en segundo plano y están habilitadas de
forma predeterminada. Algunas funciones no funcionarán mientras las interrupciones
estén deshabilitadas y es posible que se ignore la comunicación entrante. Sin embargo, las
interrupciones pueden interrumpir ligeramente el tiempo del código y pueden
deshabilitarse para secciones de código particularmente críticas.interrupts()

Sintaxis
noInterrupts()

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

USB
Descripción
Las funciones de teclado permiten que las placas basadas en micro 32u4 o SAMD envíen
pulsaciones de teclas a una computadora conectada a través del puerto USB nativo de
su micro.

Ratón
[USB]
Descripción
Las funciones del ratón permiten que las placas basadas en micro 32u4 o SAMD controlen
el movimiento del cursor en una computadora conectada a través del puerto USB nativo
de su micro. Al actualizar la posición del cursor, siempre es relativa a la ubicación anterior
del cursor.

Variables
Constantes
Tipos de datos y constantes de Arduino.
constantes
[Constantes]
Descripción
Las constantes son expresiones predefinidas en el lenguaje Arduino. Se utilizan para hacer
que los programas sean más fáciles de leer. Clasificamos las constantes en grupos:

Definición de niveles lógicos: true y false (constantes booleanas)

Hay dos constantes utilizadas para representar la verdad y la falsedad en el lenguaje
Arduino: , y .truefalse

falso
false es el más fácil de definir de los dos. false se define como 0 (cero).

verdadero
true a menudo se dice que se define como 1, lo cual es correcto, pero el verdadero tiene
una definición más amplia. Cualquier entero que no sea cero es verdadero, en un sentido
booleano. Así que -1, 2 y -200 también se definen como verdaderos, en un sentido
booleano.

Tenga en cuenta que las constantes y se escriben en minúsculas a diferencia de , , , y

.truefalseHIGHLOWINPUTOUTPUT
onstantes de coma flotante
[Constantes]
Descripción
Al igual que las constantes enteras, las constantes de coma flotante se utilizan para hacer
que el código sea más legible. Las constantes de coma flotante se intercambian en tiempo
de compilación por el valor al que se evalúa la expresión.

Código de ejemplo
n = 0.005; // 0.005 is a floating point constant
Constantes enteras
[Constantes]
Descripción
Las constantes enteras son números que se usan directamente en un boceto, como 123.
De forma predeterminada, estos números se tratan como int, pero puede cambiar esto
con los modificadores you y L (consulte a continuación).

Normalmente, las constantes enteras se tratan como enteros de base 10 (decimales), pero
se puede usar notación especial (formateador) para ingresar números en otras bases.

Conversión
(sin firmar int)
[Conversión]
Descripción
Convierte un valor en el tipo de datos.unsigned int

Sintaxis
(unsigned int)x
Descripción
Convierte un valor en el tipo de datos.unsigned long

Sintaxis
(unsigned long)x

byte():
[Conversión]
Descripción
Convierte un valor en el tipo de datos.byte

Sintaxis
byte(x)
(byte)x (Conversión de tipo estilo C)

char()
[Conversión]
Descripción
Convierte un valor en el tipo de datos.char

Sintaxis
char(x)
(char)x (Conversión de tipo estilo C)

float()
[Conversión]
Descripción
Convierte un valor en el tipo de datos.float

Sintaxis
float(x)
(float)x (Conversión de tipo estilo C)

int()
[Conversión]
Descripción
Convierte un valor en el tipo de datos.int

Sintaxis
int(x)
(int)x (Conversión de tipo estilo C)
long()
[Conversión]
Descripción
Convierte un valor en el tipo de datos.long

Sintaxis
long(x)
(long)x (Conversión de tipo estilo C)

palabra()
[Conversión]
Descripción
Convierte un valor en el tipo de datos.word

Sintaxis
word(x)
word(h, l)
(word)x (Conversión de tipo estilo C)

arreglo
[Tipos de datos]
Descripción
Una matriz es una colección de variables a las que se accede con un número de índice.
Las matrices en el lenguaje de programación C ++ en el que se escriben los bocetos de
Arduino pueden ser complicadas, pero el uso de matrices simples es relativamente
sencillo.
bool
[Tipos de datos]
Descripción
A contiene uno de dos valores, o . (Cada variable ocupa un byte de
memoria.)booltruefalsebool

Sintaxis
bool var = val;

booleano
[Tipos de datos]
Descripción
boolean es un alias de tipo no estándar definido por Arduino. Se recomienda en su lugar
utilizar el tipo estándar bool, que es idéntico.bool

byte
[Tipos de datos]
Descripción
Un byte almacena un número sin firmar de 8 bits, de 0 a 255.

Sintaxis
byte var = val;

Tipos de datos] vchar

Descripción
Tipo de datos que se utiliza para almacenar un valor de carácter. Los literales de
caracteres se escriben entre comillas simples, como esta: 'A' (para múltiples 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 sobre
caracteres, en la que se utiliza 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 para
obtener más información sobre cómo se traducen los caracteres en
números.Serial.println

El tamaño del tipo de datos es de al menos 8 bits. Se recomienda usarlo solo para
almacenar caracteres. Para un tipo de datos sin firmar, de un byte (8 bits), utilice el tipo
de datos.charcharbyte

Sintaxis
char var = val;

doble
[Tipos de datos]
Descripción
Número de coma flotante de doble precisión. En uno y otras placas basadas en
ATMEGA, esto ocupa 4 bytes. Es decir, la doble implementación es exactamente la
misma que la flotador, sin ganancia de precisión.

En el Arduino Due, los dobles tienen una precisión de 8 bytes (64 bits).

Sintaxis
double var = val;
float
int
Descripción
Los enteros son el tipo de datos principal para el almacenamiento de números.

En Arduino Uno (y otras placas basadas en ATmega) un int almacena un valor de 16 bits
(2 bytes). Esto produce un rango de -32,768 a 32,767 (valor mínimo de -2^15 y un valor
máximo de (2^15) - 1). En las placas basadas en Arduino Due y SAMD (como MKR1000 y
Zero), un int almacena un valor de 32 bits (4 bytes). Esto arroja un rango de
-2,147,483,648 a 2,147,483,647 (valor mínimo de -2^31 y un valor máximo de (2^31) - 1).

int's almacena números negativos con una técnica llamada (2's complement math). El
bit más alto, a veces denominado bit "signo", marca el número como un número
negativo. El resto de los bits se invierten y se añade 1.

El Arduino se encarga de lidiar con los números negativos por usted, para que las
operaciones aritméticas funcionen de manera transparente de la manera esperada. Sin
embargo, puede haber una complicación inesperada al tratar con el operador derecho
de desplazamiento de bits ().>>

Sintaxis

long
Descripción
Las variables largas son variables de tamaño extendido para el almacenamiento de
números y almacenan 32 bits (4 bytes), desde -2.147.483.648 hasta 2.147.483.647.

Si haciendo matemáticas con enteros al menos uno de los valores debe ser de tipo largo,
ya sea una constante entera seguida de una L o una variable de tipo largo, forzándola a
ser larga. Consulte la página Constantes enteras para obtener más información.
Sintaxis
long var = val;

short
Descripción
Un corto es un tipo de datos de 16 bits.

En todos los Arduinos (basados en ATMega y ARM) un corto almacena un valor de 16

bits (2 bytes). Esto produce un rango de -32,768 a 32,767 (valor mínimo de -2^15 y un
valor máximo de (2^15) - 1).

Sintaxis
short var = val;

size_t
size_t
[Tipos de datos]
Descripción
size_t es un tipo de datos capaz de representar el tamaño de cualquier objeto en bytes.
Ejemplos del uso de son el tipo de retorno de y .size_tsizeof()Serial.print()

Sintaxis
size_t var = val;

string
Descripción
Las cadenas de texto se pueden representar de dos maneras. puede utilizar el tipo de
datos String, que forma parte del núcleo a partir de la versión 0019, o puede hacer una
cadena a partir de una matriz de tipo char y terminarla en null. En esta página se
describe este último método. Para obtener más información sobre el objeto String, que
proporciona más funcionalidad a costa de más memoria, consulte la página objeto
String.

Sintaxis
Todas las siguientes son declaraciones válidas para cadenas.

char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";

String()
String()
[Tipos de datos]
Descripción
Construye una instancia de la clase String. Hay varias versiones que construyen cadenas
a partir de diferentes tipos de datos (es decir, formatearlas como secuencias de
caracteres), que incluyen:

una cadena constante de caracteres, entre comillas dobles (es decir, una matriz de
caracteres)

un solo carácter constante, entre comillas simples

otra instancia del objeto String

un entero constante o un entero largo

un entero constante o un entero largo, utilizando una base especificada

una variable entera o larga

una variable entera o larga, utilizando una base especificada

un float o doble, utilizando unos decimales especificados

La construcción de una cadena a partir de un número da como resultado una cadena

que contiene la representación ASCII de ese número. El valor predeterminado es la base
diez, por lo que

String thisString = String(13);

te da la cadena "13". Sin embargo, puede usar otras bases. Por ejemplo

String thisString = String(13, HEX);

le da la cadena "d", que es la representación hexadecimal del valor decimal 13. O si
prefieres binario,

String thisString = String(13, BIN);

le da la cadena "1101", que es la representación binaria de 13.

Sintaxis
String(val)
String(val, base)
String(val, decimalPlaces)
unsigned char

Descripción
Tipo de datos sin firmar que ocupa 1 byte de memoria. Igual que el tipo de datos.byte

El tipo de datos char sin firmar codifica números del 0 al 255.

Para la consistencia del estilo de programación de Arduino, se prefiere el tipo de datos

de byte.

Sintaxis
unsigned char var = val;
unsigned int
palabra larga
vacía
sin firmar

Alcance variable y calificadores:

const
onst
[Alcance variable y calificadores]
Descripción
La palabra clave significa constante. Es un calificador de variables que modifica el
comportamiento de la variable, haciendo una variable "de solo lectura". Esto significa
que la variable se puede usar como cualquier otra variable de su tipo, pero su valor no
se puede cambiar. Obtendrá un error del compilador si intenta asignar un valor a una
variable.constconst

Las constantes definidas con la palabra clave obedecen a las reglas de alcance de
variables que gobiernan otras variables. Esto, y las trampas del uso, hacen que la
palabra clave sea un método superior para definir constantes y se prefiere a usar
#define.const#definecons
scope
Descripción
Las variables en el lenguaje de programación C++, que utiliza Arduino, tienen una
propiedad llamada scope. Esto contrasta con las primeras versiones de lenguajes como
BASIC, donde cada variable es una variable global.

Una variable global es aquella que puede ser vista por cada función en un programa. Las
variables locales solo son visibles para la función en la que se declaran. En el entorno de
Arduino, cualquier variable declarada fuera de una función (por ejemplo, , , etc.), es una
variable global.setup()loop()

Cuando los programas comienzan a ser más grandes y complejos, las variables locales
son una forma útil de asegurar que solo una función tenga acceso a sus propias
variables. Esto evita errores de programación cuando una función modifica
inadvertidamente las variables utilizadas por otra función.

A veces también es útil declarar e inicializar una variable dentro de un bucle. Esto crea
una variable a la que solo se puede acceder desde el interior de los corchetes for-
loop.for

Estático
escripción
La palabra clave se utiliza para crear variables que son visibles para una sola función. Sin
embargo, a diferencia de las variables locales que se crean y destruyen cada vez que se
llama a una función, las variables estáticas persisten más allá de la llamada a la función,
preservando sus datos entre las llamadas a la función.static
Las variables declaradas como estáticas solo se crearán e inicializarán la primera vez que
se llame a una función.

volátil
Descripción
volatile es una palabra clave conocida como calificador devariables, se suele utilizar
antes del tipo de datos de una variable, para modificar la forma en que el compilador y
el programa posterior tratan la variable.

Declarar una variable es una directiva para el compilador. El compilador es un software

que traduce su código C / C ++ en el código de la máquina, que son las instrucciones
reales para el chip Atmega en el Arduino.volatile

Utilidades:
PROGMEM
Descripción
Almacene los datos en memoria flash (de programa) en lugar de SRAM. Hay una
descripción de los diversos tipos de memoria disponibles en una placa Arduino.

La palabra clave es un modificador de variables, debe usarse solo con los tipos de datos
definidos en pgmspace.h. Le dice al compilador "ponga esta información en la memoria
flash", en lugar de en SRAM, donde normalmente iría.PROGMEM

PROGMEM forma parte de la biblioteca pgmspace.h. Se incluye automáticamente en las

versiones modernas del IDE. Sin embargo, si está utilizando una versión de IDE inferior a
1.0 (2011), primero deberá incluir la biblioteca en la parte superior del boceto, de la
siguiente manera:
#include <avr/pgmspace.h> Si bien podría usarse en una sola variable, en realidad solo
vale la pena el alboroto si tiene un bloque más grande de datos que debe almacenarse,
lo que generalmente es más fácil en una matriz (u otra estructura de datos de C ++ más
allá de nuestra discusión actual).PROGMEM

El uso también es un procedimiento de dos pasos. Después de obtener los datos en la

memoria Flash, se requieren métodos especiales (funciones), también definidos en la
biblioteca pgmspace.h, para leer los datos de la memoria del programa en SRAM, por lo
que podemos hacer algo útil con él.PROGMEM

Sintaxis
const dataType variableName[] PROGMEM = {data0, data1, data3…};

Tenga en cuenta que debido a que PROGMEM es un modificador de variables, no existe

una regla dura y rápida sobre dónde debe ir, por lo que el compilador arduino acepta
todas las definiciones a continuación, que también son sinónimas. Sin embargo, los
experimentos han indicado que, en varias versiones de Arduino (que tienen que ver con
la versión GCC), PROGMEM puede funcionar en un lugar y no en otro. El ejemplo de
"tabla de cadenas" a continuación se ha probado para funcionar con Arduino 13. Las
versiones anteriores del IDE pueden funcionar mejor si PROGMEM se incluye después
del nombre de la variable.

const dataType variableName[] PROGMEM = {}; // use this form

const PROGMEM dataType variableName[] = {}; // or this one
const dataType PROGMEM variableName[] = {}; // not this one

sizeof()
sizeof()
[Utilidades]
Descripción
El operador devuelve el número de bytes en un tipo de variable o el número de bytes
ocupados por una matriz.sizeof

Sintaxis
sizeof(variable)

Estructura
Bosquejo
loop()
bucle()
[Boceto]
Descripción
Después de crear una función, que inicializa y establece los valores iniciales, la función
hace exactamente lo que su nombre sugiere, y se repite consecutivamente, lo que
permite que su programa cambie y responda. Úselo para controlar activamente la placa
Arduino.setup()loop()

Código de ejemplo
int buttonPin = 3;

// setup initializes serial and the button pin

void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}

// loop checks the button pin each time,

// and will send serial if it is pressed
void loop() {
 if (digitalRead(buttonPin) == HIGH) {
Serial.write('H');
}
else {
Serial.write('L');
}

delay(1000);
}
setup()
setup()
[Boceto]
Descripción
Se llama a la función cuando se inicia un boceto. Úselo para inicializar variables, modos
de anclaje, comenzar a usar bibliotecas, etc. La función solo se ejecutará una vez,
después de cada encendido o reinicio de la placa Arduino.setup()setup()

Código de ejemplo
int buttonPin = 3;

void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}

void loop() {
// ...
}
Estructura de control:
descanso
Descripción
break se utiliza para salir de un , bucle, evitando la condición de bucle normal. También se
utiliza para salir de una declaración.forwhiledo…whileswitch case

Código de ejemplo
En el código siguiente, el control sale del bucle for cuando el valor del sensor supera el
umbral.

int threshold = 40;

for (int x = 0; x < 255; x++) {
analogWrite(PWMpin, x);
sens = analogRead(sensorPin);
if (sens > threshold) { // bail out on sensor detect
x = 0;
break;
}
delay(50);
}
continuar :
Descripción
La instrucción omite el resto de la iteración actual de un bucle (, , o ). Continúa
comprobando la expresión condicional del bucle y procediendo con cualquier iteración
posterior.continueforwhiledo…while

Código de ejemplo
El código siguiente escribe el valor de 0 a 255 en el , pero omite los valores en el rango de
41 a 119.PWMpin
for (int x = 0; x <= 255; x ++) {
if (x > 40 && x < 120) { // create jump in values
continue;
}

analogWrite(PWMpin, x);
delay(50);
}
hacer... mientras que
Descripción
El bucle funciona de la misma manera que el bucle, con la excepción de que la condición
se prueba al final del bucle, por lo que el bucle do siempre se ejecutará al menos una
vez.do…whilewhile

Sintaxis
do {
// statement block
} while (condition);
Parámetros
condition: una expresión booleana que evalúa a o .truefalse

Código de ejemplo
int x = 0;
do {
delay(50); // wait for sensors to stabilize
x = readSensors(); // check the sensors
} while (x < 100);
de lo contrario:
Descripción
Permite un mayor control sobre el flujo de código que la instrucción básica, al permitir
que se agrupon múltiples pruebas. Se ejecutará una cláusula (si es que existe) si la
condición de la instrucción da como resultado . Puede proceder a otra prueba, de modo
que se puedan ejecutar múltiples pruebas mutuamente excluyentes al mismo
tiempo.if…elseifelseiffalseelseif

Cada prueba pasará 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,
a continuación, el programa salta a la línea que sigue toda la construcción if/else. Si
ninguna prueba resulta ser verdadera, se ejecuta el bloque predeterminado, si hay uno
presente, y se establece el comportamiento predeterminado.else

Tenga en cuenta que un bloque se puede utilizar con o sin un bloque de terminación y
viceversa. Se permite un número ilimitado de tales sucursales.else ifelseelse if

Sintaxis
if (condition1) {
// do Thing A
}
else if (condition2) {
// do Thing B
}
else {
// do Thing C
}

para :
Descripción
La instrucción se utiliza para repetir un bloque de instrucciones encerradas en llaves
rizadas. Por lo general, se utiliza un contador de incrementos para incrementar y
finalizar el bucle. La instrucción es útil para cualquier operación repetitiva y a menudo se
usa en combinación con matrices para operar en colecciones de datos / pines.forfor

Sintaxis
for (initialization; condition; increment) {
// statement(s);
}

goto:

Descripción
Transfiere el flujo del programa a un punto etiquetado en el programa

Sintaxis
label:

goto label; // sends program flow to the label

si
volver:
Descripción
Termine una función y devuelva un valor de una función a la función de llamada, si lo
desea.

Sintaxis
return;
return value;

si
[Estructura de control]
Descripción
La instrucción comprueba si hay una condición y ejecuta la siguiente instrucción o
conjunto de instrucciones si la condición es "true".if

Sintaxis
if (condition) {
//statement(s)
}
Sintaxis adicional
#define (definir)
escripción
#define es un componente útil de C++ que permite al programador dar un nombre a un
valor constante antes de compilar el programa. Las constantes definidas en arduino no
ocupan ningún espacio de memoria de programa en el chip. El compilador reemplazará
las referencias a estas constantes con el valor definido en tiempo de compilación.
Sin embargo, esto puede tener algunos efectos secundarios no deseados, si, por
ejemplo, un nombre constante que se había #defined se incluye en algún otro nombre
de constante o variable. En ese caso, el texto se sustituiría por el número (o texto)
#defined.

En general, la palabra clave se prefiere para definir constantes y debe usarse en lugar
de .const#define

Sintaxis
#define constantName value

#include (incluir)
Descripción
#include se utiliza para incluir bibliotecas externas en el boceto. Esto le da al
programador acceso a un gran grupo de bibliotecas C estándar (grupos de funciones pre-
hechas), y también bibliotecas escritas especialmente para Arduino.

La página de referencia principal para las bibliotecas AVR C (AVR es una referencia a los
chips Atmel en los que se basa el Arduino) está aquí.

Tenga en cuenta que , similar a , no tiene terminador de punto y coma, y el compilador

producirá mensajes de error crípticos si agrega uno.#include#define

Sintaxis
#include <LibraryFile.h>
#include "LocalFile.h"
/* */ (bloquear comentario)
Descripción
Los comentarios son líneas en el programa que se utilizan para informarse a sí mismo o
a otros sobre la forma en que funciona el programa. El compilador los ignora y no se
exportan al procesador, por lo que no ocupan ningún espacio en la memoria flash del
microcontrolador. El único propósito de los comentarios es ayudarlo a comprender (o
recordar), o informar a otros sobre cómo funciona su programa.

El comienzo de un comentario de bloque o un comentario de varias líneas está marcado

por el símbolo y el símbolo marca su final. Este tipo de comentario se llama así ya que
este puede extenderse sobre más de una línea; una vez que el compilador lee el, ignora
lo que sigue hasta que encuentra un archivo ./**//**/

// (comentario de una sola línea)

Los comentarios son líneas en el programa que se utilizan para informarse a sí mismo o
a otros sobre la forma en que funciona el programa. El compilador los ignora y no se
exportan al procesador, por lo que no ocupan ningún espacio en la memoria flash del
microcontrolador. El único propósito de los comentarios es ayudarlo a comprender (o
recordar), o informar a otros sobre cómo funciona su programa.

Un comentario de una sola línea comienza con (dos barras diagonales adyacentes). Este
comentario termina automáticamente al final de una línea. Lo que siga hasta el final de
una línea será ignorado por el compilador.////

; (punto y coma)
{} (brackets rizados)
Operadores aritméticos
% (resto)
Descripción
La operación Remanente calcula el resto cuando un entero se divide por otro. Es útil
para mantener una variable dentro de un rango particular (por ejemplo, el tamaño de
una matriz). El símbolo (porcentaje) se utiliza para llevar a cabo la operación de
remanente.%

Sintaxis
remainder = dividend % divisor;

* (multiplicación)
Descripción
La multiplicación es una de las cuatro operaciones aritméticas primarias. El operador
(asterisco) opera sobre dos operandos para producir el producto.*

Sintaxis
product = operand1 * operand2;

+ (suma)
Descripción
La suma es una de las cuatro operaciones aritméticas primarias. El operador (más) opera
en dos operandos para producir la suma.+

Sintaxis
sum = operand1 + operand2;
- (resta)
Descripción
La resta es una de las cuatro operaciones aritméticas primarias. El operador (menos)
opera en dos operandos para producir la diferencia del segundo del primero.-

Sintaxis
difference = operand1 - operand2;

/ (división)
Descripción
La división es una de las cuatro operaciones aritméticas primarias. El operador (barra)
opera en dos operandos para producir el resultado./

Sintaxis
result = numerator / denominator;

= (operador de asignación)
escripción
El signo igual único en el lenguaje de programación C++ se denomina operador de
asignación. Tiene un significado diferente al de la clase de álgebra donde indicaba una
ecuación o igualdad. El operador de asignación le dice al microcontrolador que evalúe
cualquier valor o expresión que se encuentra en el lado derecho del signo igual y lo
almacene en la variable a la izquierda del signo igual.=

Operadores de comparación:
!= (no igual a)
escripción
Compara la variable de la izquierda con el valor o variable de la derecha del operador.
Devuelve true cuando los dos operandos no son iguales. Tenga en cuenta que puede
comparar variables de diferentes tipos de datos, pero eso podría generar resultados
impredecibles, por lo tanto, se recomienda comparar variables del mismo tipo de datos,
incluido el tipo firmado / no firmado.

Sintaxis
x != y; // is false if x is equal to y and it is true if x is not equal to y

< (menor que)

Descripción
Compara la variable de la izquierda con el valor o variable de la derecha del operador.
Devuelve true cuando el operando de la izquierda es menor (más pequeño) que el
operando de la derecha. Tenga en cuenta que puede comparar variables de diferentes
tipos de datos, pero eso podría generar resultados impredecibles, por lo tanto, se
recomienda comparar variables del mismo tipo de datos, incluido el tipo firmado / no
firmado.

Sintaxis
x < y; // is true if x is smaller than y and it is false if x is equal or bigger than y

<= (menor o igual a)

Descripción
Compara la variable de la izquierda con el valor o variable de la derecha del operador.
Devuelve true cuando el operando de la izquierda es menor (menor) o igual que el
operando de la derecha. Tenga en cuenta que puede comparar variables de diferentes
tipos de datos, pero eso podría generar resultados impredecibles, por lo tanto, se
recomienda comparar variables del mismo tipo de datos, incluido el tipo firmado / no
firmado.

Sintaxis
x ⇐ y; // is true if x is smaller than or equal to y and it is false if x is greater than y

== (igual a)
Descripción
Compara la variable de la izquierda con el valor o variable de la derecha del operador.
Devuelve true cuando los dos operandos son iguales. Tenga en cuenta que puede
comparar variables de diferentes tipos de datos, pero eso podría generar resultados
impredecibles, por lo tanto, se recomienda comparar variables del mismo tipo de datos,
incluido el tipo firmado / no firmado.

Sintaxis
x == y; // is true if x is equal to y and it is false if x is not equal to y

> (mayor que)

Descripción
Compara la variable de la izquierda con el valor o variable de la derecha del operador.
Devuelve true cuando el operando de la izquierda es mayor (más grande) que el
operando de la derecha. Tenga en cuenta que puede comparar variables de diferentes
tipos de datos, pero eso podría generar resultados impredecibles, por lo tanto, se
recomienda comparar variables del mismo tipo de datos, incluido el tipo firmado / no
firmado.

Sintaxis
x > y; // is true if x is bigger than y and it is false if x is equal or smaller than y

>= (mayor o igual a)

escripción
Compara la variable de la izquierda con el valor o variable de la derecha del operador.
Devuelve true cuando el operando de la izquierda es mayor (más grande) que o igual
que el operando de la derecha. Tenga en cuenta que puede comparar variables de
diferentes tipos de datos, pero eso podría generar resultados impredecibles, por lo
tanto, se recomienda comparar variables del mismo tipo de datos, incluido el tipo
firmado / no firmado.

Sintaxis
x >= y; // is true if x is bigger than or equal to y and it is false if x is smaller than y

Operadores booleanos:
! (lógico no)
El NO lógico resulta en un si el operando es y viceversa.truefalse

Código de ejemplo
Este operador se puede utilizar dentro de la condición de una instrucción if.

if (!x) { // if x is not true

// statements
}

&& (lógico y)
Descripción
Logical AND resulta en sólo si ambos operandos son .truetrue

Código de ejemplo
Este operador se puede utilizar dentro de la condición de una instrucción if.

if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { // if BOTH the switches read

HIGH
// statements
|| (lógico o
Descripción
Or lógico resulta en a si cualquiera de los dos operandos es .truetrue

Código de ejemplo
Este operador se puede utilizar dentro de la condición de una instrucción if.

if (x > 0 || y > 0) { // if either x or y is greater than zero

// statements

Operadores de acceso de puntero:

& Descripción
La referencia es una de las características específicas para usar con punteros. El
operador ampersand se utiliza para este propósito. Si es una variable, entonces
representa la dirección de la variable .&x&xx

Código de ejemplo
int *p; // declare a pointer to an int data type
int i = 5;
int result = 0;
p = &i; // now 'p' contains the address of 'i'
result = *p; // 'result' gets the value at the address pointed by 'p'
// i.e., it gets the value of 'i' which is 5 (operador

de referencia) * (operador de desreferencia)

Descripción
La desreferenciación es una de las características específicas para su uso con punteros.
El operador de asterisco se utiliza para este propósito. Si es un puntero, representa el
valor contenido en la dirección señalada por .*p*pp

Código de ejemplo
int *p; // declare a pointer to an int data type
int i = 5;
int result = 0;
p = &i; // now 'p' contains the address of 'i'
result = *p; // 'result' gets the value at the address pointed by 'p'
// i.e., it gets the value of 'i' which is 5

Operadores Bitwise:
& (bitwise y)
Descripción
El operador bitwise AND en C++ es un solo ampersand , usado entre otras dos
expresiones enteras. Bitwise AND opera en cada posición de bit de las expresiones
circundantes de forma independiente, de acuerdo con esta regla: si ambos bits de
entrada son 1, la salida resultante es 1, de lo contrario la salida es 0.&
<< (bitshift left)
El operador de desplazamiento a la izquierda hace que los bits del operando izquierdo
se desplazquen a la izquierda por el número de posiciones especificadas por el operando
derecho.<<

Sintaxis
variable << number_of_bits;
>> (bitshift right)
escripción
El operador de desplazamiento a la derecha hace que los bits del operando izquierdo se
desplazquen a la derecha por el número de posiciones especificadas por el operando
derecho.>>

Sintaxis
variable >> number_of_bits;

^ (bitwise xor)
Descripción
Hay un operador algo inusual en C ++ llamado bitwise EXCLUSIVE OR, también conocido
como bitwise XOR. (En inglés esto generalmente se pronuncia "eks-or".) El operador
XOR bitwise se escribe usando el símbolo de caret . Una operación XOR bitwise da como
resultado un 1 solo si los bits de entrada son diferentes, de lo contrario da como
resultado un 0.^

| (bitwise o)
Descripción
El operador OR bitwise en C++ es el símbolo de barra vertical, |. Al igual que el &
operador, | opera independientemente cada bit en sus dos expresiones enteras
circundantes, pero lo que hace es diferente (por supuesto). El OR bitwise de dos bits es 1
si uno o ambos bits de entrada es 1, de lo contrario es 0.

~ (bitwise no)
Descripción
El operador NOT bitwise en C++ es el carácter tilde . A diferencia de & y |, el operador
BITWISE NOT se aplica a un solo operando a su derecha. Bitwise NO cambia cada bit a su
opuesto: 0 se convierte en 1 y 1 se convierte en 0.~

Operadores compuestos:
%= (resto compuesto)
Descripción
Esta es una abreviatura conveniente para calcular el resto cuando un entero se divide
por otro y asignarlo de nuevo a la variable en la que se realizó el cálculo.

Sintaxis
x %= divisor; // equivalent to the expression x = x % divisor;

&= (compuesto bitwise y)

escripción
El operador compuesto bitwise AND se usa a menudo con una variable y una constante
para forzar bits particulares en una variable al estado LOW (a 0). Esto a menudo se
conoce en las guías de programación como "borrar" o "restablecer" bits.&=
*= (multiplicación compuesta)
Descripción
Esta es una taquigrafía conveniente para realizar la multiplicación de una variable con
otra constante o variable.

Sintaxis
x *= y; // equivalent to the expression x = x * y;
++ (incremento)
Descripción
Incrementa el valor de una variable en 1.

Sintaxis
x++; // increment x by one and returns the old value of x
++x; // increment x by one and returns the new value of x

+= (suma compuesta)
Descripción
Esta es una abreviatura conveniente para realizar la adición en una variable con otra
constante o variable.

Sintaxis
x += y; // equivalent to the expression x = x + y;

-- (decremento)
Descripción
Disminuye el valor de una variable en 1.

Sintaxis
x--; // decrement x by one and returns the old value of x
--x; // decrement x by one and returns the new value of x

-= (resta compuesta)
Descripción
Esta es una abreviatura conveniente para realizar la resta de una constante o una
variable de una variable.

Sintaxis
x -= y; // equivalent to the expression x = x - y;

/= (división compuesta)
Descripción
Esta es una taquigrafía conveniente para realizar la división de una variable con otra
constante o variable.

Sintaxis
x /= y; // equivalent to the expression x = x / y;

^= (compuesto bitwise xor)

Descripción
El operador XOR bitwise compuesto se usa a menudo con una variable y una constante
para alternar (invertir) bits particulares en una variable.^=

Una revisión del operador Bitwise XOR:^

0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 0 (operand1 ^ operand2) - returned result
Sintaxis
x ^= y; // equivalent to x = x ^ y;

|= (compuesto bitwise o)

Descripción
El operador OR bitwise compuesto se usa a menudo con una variable y una constante
para "establecer" (establecer en 1) bits particulares en una variable.|=

Una revisión del operador Bitwise OR:|

0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 1 (operand1 | operand2) - returned result
Sintaxis
x |= y; // equivalent to x = x | y;

4. Programas y planos de arduino que se desarrollen en clase.

5. Todo debe entregarse en PDF

6. Aplicar para este trabajo la norma APA.