Ho un progetto su cui voglio lavorare su Uno o Mega (o anche Due) e sarebbe bello se non avessi bisogno di due versioni del software. Ad esempio, su un Mega, per utilizzare SoftwareSerial, è necessario utilizzare pin diversi da quelli su Uno. Consulta la documentazione su Seriale software . Ad ogni modo, sarebbe bello rilevare che sto usando uno Uno in modo da poter usare solo i pin 4 e 5 per TX / RX e se sto usando un Mega il software rileverà e utilizzerà solo i pin 10 e 11 (e di Certo, dovrò collegarlo in modo diverso ma almeno il software sarà lo stesso).

Tempo di esecuzione

Per quanto ne so, non è possibile rilevare il tipo di scheda, ma è possibile leggere l'ID del dispositivo ATmega. Controlla come è possibile fare questa domanda: è possibile leggere una firma del dispositivo ATmega o ATtiny durante l'esecuzione? Si noti tuttavia che quando si utilizza questo metodo, diverse assegnazioni di registro cambieranno, non solo la piedinatura. Pertanto, il codice potrebbe diventare significativamente più complesso. Il vantaggio è che se riesci ad aggirare tutte le modifiche alle assegnazioni dei registri e ad altre dipendenze hardware, puoi utilizzare un singolo file .hex per programmare direttamente i tuoi dispositivi avrdude.

Tempo di compilazione

Un altro modo per capire il tipo di scheda / controller è in fase di compilazione. Fondamentalmente compilate parti del codice o impostate macro a seconda del tipo di dispositivo configurato nell'IDE di Arduino. Controlla questo sniplet di codice per un esempio:

#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

Lo sniplet di codice è stato copiato senza vergogna da https://github.com/gillham/logic_analyzer/wiki Controlla quel codice per qualche altro trucco specifico del dispositivo.

A seconda del sistema operativo dell'host, i tipi di controller supportati sono disponibili nel seguente file:

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

L'uso del preprocessore C (mediante il quale viene gestito il codice sopra) è probabilmente fuori dall'ambito di questo sito. http://stackoverflow.com sarebbe il posto migliore per domande dettagliate.

Se sei su Linux puoi facilmente trovare tutti i tipi di controller supportati digitando:

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

Come indicato nelle specifiche hardware di Arduino , l'IDE di Arduino ora definisce una macro per ogni scheda, come definito nella build.boardproprietà boards.txt . A quel valore viene aggiunto ARDUINO_quindi, ad esempio, le macro per le schede che ti interessano sono:

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

Esempio di come è possibile utilizzare queste macro nel codice:

#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

Un modo semplice per eseguire lo sniffing della scheda è utilizzare una libreria come ArduinoManager. Con questo puoi facilmente ottenere il nome e le caratteristiche della scheda https://github.com/backupbrain/ArduinoBoardManager

Utilizza la tecnica sopra descritta per rivelare molte informazioni su quasi tutte le schede Arduino, quindi è ottimo per realizzare progetti che potrebbero essere distribuiti su ambienti molto diversi.

Basta scaricare e includere nel tuo progetto 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() {
}

L'output risultante su Arduino Uno è:

Board is compatible with Arduino UNO

Speed/SRAM/Flash: 
16000000
2048
33554432

Il processo per creare questa libreria (incluso il codice di esempio) per determinare un modello e una versione della scheda Arduino è descritto in dettaglio sul mio blog.

Per tutte le schede compatibili con Arduio Due

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

(Vedi il file sam3.h per maggiori informazioni.)

Se vuoi solo scegliere come target l'Arduino Due (tralasciando le schede compatibili), puoi usarlo

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

(Questo è definito nel file variant.h di Arduino Due .)

Ringraziamo Adam F /programming//a/21058963/354144

Poiché Arduino Due è una famiglia di processori (ARM) diversa da quella degli AVR, non sarà possibile utilizzare lo stesso eseguibile per tutti e tre. Ma puoi avere lo stesso codice sorgente (supponendo che la sintassi per la lettura di una porta sia la stessa su entrambe le parti AVR e ARM) e solo due eseguibili (poiché lo stesso verrà eseguito su Uno e Mega senza ricompilare).

È possibile determinare il tipo di scheda in fase di runtime senza dover ricompilare, scegliendo due pin digitali che non sono già utilizzati dal programma su nessuna delle schede e collegandoli in alto o in basso come ID scheda. Ad esempio, se i pin scelti sono PC1 e PC3:

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

Quindi leggi la porta all'accensione e imposta una variabile nel tuo programma.

Un altro schema che può essere usato, che lega solo un pin, è usare un pin di ingresso analogico e usare un divisore di resistenza, scegliendo resistori in modo da ottenere tensioni diverse, ad esempio incrementi di 0,25 V. Ho usato quella tecnica per specificare non solo un tipo di scheda, ma anche una revisione della scheda per la stessa scheda (che in un certo senso è un nuovo tipo di scheda).