Eu tenho um projeto que eu quero trabalhar em um Uno ou um Mega (ou mesmo um Due) e seria bom se eu não precisasse de duas versões do software. Por exemplo, em um Mega, para usar o SoftwareSerial, você precisa usar pinos diferentes dos de um Uno. Veja os documentos em Software Serial . De qualquer forma, seria bom detectar que estou usando um Uno, para que eu possa usar os pinos 4 e 5 para TX / RX e se eu estiver usando um Mega, o software detectará e usará os pinos 10 e 11 (e de Claro, terei que conectá-lo de maneira diferente, mas pelo menos o software será o mesmo).

Tempo de execução

Que eu saiba, você não pode detectar o tipo de placa, mas pode ler o ID do dispositivo ATmega. Verifique esta pergunta como isso pode ser feito: Uma assinatura de dispositivo ATmega ou ATtiny pode ser lida durante a execução? Observe que, ao usar esse método, várias atribuições de registro serão alteradas, não apenas a pinagem. Portanto, seu código pode ficar significativamente mais complexo. A vantagem é que, se você conseguir solucionar todas as atribuições de registro alteradas e outras dependências de hardware, poderá usar um único arquivo .hex para programar seus dispositivos diretamente avrdude.

Tempo de compilação

Outra maneira de descobrir o tipo de placa / controlador é em tempo de compilação. Basicamente, você compila partes do código ou define macros, dependendo do tipo de dispositivo configurado no IDE do Arduino. Verifique este sniplet de código para obter um exemplo:

#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

O sniplet de código foi copiado descaradamente em https://github.com/gillham/logic_analyzer/wiki Verifique esse código para mais alguns truques específicos do dispositivo.

Dependendo do sistema operacional do host, os tipos de controladores suportados podem ser encontrados no seguinte arquivo:

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

O uso do pré-processador C (pelo qual o código acima é tratado) provavelmente está fora do escopo deste site. http://stackoverflow.com seria o melhor lugar para perguntas detalhadas.

Se você estiver no Linux, poderá encontrar facilmente todos os tipos de controladores suportados digitando:

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

Conforme declarado na especificação de hardware do Arduino , o Arduino IDE agora define uma macro para cada placa, conforme definido na build.boardpropriedade boards.txt . Esse valor é anexado a ARDUINO_, portanto, por exemplo, as macros para os painéis nos quais você está interessado são:

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

Exemplo de como você pode usar essas macros no seu 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

Uma maneira fácil de farejar placas é usar uma biblioteca como o ArduinoManager. Com isso, você pode facilmente obter o nome do painel e os recursos https://github.com/backupbrain/ArduinoBoardManager

Ele usa a técnica descrita acima para revelar muitas informações sobre quase todas as placas do Arduino, por isso é excelente para fazer projetos que podem ser implantados em ambientes muito diferentes.

Basta baixar e incluir no seu projeto do 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() {
}

A saída resultante no Arduino Uno é:

Board is compatible with Arduino UNO

Speed/SRAM/Flash: 
16000000
2048
33554432

O processo para fazer esta biblioteca (incluindo exemplo de código) para determinar um modelo de placa Arduino e versão é descrito em detalhes no meu blog.

Para todas as placas compatíveis com Arduio Due

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

(Veja o arquivo sam3.h para obter mais informações.)

Se você deseja apenas segmentar o Arduino Due (excluindo placas compatíveis), pode usar

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

(Isso é definido no arquivo variant.h do Arduino Due .)

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

Como o Arduino Due é uma família de processadores (ARM) diferente dos AVRs, você não poderá usar o mesmo executável para todos os três. Mas você pode ter o mesmo código fonte (assumindo que a sintaxe para ler uma porta seja a mesma nas partes AVR e ARM) e apenas dois executáveis ​​(já que o mesmo será executado no Uno e no Mega sem recompilar).

Você pode determinar o tipo de placa em tempo de execução sem precisar recompilar, escolhendo dois pinos digitais que ainda não estão sendo utilizados pelo seu programa em nenhuma das placas e amarrá-los alto ou baixo como um ID da placa. Por exemplo, se os pinos que você escolher forem PC1 e PC3:

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

Em seguida, basta ler a porta na inicialização e definir uma variável no seu programa.

Outro esquema que pode ser usado, que une apenas um pino, é usar um pino de entrada analógica e usar um divisor de resistor, escolhendo resistores de modo a obter tensões diferentes, por exemplo, incrementos de 0,25V. Eu usei essa técnica para especificar não apenas um tipo de placa, mas também uma revisão da mesma placa (que em certo sentido é um novo tipo de placa).