Tengo un proyecto en el que quiero trabajar, ya sea en Uno o Mega (o incluso en Due) y sería bueno si no necesitara dos versiones del software. Por ejemplo, en un Mega, para usar SoftwareSerial, debe usar pines diferentes a los de un Uno. Vea los documentos en Serie de software . De todos modos, sería bueno detectar que estoy usando un Uno para poder usar los pines 4 y 5 para TX / RX y si estoy usando un Mega, el software detectará y solo usará los pines 10 y 11 (y de Por supuesto, tendré que conectarlo de manera diferente, pero al menos el software será el mismo).

Tiempo de ejecución

Que yo sepa, no puede detectar el tipo de placa, pero puede leer la identificación del dispositivo ATmega. Compruebe esta pregunta cómo se puede hacer: ¿Se puede leer la firma de un dispositivo ATmega o ATtiny mientras se ejecuta? Sin embargo, tenga en cuenta que al usar este método, varias asignaciones de registro cambiarán, no solo el pinout. Por lo tanto, su código puede ser significativamente más complejo. La ventaja es que si logra evitar todas las asignaciones de registros cambiantes y otras dependencias de hardware, puede usar un solo archivo .hex para programar sus dispositivos directamente avrdude.

Tiempo de compilación

Otra forma de averiguar el tipo de placa / controlador es en tiempo de compilación. Básicamente, compila partes del código o establece macros dependiendo del tipo de dispositivo configurado en el IDE de Arduino. Consulte este fragmento de código para ver un ejemplo:

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define DEBUG_CAPTURE_SIZE 7168
#define CAPTURE_SIZE 7168
#elif defined(__AVR_ATmega328P__)
#define DEBUG_CAPTURE_SIZE 1024
#define CAPTURE_SIZE 1024
#else
#define DEBUG_CAPTURE_SIZE 532
#define CAPTURE_SIZE 532
#endif

El fragmento de código se copió descaradamente de https://github.com/gillham/logic_analyzer/wiki. Consulte ese código para ver algunos trucos más específicos del dispositivo.

Dependiendo del sistema operativo de su host, los tipos de controladores compatibles se pueden encontrar en el siguiente archivo:

• Linux: /usr/lib/avr/include/avr/io.h
• Ventanas: ...\Arduino\hardware\tools\avr\avr\include\avr\io.h

El uso del preprocesador C (por el cual se maneja el código anterior) probablemente esté fuera del alcance de este sitio. http://stackoverflow.com sería el mejor lugar para preguntas detalladas.

Si está en Linux, puede encontrar fácilmente todos los tipos de controladores compatibles escribiendo:

grep 'defined (__AVR' /usr/lib/avr/include/avr/io.h | sed 's/^[^(]*(\([^)]*\))/\1/'

Como se indica en la especificación de hardware de Arduino , el IDE de Arduino ahora define una macro para cada placa, como se define en la build.boardpropiedad boards.txt . Ese valor se agrega aARDUINO_ , por ejemplo, las macros para los tableros que le interesan son:

• Uno: ARDUINO_AVR_UNO
• Mega 2560: ARDUINO_AVR_MEGA2560
• Debido: ARDUINO_SAM_DUE

Ejemplo de cómo puede usar estas macros en su código:

#if defined(ARDUINO_AVR_UNO)
//Uno specific code
#elif defined(ARDUINO_AVR_MEGA2560)
//Mega 2560 specific code
#elif defined(ARDUINO_SAM_DUE)
//Due specific code
#else
#error Unsupported hardware
#endif

Una manera fácil de rastrear tableros es usar una biblioteca como ArduinoManager. Con esto, puede obtener fácilmente el nombre y las características de la placa https://github.com/backupbrain/ArduinoBoardManager

Utiliza la técnica descrita anteriormente para revelar mucha información sobre casi todas las placas Arduino, por lo que es ideal para hacer proyectos que podrían implementarse en entornos muy diferentes.

Simplemente descargue e incluya en su proyecto Arduino.

#include "ArduinoBoardManager.h"

ArduinoBoardManager arduino = ArduinoBoardManager(); // required if you want to know the board name and specific features

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

  Serial.print("Board is compatible with Arduino ");
  Serial.println(arduino.BOARD_NAME);

  Serial.println("Speed/SRAM/Flash: ");
  Serial.print(ArduinoBoardManager::MAX_MHZ);
  Serial.println(ArduinoBoardManager::SRAM_SIZE);
  Serial.println(ArduinoBoardManager::FLASH_SIZE);

  // Board features (multiple serial ports on Mega, for example)
  if (arduino.featureExists(ArduinoBoardManager::FEATURE_MULTIPLE_SERIAL)) {
    Serial.println("Your board supports multiple serial connections");
  }

}

void loop() {
}

La salida resultante en Arduino Uno es:

Board is compatible with Arduino UNO

Speed/SRAM/Flash: 
16000000
2048
33554432

El proceso para hacer esta biblioteca (incluido el código de ejemplo) para determinar un modelo y versión de placa Arduino se describe en detalle en mi blog.

Para todas las placas compatibles con Arduio Due

#if defined (__arm__) && defined (__SAM3X8E__) // Arduino Due compatible
// your Arduino Due compatible code here
#endif

(Ver el archivo sam3.h para obtener más información).

Si solo desea apuntar al Arduino Due (sin incluir placas compatibles), puede usar

#if defined (_VARIANT_ARDUINO_DUE_X_)
// your Arduino Due code here
#endif

(Esto se define en el Arduino Due's archivo variant.h de ).

Crédito a Adam F /programming//a/21058963/354144

Dado que Arduino Due es una familia de procesadores (ARM) diferente a la de los AVR, no podrá utilizar el mismo ejecutable para los tres. Pero puedes tener lo mismo código fuente (suponiendo que la sintaxis para leer un puerto sea la misma en las partes AVR y ARM), y solo dos ejecutables (ya que el mismo se ejecutará en Uno y Mega sin recompilar).

Puede determinar el tipo de placa en tiempo de ejecución sin tener que volver a compilar, eligiendo dos pines digitales que su programa aún no esté utilizando en ninguna de las placas y vincularlos alto o bajo como ID de placa. Por ejemplo, si los pines que elige son PC1 y PC3:

 PC1   PC3   Board ID
  0     0      Uno
  0     1      Mega
  1     0      Due
  1     1      spare

Luego, simplemente lea el puerto al encender y configure una variable en su programa.

Otro esquema que se puede usar, que ata solo un pin, es usar un pin de entrada analógica y usar un divisor de resistencia, eligiendo resistencias de manera que obtenga diferentes voltajes en incrementos de 0.25V. He usado esa técnica para especificar no solo un tipo de placa, sino también una revisión de placa para la misma placa (que en cierto sentido es un nuevo tipo de placa).