J'ai un projet sur lequel je veux travailler sur un Uno ou un Mega (ou même un Due) et ce serait bien si je n'avais pas besoin de deux versions du logiciel. Par exemple, sur un Mega, pour utiliser SoftwareSerial, vous devez utiliser des broches différentes de celles d'un Uno. Voir les documents sur Software Serial . Quoi qu'il en soit, ce serait bien de détecter que j'utilise un Uno donc je peux simplement utiliser les broches 4 et 5 pour TX / RX et si j'utilise un Mega, le logiciel détectera et utilisera simplement les broches 10 et 11 (et de bien sûr, je vais devoir le câbler différemment mais au moins le logiciel sera le même).

Durée

À ma connaissance, vous ne pouvez pas détecter le type de carte, mais vous pouvez lire l'ID de l'appareil ATmega. Vérifiez cette question comment cela peut être fait: une signature d'appareil ATmega ou ATtiny peut-elle être lue pendant l'exécution? Notez cependant que lorsque vous utilisez cette méthode, plusieurs affectations de registre changeront, pas seulement le brochage. Par conséquent, votre code peut devenir beaucoup plus complexe. L'avantage est que si vous parvenez à contourner toutes les affectations de registre changeantes et autres dépendances matérielles, vous pouvez utiliser un seul fichier .hex pour programmer vos périphériques directement à partir de avrdude.

Compiler le temps

Une autre façon de déterminer le type de carte / contrôleur est au moment de la compilation. Fondamentalement, vous compilez des parties du code ou définissez des macros en fonction du type de périphérique configuré dans l'IDE Arduino. Consultez cet exemple de code pour un exemple:

#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

Le fragment de code a été copié sans vergogne à partir de https://github.com/gillham/logic_analyzer/wiki Vérifiez ce code pour une astuce plus spécifique à l'appareil.

Selon le système d'exploitation de votre hôte, les types de contrôleurs pris en charge se trouvent dans le fichier suivant:

• Linux: /usr/lib/avr/include/avr/io.h
• Les fenêtres: ...\Arduino\hardware\tools\avr\avr\include\avr\io.h

L'utilisation du préprocesseur C (par lequel le code ci-dessus est géré) est probablement hors de portée pour ce site. http://stackoverflow.com serait le meilleur endroit pour des questions détaillées.

Si vous êtes sous Linux, vous pouvez facilement trouver tous les types de contrôleurs pris en charge en tapant:

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

Comme indiqué dans la spécification matérielle Arduino , l'IDE Arduino définit désormais une macro pour chaque carte, comme défini dans la build.boardpropriété boards.txt . Cette valeur est ajoutée à ARDUINO_, par exemple, les macros des cartes qui vous intéressent sont:

• Uno: ARDUINO_AVR_UNO
• Mega 2560: ARDUINO_AVR_MEGA2560
• Dû: ARDUINO_SAM_DUE

Exemple d'utilisation de ces macros dans votre code:

#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 moyen simple de renifler des cartes consiste à utiliser une bibliothèque telle que ArduinoManager. Avec cela, vous pouvez très facilement obtenir le nom et les fonctionnalités de la carte https://github.com/backupbrain/ArduinoBoardManager

Il utilise la technique décrite ci-dessus pour révéler de nombreuses informations sur presque toutes les cartes Arduino, il est donc idéal pour créer des projets qui pourraient être déployés dans des environnements très différents.

Téléchargez et incluez simplement dans votre projet 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 sortie résultante sur Arduino Uno est:

Board is compatible with Arduino UNO

Speed/SRAM/Flash: 
16000000
2048
33554432

Le processus de création de cette bibliothèque (y compris un exemple de code) pour déterminer un modèle et une version de carte Arduino est décrit en détail sur mon blog.

Pour toutes les cartes compatibles avec Arduio Due

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

(Voir le fichier sam3.h pour plus d'informations.)

Si vous souhaitez simplement cibler l'Arduino Due (en laissant de côté les cartes compatibles), vous pouvez utiliser

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

(Ceci est défini dans le fichier variant.h d' Arduino Due .)

Crédit à Adam F /programming//a/21058963/354144

Étant donné que l'Arduino Due est une famille de processeurs (ARM) différente de celle des AVR, vous ne pourrez pas utiliser le même exécutable pour les trois. Mais vous pouvez avoir le même code source (en supposant que la syntaxe de lecture d'un port est la même sur les parties AVR et ARM), et seulement deux exécutables (car le même s'exécutera sur Uno et Mega sans recompilation).

Vous pouvez déterminer le type de carte au moment de l'exécution sans avoir à recompiler, en choisissant deux broches numériques qui ne sont déjà utilisées par votre programme sur aucune des cartes et en les liant haut ou bas comme ID de carte. Par exemple, si les broches que vous choisissez sont PC1 et PC3:

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

Ensuite, lisez simplement le port à la mise sous tension et définissez une variable dans votre programme.

Un autre schéma qui peut être utilisé, qui n'attache qu'une seule broche, consiste à utiliser une broche d'entrée analogique et à utiliser un diviseur de résistance, en choisissant des résistances telles que vous obtenez des tensions différentes, par exemple, des incréments de 0,25 V. J'ai utilisé cette technique pour spécifier non seulement un type de carte, mais aussi une révision de carte pour la même carte (qui, dans un sens, est un nouveau type de carte).