# data[].attributes.body
Arduino es una plataforma de desarrollo basada en una placa electrónica de hardware libre que incorpora un microcontrolador re-programable y una serie de pines hembra. Estos permiten establecer conexiones entre el microcontrolador y los diferentes sensores y actuadores de una manera muy sencilla (principalmente con cables dupont).

# data[].attributes.body
una placa de prototipado o desarrollo es una placa electrónica que nos permite hacer prototipos con electrónica y programación.

Se pueden hacer robots, impresoras 3D, proyectos domóticos y objetos conectados para el Internet de las Cosas o IoT.

# data[].attributes.body
Sí, esto quiere decir que el código fuente del software de arduino está disponible públicamente y se puede acceder, estudiar y modificar de acuerdo con las necesidades de los usuarios. Esto permite que la comunidad de usuarios y desarrolladores colaboren, mejoren y personalicen el software según sus requerimientos específicos.

# data[].attributes.headline
¿Que significa que Arduino sea hardware libre?

# data[].attributes.subject
¿Que significa que Arduino sea hardware libre?

# data[].attributes.body
Esto significa que cualquier persona puede acceder al diseño y las especificaciones del hardware de Arduino, como los esquemas de circuito y los diseños de PCB (placas de circuito impreso), y utilizarlos como base para desarrollar y fabricar sus propias versiones de la plataforma Arduino. Además, los usuarios pueden modificar y adaptar el diseño para satisfacer sus necesidades específicas.

# data[].attributes.attachment_link.readable_text
El Arduino Micro es una placa basada en el microcontrolador ATmega32U4, y fue desarrollada en conjunto con Adafruit. Dispone de 20 pines de entrada y salida digitales, de los cuales 7 se pueden usar como salidas PWM y 12 como entradas analógicas. Tiene un oscilador de cristal de 16 MHz, una conexión micro USB, un encabezado ICSP y un botón de reset.

La placa Arduino Micro Contiene todo lo necesario para soportar el microcontrolador. Simplemente conectarla al ordenador con un cable micro USB para comenzar. Tiene un factor de forma que le permite colocarse fácilmente en una placa de pruebas.

La placa Arduino Micro es similar a la placa Arduino Leonardo en que el ATmega32U4 tiene incorporada capacidad de comunicación por USB, eliminando la necesidad de un procesador secundario, como en el caso de la placa Arduino UNO R3.

Esto permite que la Arduino Micro al ceonctarse a un ordenador mediante el puerto micro USB aparezca como un mouse y teclado, además de un puerto serie o COM virtual ( CDC).

Características de la Arduino Micro

Microcontrolador: ATmega32U4

Voltaje de funcionamiento: 5 V

Voltaje de entrada (recomendado): 7-12 V

Voltaje de entrada (límite): 6-20 V

Pines de E/S digitales: 20

Canales PWM: 7

Canales de entrada analógica: 12

Corriente CC por pin de E/S: 20 mA

Corriente CC para pin de 3.3V: 50 mA

Memoria Flash: 32 KB (ATmega32U4) de los cuales 4 KB utiliza el gestor de arranque

SRAM: 2,5 KB (ATmega32U4)

EEPROM: 1 KB (ATmega32U4)

Velocidad de reloj: 16 MHz

Led incorporado: pin 13

Longitud: 48 mm

Ancho: 18 mm

Peso: 13 g

Microcontrolador Atmega 32U4

El Atmega32U4 es un microcontrolador de alto rendimiento basado en RISC AVR de 8 bits con de bajo consumo, 32 KB de memoria FLASH, SRAM de 2,5 KB, EEPROM de 1 KB, interfaz USB 2.0 de velocidad completa/baja velocidad, convertidor A/D de 12 canales y 10 bits e interfaz JTAG para depuración en chip.

El microcontrolador alcanza un rendimiento de hasta 16 MIPS a 16 MHz. Funciona con un voltaje entre 2.7-5.5 voltios.

Al ejecutar poderosas instrucciones en un solo ciclo de reloj, el dispositivo logra rendimientos cercanos a 1 MIPS por MHz, lo que le permite optimizar el consumo de energía en comparación con la velocidad de procesamiento.

Alimentación de la Arduino Micro

La placa Arduino Micro puede alimentarse a través de la conexión micro USB o con una fuente de alimentación externa. La placa selecciona la fuente de poder automáticamente.

La alimentación externa (no por USB) puede provenir de una fuente de alimentación de CA-CC o de una batería. Los cables de una batería o fuente de alimentación de CC se pueden conectar a los pines GND y Vin.

La placa Arduino Micro puede funcionar con un suministro externo de 6V a 20V. Sin embargo, si se suministra con menos de 7V, el pin de 5V puede suministrar menos de cinco voltios (el voltaje mínimo de funcionamiento) y la placa puede volverse inestable.

Si usa más de 12V, el regulador de voltaje puede sobrecalentarse y dañar la placa. El rango recomendado es de 7V a 12V.

Los pines de alimentación son los siguientes:

Vin: El voltaje de entrada a la placa Arduino Micro cuando está utilizando una fuente de alimentación externa (a diferencia de los 5V de la conexión USB u otra fuente de alimentación regulada). Puede suministrar voltaje a través de este pin.

5V: La fuente de alimentación regulada utilizada para alimentar el microcontrolador y otros componentes en la placa. Esto puede provenir de Vin a través de un regulador incorporado, o puede ser suministrado por USB u otro suministro regulado de 5V.

3V: Un suministro de 3,3V generado por el regulador de la placa. El consumo máximo de corriente es 50 mA.

GND: Pines de tierra.

Memoria de la Arduino Micro

El microcontrolador ATmega32U4 de la placa Arduino Micro tiene una capacidad de 32 KB (con 4 KB utilizados para el gestor de arranque). También tiene 2.5 KB de SRAM y 1 KB de EEPROM (que se puede leer y escribir con la biblioteca EEPROM).

Entradas & salidas de la Arduino Micro

Cada uno de los 20 pines digitales de la placa Arduino Micro se puede utilizar como entrada o salida, utilizando las funciones pinMode (), digitalWrite() y digitalRead().

Cada pin funciona a 5 voltios y pueden proporcionar o recibir 20mA como condición de operación recomendada.

Tienen una resistencia de pull-up interna (que está desconectada por defecto) de 20-50 k ohmios. La carga máxima es de 40 mA es el valor que no debe superarse para evitar daños permanentes al microcontrolador.

Además, algunos pines tienen funciones especializadas:

Serial: pines 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y transmitir (TX) datos en serie TTL utilizando la capacidad de serie de hardware del ATmega32U4. Hay que tener en cuenta que en la placa Arduino Micro, la clase Serial se refiere a la comunicación USB (CDC). Para TTL serial en los pines 0 y 1, use la clase Serial1.

TWI: pines 2 (SDA) y 3 (SCL). Admite la comunicación TWI (o I2C) mediante la biblioteca Wire.

Interrupciones externas: pines 0 (RX), 1 (TX), 2, 3 y 7. Estos pines pueden configurarse para activar una interrupción en nivel bajo, en flanco ascendente o descendente, o un cambio de nivel. Vea la función attachInterrupt() para más detalles.

PWM: pines 3, 5, 6, 9, 10, 11 y 13. Proporcionan salida PWM de 8 bits con la función analogWrite().

SPI: están en el encabezado ICSP. Estos pines admiten la comunicación SPI mediante la biblioteca SPI. Tenga en cuenta que los pines SPI no están conectados a ninguno de los pines de E/S digitales como están en la placa Arduino Uno R3, solo están disponibles en el conector ICSP y en los pines cercanos etiquetados MISO, MOSI y SCK.

RX_LED/SS: Este es un pin adicional en comparación con la placa Arduino Leonardo. Está conectado al RX_LED que indica la actividad de transmisión durante la comunicación USB, pero también se puede utilizar como pin de selección esclavo (SS) en la comunicación SPI.

LED: pin 13. Hay un LED incorporado conectado al pin digital 13. Cuando el pin tiene un valor ALTO, el LED está encendido, cuando el pin está en BAJO, está apagado.

Entradas analógicas: pines A0-A5, A6 - A11 (en los pines digitales 4, 6, 8, 9, 10 y 12). La placa Arduino Micro tiene un total de 12 entradas analógicas, los pines de A0 a A5 están etiquetados directamente en los pines, y los otros a los que puede acceder en código usando las constantes de A6 a A11 están compartidos respectivamente en los pines digitales 4, 6, 8, 9, 10 y 12. Todos se pueden utilizar también como E/S digitales. Cada entrada analógica proporciona 10 bits de resolución (es decir, 1024 valores diferentes). Por defecto, las entradas analógicas miden desde tierra (GND) hasta 5V, aunque es posible cambiar el extremo superior de su rango utilizando el pin AREF y la función analogReference().

Hay un par de otros pines en la placa:

AREF: Tensión de referencia para las entradas analógicas (ADC). Usado con analogReference().

RESET: Es un pin de entrada. Llevar este pin a tierra (GND) reiniciará el microcontrolador. Normalmente se usa para agregar un botón de reinicio a las placas de expansión (shields) que bloquean el que está disponible en la placa principal.

Comunicaciones en la Arduino Micro

La placa Arduino Micro tiene varias facilidades para comunicarse con un ordenador, otra placa de la familia Arduino & Genuino u otros microcontroladores.

El microcontrolador Atmega32U4 proporciona comunicación serial UART TTL (5V), que está disponible en los pines digitales 0 (RX) y 1 (TX). El ATmega32U4 también permite la comunicación en serie (CDC) a través de USB y aparece como un puerto de comunicación virtual para el sistema operativo del ordenador.

El chip también actúa como un dispositivo USB 2.0 de velocidad completa, utilizando controladores COM y USB estándar. En Windows, se requiere un archivo .inf para la correcta instalación del manejador (driver).

El entorno de desarrollo Arduino IDE incluye un monitor en serie que permite enviar datos de texto simples hacia y desde la placa. Los LED RX y TX de la placa parpadearán cuando los datos se transmitan a través de la conexión USB del ordenador (pero no para la comunicación en serie en los pines 0 y 1).

La librería SoftwareSerial permite la comunicación serial en cualquiera de los pines digitales de la placa Arduino Micro.

El microcontrolador ATmega32U4 también es compatible con la comunicación I2C (TWI) y SPI. El entorno de desarrollo Arduino IDE incluye la libreria Wire para simplificar el uso del bus I2C. Para la comunicación SPI, use la libreria SPI.

La placa Arduino Micro aparece como un teclado y un mouse genéricos para el sistema operativo del ordenador, y se puede programar para controlar estos dispositivos de entrada mediante las clases de teclado y mouse.

Programación de la Arduino Micro

La placa Arduino Micro se puede programar con el entorno de desarrollo Arduino IDE.

El ATmega32U4 en la placa Arduino Micro viene pre-programado con un gestor de arranque (bootloader) que le permite cargar un nuevo programa sin el uso de un programador hardware externo. Se comunica utilizando el protocolo original STK500.

También puede omitir el gestor de arranque y programar el microcontrolador directamente a través del conector ICSP ( In-Circuit Serial Programming - Programación serial en circuito) usando Arduino ISP o similar.

Reinicio automático e inicio del cargador de arranque en la Arduino Micro

En lugar de la presión física del botón de reinicio antes de una carga de programación, la placa Arduino Micro está diseñada de manera que permite que se reinicie mediante software. El reinicio se activa cuando el puerto serie o COM virtual (CDC) de la Arduino Micro se abre a 1200 baudios y luego se cierra.

Cuando esto sucede, el microcontrolador se reiniciará, interrumpiendo la conexión USB al ordenador (lo que significa que el puerto serial o COM virtual desaparecerán).

Una vez que el microcontrolador se reinicia, el cargador de arranque ( bootlader) se inicia y permanece activo durante unos 8 segundos. El cargador de arranque también se puede iniciar presionando el botón de reinicio en la Arduino Micro.

Tenga en cuenta que cuando la placa se enciende por primera vez, saltará directamente al programa del usuario, si está presente, en lugar de iniciar el gestor de arranque.

Debido a la forma en que se reinicia el microcontrolador en la Arduino Micro, es mejor dejar que el entorno de desarrollo Arduino IDE intente el reinicio de la placa antes de cargar el programa, especialmente si tiene la costumbre de presionar el botón de reinicio antes de cargar el programa en otras placas.

Si el software no puede reiniciar la placa, siempre puede iniciar el gestor de arranque presionando el botón de reinicio en la placa.

# data[].attributes.attachment_link.description
La Arduino Micro es una ✅mejora✅ de diseño, con más ?potencia de procesador, mas memoria y con capacidades de comunicaciones ?USB.

# data[].attributes.body
El microcontrolador que lleva la placa de Arduino, es el modelo Atmega328P de la marca Atmel. Atmega328P, pertenece a la familia de microcontroladores megaAVR.

# data[].attributes.body
Memoria EEPROM

Donde se almacenan  los datos que permanecen guardados una vez apagado el microcontrolador.

Memoria Flash

Donde se almacena de manera permanente el programa que ejecuta el microcontrolador.

Memoria SRAM

Donde se guardan los datos(enteros, flotantes o caracteres). Independiente del tipo de dato, su valor se elimina cuando se deja de alimentar al microcontrolador.

# data[].attributes.body
Son espacios de memoria existentes, dentro de la propia CPU del  microcontrolador. Algunas funciones son:

Guardan los datos para la ejecución de instrucciones.

Almacenan temporalmente los resultados de las instrucciones.

Guardan las instrucciones que se estén ejecutando en ese momento.

# data[].attributes.attachment_link.provider_name
𝗘𝗹𝗲𝗰𝘁𝗿𝗼𝗱𝗮𝗱𝗱𝘆

# data[].attributes.attachment_link.readable_text
En esta lección, aprenderemos a trabajar directamente con los registros del microcontrolador. ¿Para qué? Creo que, en primer lugar, esto es necesario para comprender el código de otra persona y rehacerlo usted mismo, porque el trabajo directo con registros en bocetos de Internet es bastante común.

Registros, bytes, bits.

Comencemos recordando dónde escribimos el código: Arduino IDE. A pesar de la gran cantidad de negativas no siempre justificadas hacia este programa, es bastante bueno. Además de un montón de herramientas integradas y soporte de "repositorio" de terceros, el IDE de Arduino nos permite programar la placa en diferentes lenguajes de programación. Esta es una especie de convención, pero de hecho resulta en tres idiomas:

C ++ , que aprendimos en las lecciones del sitio;

Ensamblador (inserciones de ensamblador): trabajo directo con un microcontrolador, un lenguaje muy complejo;

El "idioma" de los registros del microcontrolador. Llamémoslo condicionalmente un lenguaje separado, aunque no lo es.

¿Qué es un registro? Aquí todo es bastante simple: se trata de bloques de RAM ultrarrápidos con un volumen de 1 byte ubicados junto al núcleo del Mc y los periféricos. En el lado del programa, estas son variables globales ordinarias que se pueden leer y cambiar. Los registros del microcontrolador almacenan "configuraciones" para sus diversos periféricos: temporizadores-contadores, puertos con pines, ADC, bus UART, I2C, SPI y otro hardware integrado en el MC. Al cambiar el registro, le damos un comando casi directo al microcontrolador sobre qué hacer y cómo. Escribir en el registro toma 1 reloj, es decir, 0.0625 microsegundos ( a una frecuencia de reloj de 16 MHz ) - es MUY rápido. Los nombres de registro son fijos, se puede encontrar una lista completa con una descripción detallada en la hoja de datos del microcontrolador ( hoja de datos oficial en ATmega328 - Arduino Nano / UNO / Mini). Trabajar con registros es muy difícil si no los ha aprendido todos de memoria, porque sus nombres suelen ser abreviaturas ilegibles. Las llamadas funciones "Arduino" realmente funcionan con registros, dejándonos una función adecuada, comprensible y legible. No tiene nada de sobrenatural.

¿Por qué trabajar con registros directamente? Hay varios grandes beneficios:

Velocidad de operación: la lectura / escritura de un registro se realiza lo más rápido posible, lo que le permite acelerar el trabajo con el MC (por ejemplo, tirar de los pines manualmente en lugar de digitalWrite ()). La velocidad máxima de trabajo con los periféricos del Mc no siempre es necesaria, por lo que si no necesita ahorrar unos microsegundos, ni siquiera tiene que meterse con los registros.

Tamaño de la memoria: el trabajo directo con registros le permite trabajar con periféricos del Mc de la manera más compacta posible, leyendo y escribiendo solo los bits necesarios, por lo tanto, el código específico escrito para sus tareas ocupará menos espacio que las funciones y bibliotecas universales listas para usar de otra persona (por ejemplo, el mismo digitalWrite () o trabajar con Serial). Cuando trabajas con Arduino, casi nunca puedes preocuparte por esto, pero si haces un proyecto en ATTiny, tendrás que comprimir el código a un byte.

Flexibilidad de personalización: trabajar con el microcontrolador directamente usando registros le permite personalizar de manera muy flexible los periféricos para sus tareas. ¡El hecho es que todas las bibliotecas Arduino existentes cubren un poco más de la mitad de las capacidades del microcontrolador! Una gran cantidad de configuraciones y trucos útiles no se describen en ninguna parte excepto en la hoja de datos, y para usarlos, debe poder leer esta hoja de datos y trabajar con registros. Lea sobre esto a continuación.

Entonces, desde el punto de vista del código, el registro es una variable que podemos leer y escribir. En los microcontroladores ATmega / ATtiny, los registros son de 8 bits, es decir, el registro es una variable del tipo byte, cambiandolo es posible configurar el funcionamiento del microcontrolador a un nivel bajo. Hasta donde sabemos, un byte es un número de 0 a 255, por lo que cada registro tiene 255 configuraciones. No, la lógica aquí es completamente diferente: un byte tiene 8 bits, tomando valores 0 y 1, es decir, un registro almacena 8 configuraciones que se pueden activar / desactivar. Así es exactamente como funciona la configuración del microcontrolador a bajo nivel. Tomemos como ejemplo uno de los registros del temporizador 1, llamadoTCCR1B... Imagen de la hoja de datos en ATmega328p:

Registro TCCR1B, corresponde a un byte, consta de 8 bits. Casi todos tienen un nombre (excepto el quinto, en este Mc no está usado). Lo que hace cada bit y registro se describe de la manera más detallada en la hoja de datos del microcontrolador. Los nombres de todos los bits y registros se establecen (ocupados, reservados) en el compilador, es decir, no se pueden crear variables con los mismos nombres. Tampoco puede cambiar los valores de los bits, son constantes:

int WGM12; // resultará en un error
CS11 = 5;  // resultará en un error

¡Pero puedes leer el valor de un bit por su nombre! Además, el valor será igual a su número en el registro, contando desde la derecha. CS11 es igual a 1, WGM13 es igual a 4, ICNC1 es el 7 (consulte la tabla anterior). Creo que todo está claro aquí: hay un registro (byte) que tiene un nombre único y consta de 8 bits, cada bit también tiene un nombre único por el cual se puede obtener el valor de este bit en el byte de su registro. Queda por descubrir cómo usarlo todo.

Leer y escribir registros.

Hay varias formas de establecer bits en registros. Los consideraremos todos para que cuando te encuentres con uno de ellos, sepas qué es y cómo funciona esta línea de código. Absolutamente todo trabajo con registros consiste en poner los bits necesarios en el byte deseado (en el registro) al estado 0 o 1. Recomiendo leer la lección sobre operaciones de bits, en la que se analiza en detalle todo lo relacionado con la manipulación de bits.

Volvamos al registro del temporizador que mostré arriba e intentemos configurarlo. La primera forma es establecer explícitamente todo el byte a la vez, con todos los unos y ceros. Puedes hacerlo así:

Por lo tanto, activamos y desactivamos los bits necesarios a la vez, de una sola vez. Como recordará de la lección sobre tipos de datos y números, al microcontrolador no le importa en qué sistema numérico trabaje, es decir 0b01010101 en nuestro sistema binario, en decimal será 85, y en hexadecimal - 0x55. Y estas tres opciones son absolutamente iguales en cuanto al resultado:

TCCR1B = 0b01010101 ;
TCCR1B = 85;
TCCR1B = 0x55 ;

Solo necesita mirar el primero y comprender de inmediato qué es y dónde. No se puede decir lo mismo de los otros dos. Muy a menudo, en los bocetos de otras personas se encuentra esta notación y no es muy cómodo.

Con mucha más frecuencia es necesario cambiar " deliberadamente " un bit en un byte, y aquí las funciones lógicas (bit) y las macros vienen al rescate. Considere todas las opciones, en todas ellas BYTE es un registro de bytes, y BIT es el número de bit de la derecha. Es decir, BIT es un dígito del 0 al 7, o el nombre de un ese bit de la hoja de datos.

Lo que quiero decir sobre las opciones enumeradas: todas son esencialmente iguales, es decir, la primera, simplemente envuelta en otras funciones y macros. El tiempo de ejecución de todas las opciones es el mismo, ya que Las funciones macro no realizan acciones innecesarias, sino que llevan todos los métodos al primero, con un cambio y | = y & =... Puede encontrar todos estos métodos en bocetos de Internet, esto es un hecho. Personalmente, me gusta más el bitSet y bitClear de Arduino , porque tienen un nombre legible y se encuentran en la biblioteca de antemano. Sobre sbi () y cbi () - luego, para usarlos, debe crear macros al principio del documento:

#define cbi (sfr, bit) (_SFR_BYTE (sfr) & = ~ _BV (bit))
#define sbi (sfr, bit) (_SFR_BYTE (sfr) | = _BV (bit))

Y después de eso puedes usar sbi () y cbi ().

Veamos un ejemplo en el que simplemente manipulamos TCCR1B por diferentes caminos:

// para usar sbi y cbi
#define cbi (sfr, bit) (_SFR_BYTE (sfr) & = ~ _BV (bit))
#define sbi (sfr, bit) (_SFR_BYTE (sfr) | = _BV (bit))
void setup () {
  TCCR1B = 0;            // establecer el registro en cero
  bitSet ( TCCR1B, CS11 ) ;  // activó el bit # 1
  cbi ( TCCR1B, CS11 ) ;     // desactivó el bit # 1
  TCCR1B | = _BV ( 4 ) ;      // activó el bit # 4
  TCCR1B | = ( 1 << WGM12 ) ; // activó el bit # 3
  TCCR1B & = ~ _BV ( WGM13 ) ; // desactivó el bit # 4
  bitClear ( TCCR1B, 3 ) ;   // desactivó el bit # 3
}

También puede agregar una opción donde puede establecer varios bits en una línea:

void setup () {
  TCCR1B = 0; // establecer el registro en cero
  // establecer bit 1, 3 y 4 (WGM13)
  TCCR1B | = _BV ( 1 ) | _BV ( 3 ) | _BV ( WGM13 ) ;
}

Creo que todo está claro aquí, ahora intentemos "apuntar"y leer un bit de un registro:

Los dos métodos discutidos devuelven 0 o 1 según el estado del bit. Ejemplo:

void setup () {
  TCCR1B = 0;            // poner el registro en cero
  bitSet ( TCCR1B, CS12 ) ;  // activó el bit # 2
  Serial.begin(9600);    // abre el puerto
  Serial.println(bitRead(TCCR1B, 2));// consiguió 1
}

Para obtener aún más ejemplos de trabajo con bits, consulte el tutorial anterior sobre operaciones con bits.

Registros de 16 bits.

Los Arduino (AVR) también tienen registros duales de 16 bits, consisten en dos de 8 bits, por ejemplo, un ADC es un "registro dual". ADC comprende ADCH y ADCL o registro de temporizador ICR1 comprende ICR1H y ICR1L. Nuestro ADC es de 10 bits, pero los registros son de 8 bits, por lo que parte (8 bits) se almacena en un registro (ADCL), y el resto (2 bits) - en otro (ADCH). Vea cómo se ve en la tabla:

La pregunta es: ¿cómo podemos leer o cambiar este mismo número de 10 bits si está dividido en dos registros diferentes? Es muy simple: trabajar con tales registros dobles está integrado en el compilador avr-gcc y puede trabajar con ellos directamente como con una variable regular, por ejemplo:

int val = ADC;  // lee el valor
ICR1 = 1234; // escribe el valor

Por alguna razón, esta notación rara vez se usa, quizás por compatibilidad con otros compiladores. Muy a menudo, se encontrará con esta opción, en la que los valores están "pegados" a través de rotación:

int val = ADCL + ( ADCH << 8 ) ;
// posible opción ADCL | (ADCH << 8), vea la lección sobre operaciones de bits

Necesita leer desde el registro inferior. Tan pronto como leemos el registro más bajo (primero), desde el MC se bloquea completamente el acceso a todos los registros, hasta que lea el superior. Si lee primero el más significativo, es posible que se pierda el valor del menos significativo.

Problema inverso: nuevamente hay un registro imaginario de 16 bits (que consta de dos de 8 bits), en el que debemos escribir valor. Por ejemplo doble registro ICR1H y ICR1L, aquí está la tabla:

Los registros de arduino, registro ICR1

El microcontrolador sólo puede funcionar con un byte, pero ¿cómo escribimos un número de dos bytes?. Así: divida el número en dos bytes (usando funciones de Arduino highByte () y lowByte ()) y escriba estos bytes en los registros correspondientes. Ejemplo:

uint16_t val = 1500;   // solo un número de tipo int
ICR1H = highByte ( val ) ; // escribe byte alto
ICR1L = lowByte ( val ) ;  // escribe el byte menos significativo
// leer los bytes de nuevo y pegarlos en int
byte val_1 = ICR1L;
byte val_2 = ICR1H;
uint16_t valor = val_1 + ( val_2 << 8 ) ;

Necesita escribir primero el byte alto. Tan pronto como grabemos el byte menos significativo (el último), el MC "enclava" ambos registros en la memoria, respectivamente, si primero escribe el inferior, el superior será 0, y la escritura posterior del anterior será ignorado.

# data[].attributes.attachment_link.title
29- Los registros de Arduino - 𝗘𝗹𝗲𝗰𝘁𝗿𝗼𝗱𝗮𝗱𝗱𝘆

# data[].attributes.attachment_link.description
Vamos a trabajar con los registros del Arduino directamente. ¿Para qué? Creo que, en primer lugar, esto es necesario para comprender el código de otra persona y rehacerlo usted mismo, porque el trabajo directo con registros en bocetos de Internet es bastante común.

# data[].attributes.body
SPI

Permite controlar a cortas distancias, cualquier dispositivo electrónico digital que acepte un flujo de bits regulado por un reloj.

I^2 C

Utiliza dos líneas para transmitir la información. Una sirve para transferir los datos y otra sirve para enviar la señal del reloj.

# data[].attributes.attachment_link.title
Arduino: El Bootloader o Gestor de Arranque

# data[].attributes.attachment_link.title
Características principales de Arduino UNO 🤩

# data[].attributes.attachment_link.title
Alimentar el Arduino: La guía definitiva - Geek Factory

# data[].attributes.attachment_link.description
Aprende las posibles formas de alimentar el arduino en este tutorial. Evita los errores comunes que pueden llevar a la destrucción de tu placa arduino.

# data[].attributes.attachment_link.readable_text
En entradas anteriores hemos visto cómo emplear las entradas digitales de nuestro Arduino. También hemos usado estas entradas para leer el estado de un pulsador. En esta entrada vamos a ver las entradas analógicas, su funcionamiento y características.

Las entradas analógicas funcionan de una forma similar a las entradas digitales, por lo que en la práctica el montaje y código final son muy similares. Por tanto, es de aplicación la mayoría de lo que vimos en esta entrada. Sin embargo en ciertos aspectos son radicalmente distintos, por lo que para entender correctamente su uso y funcionalidad es necesario veamos un mínimo de teoría.

¿Qué es una entrada analógica?

Una señal analógica es una magnitud que puede tomar cualquier valor dentro de un intervalo -Vcc y + Vcc. Por ejemplo, una señal analógica de tensión entre 0V y 5V podría valer 2,72V, o cualquier otro valor con cualquier número de decimales. Por contra, recordemos que una señal digital de tensión teórica únicamente podía registrar dos valores (en el ejemplo, 0V o 5V).

Por norma general en los autómatas las entradas analógicas son más escasas, más lentas y más caras que las entradas digitales. En el caso de Arduino uno disponemos de un número variable de entradas analógicas, que en el caso de Arduino Uno y Mini Pro son 6, y en el Arduino Mega son 16. Este es un número más que respetable de entradas analógicas, que rivaliza o supera a autómatas tradicionales de coste muy superior.

Como vimos al explicar las entradas digitales, una entrada digital supone un proceso de transformación de una señal en un valor digital, atribuyendo un valor HIGH a las medidas que superen un valor umbral, y LOW a lo que quedan por debajo. Por el contrario, una entrada analógica proporciona una medición codificada en forma de un valor digital con un número N de bits.

Es importante entender que en el mundo real cualquier señal de tensión es siempre analógica. Un valor digital es un concepto, una abstracción. Sin embargo conviene señalar que la medición que proporciona una entrada analógica también es un valor digital, por lo que igualmente es una abstracción. Esto nos lleva al concepto de precisión de la medición.

Precisión de la medición

Para entender la precisión de una entrada analógica es necesario entender cómo funciona un conversor analógico digital (ADC), que es su componente fundamental. Un ADC es un dispositivo que convierte una medición analógica en una medición digital codificada con un número N de bits.

Existen muchas formas de construir un ADC, pero lo importante es entender que en realidad no medimos el valor analógico con todos sus decimales, sino que lo "clasificamos" dentro de 2^N niveles, que definen 2^N-1 intervalos. El ancho de este intervalo medido en mV es la precisión de la señal. Cuanto mayor sea el número de bits, mayor será el número de intervalos, menor será el ancho del intervalo, y por tanto mejor la precisión de la medición.

En el caso de Arduino Uno, Mini Pro, y Mega, las entradas analógicas disponen de 10 bits de resolución, lo que proporciona 1024 niveles digitales, lo que a 5V supone una precisión de la medición de +-2,44mV. Arduino Due tiene una resolución de 12bits, 4096 niveles digitales, lo que supone una precisión de 0,61 mV.

Precisión relativa

Hasta ahora hemos supuesto un autómata alimentado entre 0V y 5V, que mide una señal analógica de tensión entre 0V a 5V. En este caso, con un ADC de 10 bit tenemos una precisión de 4,88mV, lo que supone una precisión relativa respecto a la señal de entrada de 0,1% (1/1024).

Sin embargo, supongamos que medimos una señal que varía entre 0V y 1V. En este caso, con el mismo ADC de 10 bit tendríamos la misma precisión absoluta de 4,88mV, pero una menor precisión relativa respecto a la señal, que caería hasta 0,5%.

Es decir, si realizamos una medición a una señal que varía en un límite inferior a Vcc estamos perdiendo precisión relativa. Esto es la consecuencia de no aprovechar todo el rango de la medición, por lo que en realidad el ADC se comporta como si tuviera un número inferior de bits.

Referencia de tensión analógica (aref)

Para resolver esta situación Arduino permite cambiar la tensión tomada como referencia por el conversor analógico digital. El valor de la referencia se cambia con la función AnalogRef, y los valores posibles son:

DEFAULT: Valor por defecto, correspondiente con Vcc (5V o 3.3V, según modelos)

INTERNAL: Corresponde a 1.1V (en Atmega 168 y 328)

EXTERNAL: Voltaje aplicado de forma externa en el pin Vref (siempre entre 0 y Vcc

INTERNAL1V1 y INTERNAL2V56, correspondientes a 1.1V y 2.56V (sólo en Mega)

En el caso de usar la referencia de tensión externa (EXTERNAL), si sabemos con total seguridad que una señal no va a superar de un cierto valor de tensión, por ejemplo 0.7V, podemos proporcionar este valor como referencia a través del Pin Aref. La medición se realizará tomando esta tensión como referencia en lugar de Vcc, por lo que recuperamos toda la precisión relativa.

Conexión de entradas analógicas en Arduino

Supongamos que dispongamos un sensor analógico que proporciona una señal analógica entre 0V a 5V. El esquema de conexión es similar al que empleamos para realizar la lectura digital.

Código en Arduino

El código para realizar la lectura es realmente sencillo, y similar al que vimos para las entradas digitales. Simplemente realizamos la lectura mediante AnalogRead() y almacenamos el valor devuelto.

El valor devuelto por la función AnalogRead() se codifica como un número entero 0 a 1023. En caso de querer convertir este valor en un valor de tensión podemos usar la siguiente variación:

Sin embargo tener en cuenta que las operaciones en coma flotante (con decimales) son mucho más lentas que con enteros por lo que intentar evitar tener que realizar esta conversión y trabajar siempre que sea posible con números enteros.

Frecuencia de muestreo

Con el código empleado la frecuencia de muestreo es aproximadamente 9600 Hz, es decir, unos 100 micro segundos para la medición. En comparación, la función digitalRead tiene una frecuencia de 15000Hz, unos 66 micro segundos por medición, levemente más rápido.

Sin embargo, mediante otros códigos la lectura analógica puede aumentarse hasta aproximádamente 1,5 Mhz, o 660 nano segundos por entrada. Por contra, las entradas digitales pueden acelerarse hasta casi 15 Mhz, 66 nano segundos, leyendo todas las entradas de forma simultánea. Por lo tanto, vemos que realmente las entradas digitales pueden ser mucho más rápidas que las analógicas.

Lectura de valores mayores de 5V

En caso de necesitar leer una entrada de nivel de tensión superior, por ejemplo de 12V, debemos realizar una adaptación de tensión. La forma mejor de realizar la adaptación es emplear un simple divisor de tensión.

Con esta configuración el pin digital de Arduino recibirá una tensión que varía entre 0 a 3,84V por lo que, como hemos explicado, estaríamos perdiendo precisión relativa. Una opción sería ajustar las resistencias para que los límites estén lo más cercanos posible a 0 y 5V, o usar otro divisor de tensión para alimentar el pin Aref.

Los valores de las resistencias a emplear dependen del voltaje que queremos leer, y de la impedancia del sensor. En general, deben cumplir las siguientes condiciones:

Deben convertir la señal en un rango inferior pero similar a la tensión de alimentación.

Deben ser muy superiores a la impedancia equivalente del dispositivo a medir.

Deben despreciables respecto a la impedancia de la entrada Arduino.

Deben limitar la corriente que circula por ellas para minimizar pérdidas.

Deben ser capaces de disipar la potencia que van a soportar.

Podéis ayudaros de la calculadora de divisores de tensión para calcular valores de resistencia que cumplan estos requisitos.

En la siguiente entrada veremos cómo emplear las entradas analógicas para leer el estado de un potenciómetro o el valor de una resistencia variable, algo habitual a la hora de leer sensores cuya lectura se realiza a través de la medición de su resistencia.

Descarga el código

Todo el código de esta entrada está disponible para su descarga en Github.

# data[].attributes.attachment_link.description
En esta entrada explicamos qué son y cómo usar las entradas analógicas en Arduino, un componente fundamental en todo proyecto de electrónica

# data[].attributes.attachment_link.description
En este tutorial aprendemos a usar las salidas PWM de Arduino para emular una salida analógica

# data[].attributes.body
Las tres placas Arduino tienen su propio nivel de potencia de procesamiento, así que hablemos de su frecuencia/velocidad de reloj. La frecuencia/velocidad de reloj de estas placas simplemente se refieren a la rapidez con la que pueden ejecutar comandos.

# data[].attributes.attachment_link.readable_text
1. Restablecer Arduino usando el botón Restablecer

2. Restablecer Arduino usando la biblioteca Softwarereset

3. Restablecer Arduino usando la biblioteca Adafruit SleepyDog

Este tutorial discutirá tres métodos para restablecer un Arduino. El primer método es el botón de reinicio presente en el Arduino. El segundo método es la biblioteca Softwarereset y el tercero es la biblioteca Adafruit SleepyDog.

Restablecer Arduino usando el botón Restablecer

Si está utilizando Linux, hay un error que impide que su IDE de Arduino se comunique con la placa Arduino. Como resultado, no puede cargar un código en su Arduino y dará un error. En este caso, puede utilizar este método para restablecer su Arduino.

En primer lugar, asegúrese de conectar su Arduino directamente a su computadora sin un concentrador. El uso de un concentrador a veces le dará errores. Ahora apague el Arduino, presione y mantenga presionado el botón de reinicio mientras lo enciende nuevamente. Esto restablecerá su Arduino y podrá cargar fácilmente otro código sin errores.

Restablecer Arduino usando la biblioteca Softwarereset

Si desea restablecer su Arduino usando un sketch, puede restablecerlo fácilmente usando la biblioteca Softwarereset. Esta biblioteca es compatible con la arquitectura AVR ​​para que pueda usarla con placas Arduino Uno, Mega, Yun, Nano y Leonardo. Para usar esta biblioteca, debe usar el Administrador de bibliotecas disponible en el IDE de Arduino para instalarlo.

Esta biblioteca tiene dos métodos para restablecer el Arduino. Uno es el método estándar que reiniciará Arduino usando el temporizador watchdog. El otro método es el método simple que simplemente reiniciará el programa.

Tenga en cuenta que no se ejecutará ninguna línea de código escrita debajo del código de reinicio. Así que asegúrese de usar restablecer después de haber completado su código. Para obtener más información, lea la biblioteca Documentación.

Restablecer Arduino usando la biblioteca Adafruit SleepyDog

La biblioteca anterior funciona solo para cinco placas Arduino. Si su Arduino no es uno de ellos, entonces puede usar esta biblioteca porque es compatible con casi todas las placas Arduino. Utilice este enlace para comprobar si su Arduino es compatible con esta biblioteca.

En el código anterior, Arduino se reiniciará en 4 segundos. Puede restablecer el perro guardián utilizando el método de restablecimiento. Para obtener más información, lea la biblioteca documentación.

# data[].attributes.attachment_link.description
Uno puede reiniciar el Arduino usando el botón de reinicio, la biblioteca de reinicio de software y la biblioteca Adafruit SleepyDog.

# data[].attributes.attachment_link.title
Cuántos tipos de placas Arduino existen? Cuáles son sus características?

# data[].attributes.attachment_link.readable_text
El microcontrolador ATmega16U2 pertenece a la compañía Microchip, utiliza una arquitectura AVR de 32 registros de 8 bits cada uno, este microcontrolador es de bajo consumo y cuenta con 16 KB de memoria flash, 512 bytes de memoria EEPROM y 512 bytes de memoria SRAM, también dispone de un oscilador interno para la sincronización de instrucciones, 22 pines de entradas y salidas, una interface UART, 2 de SPI y 5 pines PWM.

En la placa electronica arduino uno tenemos un chip ATmega16U2 programado con el firmware necesario para la transmisión de información con el protocolo USB, de esta manera cuando conectamos a través del puerto USB la placa arduino a nuestro ordenador el encargado de comunicarse situandose como intermediario entre el ordenador y el ATmega328P es el chip ATmega16U2.

# data[].attributes.attachment_link.description
El microcontrolador ATmega16U2 pertenece a la compañía Microchip, utiliza una arquitectura AVR de 32 registros de 8 bits cada uno, este microcontrolador es de bajo consumo y cuenta con 16 KB de memoria flash, 512 bytes de memoria EEPROM y 512 bytes de memoria SRAM, también dispone de un oscilador interno para la sincronización de [...]