¿Cómo puedo detectar qué placa de arduino (o qué controlador) en el software?

Question

Tengo un proyecto en el que quiero trabajar tanto en un Uno como en un Mega (o incluso en un Due) y estaría bien no necesitar dos versiones del software. Por ejemplo, en un Mega, para usar el SoftwareSerial, hay que usar pines diferentes a los de un Uno. Ver los documentos de Software Serial . De todos modos, estaría bien detectar que estoy usando un Uno para poder usar sólo los pines 4 y 5 para TX/RX y si estoy usando un Mega el software lo detectará y sólo usará los pines 10 y 11 (y por supuesto, tendré que cablearlo de forma diferente pero al menos el software será el mismo).

Answer 1

Tiempo de ejecución

Que yo sepa no se puede detectar el tipo de placa, pero sí se puede leer el ID del dispositivo ATmega. Comprueba en esta pregunta cómo se puede hacer: ¿Se puede leer la firma de un dispositivo ATmega o ATtiny mientras se ejecuta? Sin embargo, ten en cuenta que al usar este método, varias asignaciones de registros cambiarán, no sólo el pinout. Por lo tanto, su código puede volverse significativamente más complejo. La ventaja es que si Si consigues evitar todos los cambios en la asignación de registros y otras dependencias del hardware, puedes utilizar un único archivo .hex para programar tus 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 se compilan partes del código o se establecen macros dependiendo del tipo de dispositivo configurado en el IDE de Arduino. Mira 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 fue copiado descaradamente de https://github.com/gillham/logic_analyzer/wiki Revisa ese código para ver algún truco más específico del dispositivo.

Dependiendo del sistema operativo de su host, los tipos de controladores soportados 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 (mediante el cual se maneja el código anterior) está probablemente fuera del alcance de este sitio. http://stackoverflow.com sería el mejor lugar para las preguntas detalladas.

Si estás en Linux puedes encontrar fácilmente todos los tipos de controladores soportados escribiendo:

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

Answer 2

Como se indica en el Especificación del hardware de Arduino El IDE de Arduino define ahora una macro para cada placa, tal y como se define en el archivo boards.txt build.board propiedad. Ese valor se añade a ARDUINO_ Así, por ejemplo, las macros de las tablas que te interesan son

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

Ejemplo de cómo puede utilizar 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

Answer 3

Una manera fácil de hacer el sniffing de la placa es utilizar una biblioteca como ArduinoManager. Con esto puedes obtener muy fácilmente el nombre de la placa y sus características 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 genial para hacer proyectos que puedan ser desplegados en muchos entornos diferentes.

Sólo tienes que descargarlo e incluirlo en tu 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 el Arduino Uno es:

Board is compatible with Arduino UNO

Speed/SRAM/Flash: 
16000000
2048
33554432

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

Answer 4

Para todas las placas compatibles con Arduio Due

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

(Véase el archivo sam3.h para más información).

Si sólo quieres apuntar al Arduino Due (dejando fuera las placas compatibles), puedes usar

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

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

Crédito a Adam F https://stackoverflow.com/a/21058963/354144

Answer 5

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

Puedes determinar el tipo de placa en tiempo de ejecución sin tener que recompilar, eligiendo dos pines digitales que no estén siendo usados por tu programa en ninguna de las placas y atándolos a alto o bajo como un ID de placa. Por ejemplo, si los pines que eliges son PC1 y PC3:

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

Entonces simplemente lee el puerto al encenderlo y establece una variable en tu programa.

Otro esquema que se puede utilizar, que ata sólo un pin, es utilizar un pin de entrada analógica y utilizar un divisor de resistencias, eligiendo resistencias de tal manera que se obtienen diferentes voltajes en, digamos, incrementos de 0,25V. He utilizado esta técnica para especificar no sólo un tipo de placa, sino también una revisión de la misma placa (que en cierto sentido es un nuevo tipo de placa).