Tiempo de ejecución

Que yo sepa, no puede detectar el tipo de placa, pero puede leer el ID de dispositivo ATmega. Compruebe esta pregunta cómo se puede hacer: ¿Se puede leer la firma de un dispositivo ATmega o ATtiny durante la ejecución? aunque al usar este método, se pueden cambiar varias asignaciones de registro, no solo el pinout. Por lo tanto, su código puede ser significativamente más complejo. La ventaja es que si puede solucionar todos los cambios en las asignaciones de registro y otras dependencias de hardware, puede usar un solo archivo .hex para programar sus dispositivos directamente desde 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 configura macros según el tipo de dispositivo configurado en el IDE de Arduino. Revisa este código 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ó sin vergüenza desde enlace Comprueba ese código para ver algunos trucos específicos del dispositivo.

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

• Linux: /usr/lib/avr/include/avr/io.h
• Windows: ...\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. enlace 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/^[^(]*(\([^)]*\))//'

Como se indica en especificación de hardware Arduino , el IDE de Arduino ahora define una macro para cada placa, como se define en la propiedad boards.txt build.board . Ese valor se agrega a ARDUINO_ , por lo que, por ejemplo, las macros para los tableros en los que está interesado son:

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

Ejemplo de cómo puedes usar estas macros en tu 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 forma fácil de hacer sniffing de tablas es usar una biblioteca como ArduinoManager. Con esto, puede obtener muy fácilmente el nombre de la placa y las características enlace

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

Solo 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 determina un Arduino El modelo y la versión de la placa se describen 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

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

Si solo quieres apuntar a Arduino Due (sin incluir tableros compatibles), puedes usar

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

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

Crédito a Adam F enlace

Dado que Arduino Due es una familia de procesadores (ARM) diferente a la del AVR, no podrá usar el mismo ejecutable para los tres. Pero puede tener el mismo código fuente (asumiendo que la sintaxis para leer un puerto es la misma en ambas partes del AVR y ARM), y solo dos ejecutables (ya que el mismo se ejecutará en ambos y Mega sin recompilar).

Puede determinar el tipo de placa en el tiempo de ejecución sin tener que volver a compilar, eligiendo dos pines digitales que su programa no esté utilizando en ninguna de las placas y ajústelos a un nivel alto o bajo como una 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 en el encendido y establezca una variable en su programa.

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