La programmation et le débogage à l'aide de simulateurs peuvent être un excellent moyen de se familiariser avec le microcontrôleur SAMD21. Ils constituent une excellente plateforme pour ceux qui découvrent les systèmes embarqués et souhaitent mieux comprendre leur fonctionnement. Grâce à divers simulateurs, il est possible de développer rapidement et facilement des projets et des applications. Grâce à une combinaison de tutoriels et d'expériences pratiques, vous pouvez vous familiariser avec les bases de la programmation SAMD21 en un rien de temps. Dans cet article, vous découvrirez les différents types de simulateurs SAMD21, les programmes de débogage sur simulateurs, des exemples de code SAMD21 et bien plus encore.
Qu'est-ce que le simulateur SAMD21 ?
Le simulateur SAMD21 est un programme informatique qui permet aux utilisateurs de simuler le comportement d'un microcontrôleur SAMD21. Ce simulateur peut être utilisé pour tester des programmes destinés au processeur SAMD21 ou pour développer des applications embarquées. Il fournit un environnement permettant de déboguer et de tester des programmes sur le microcontrôleur SAMD21, sans avoir besoin de matériel physique. Il comprend une gamme de périphériques, tels que UART, SPI, I2C, des minuteries et des modulateurs de largeur d'impulsion. Le simulateur comprend également un IDE avec un assembleur, un compilateur et un débogueur. Par exemple, si un utilisateur développe un programme pour un appareil basé sur SAMD21, il peut utiliser le simulateur pour tester le programme et le déboguer sans avoir besoin de matériel physique.
Types de simulateurs pour SAMD21
Les simulateurs sont des programmes informatiques qui simulent le comportement d'un système physique. Ils sont souvent utilisés pour la programmation de systèmes embarqués, car ils permettent de tester le code sans avoir besoin de matériel physique. Les simulateurs pour le SAMD21 comprennent Arduino Create, Proteus et QEMU.
Atmel Studio 7
Atmel Studio 7 est une plateforme de développement intégrée (IDP) développée par Atmel, l'un des principaux fabricants de microcontrôleurs. Il s'agit d'un environnement de développement puissant qui permet aux utilisateurs d'écrire, de compiler, de déboguer et de déployer des applications pour les microcontrôleurs Atmel AVR et ARM. Il prend en charge une large gamme de cartes de développement et fournit des outils d'interface utilisateur graphique (GUI) pour le codage, le débogage et la programmation. Il dispose également d'une suite complète d'outils pour le débogage de logiciels, l'analyse de traces et la simulation. Parmi les fonctionnalités, on peut citer le débogage, l'émulateur en circuit, l'éditeur de code, la programmation de périphériques et les systèmes de contrôle de version.
Proteus
Proteus est un simulateur qui peut être utilisé pour simuler divers systèmes embarqués, y compris le SAMD21. Il prend en charge un large éventail de composants, notamment des capteurs, des actionneurs et des écrans. Il fournit également des outils de débogage et permet l'exécution de code sur le matériel simulé.
KVM
QEMU est un simulateur open source couramment utilisé pour la programmation de systèmes embarqués. Il prend en charge un large éventail d'architectures, y compris ARM, et peut être utilisé pour simuler le SAMD21. Il fournit des outils de débogage et est souvent utilisé pour tester du code sans avoir besoin de matériel physique.
Comment déboguer le programme SAMD21 avec des simulateurs ?
Le débogage est une partie importante de la programmation SAMD21. Il vous permet de trouver et de corriger les erreurs dans votre code avant qu'elles ne causent des problèmes dans votre projet. L'utilisation du débogueur et du moniteur série peut être un excellent moyen de dépanner le code et de trouver les erreurs dans votre programme. Il est important de bien comprendre le fonctionnement de ces outils avant de commencer à déboguer votre code. Voici un exemple sur le simulateur Atmel Studio 7 :
1). Téléchargez et installez un progiciel compatible avec le microcontrôleur SAMD21. Atmel Studio 7 est un exemple de tel logiciel. Il peut être téléchargé depuis le site Web d'Atmel ou à l'adresse suivante.
https://atmel-studio.software.informer.com/download/
2). Créez un nouveau projet dans Atmel Studio 7 en sélectionnant « Fichier » -> « Nouveau » -> « Projet ». Choisissez l'option « Projet GCC C ASF Board » et cliquez sur « OK ».
3). Choisissez la carte et le microcontrôleur que vous allez simuler. Dans cet exemple, nous utiliserons la carte SAMD21 Xplained Pro et le microcontrôleur ATSAMD21J18A.
4). Dans la boîte de dialogue « ASF Wizard », recherchez et sélectionnez le pilote « SERCOM USART ». Cliquez ensuite sur « Apply » pour générer le projet.
5). Vous pouvez maintenant commencer à coder votre projet. Dans cet exemple, nous allons écrire un programme simple qui envoie et reçoit des données via l'interface USART. Le programme enverra la chaîne « Hello World », puis attendra les données entrantes. La fenêtre de l'éditeur de code se trouve généralement au centre de l'interface utilisateur d'Atmel Studio. Si vous ne voyez pas la fenêtre de l'éditeur de code, vous pouvez l'ouvrir en double-cliquant sur le fichier .c que vous avez ajouté à votre projet dans le volet Solution Explorer. Vous pouvez également sélectionner le fichier dans le volet Solution Explorer, puis cliquer sur « View » > « Code » dans la barre de menus pour ouvrir la fenêtre de l'éditeur de code.
#include <asf.h>
int main (void)
{
/* Initialize the system */
system_init();
/* Initialize the USART interface */
struct usart_module usart_instance;
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = 9600;
config_usart.mux_setting = USART_RX_3_TX_2_XCK_3;
config_usart.pinmux_pad0 = PINMUX_PB08C_SERCOM4_PAD0;
config_usart.pinmux_pad1 = PINMUX_PB09C_SERCOM4_PAD1;
config_usart.pinmux_pad2 = PINMUX_UNUSED;
config_usart.pinmux_pad3 = PINMUX_UNUSED;
while (usart_init(&usart_instance, SERCOM4, &config_usart) != STATUS_OK);
/* Send a message */
char tx_buffer[] = "Hello World!\r\n";
usart_write_buffer_wait(&usart_instance, (uint8_t *)tx_buffer, sizeof(tx_buffer));
/* Wait for incoming data */
while (1) {
uint8_t rx_byte;
while (usart_read_wait(&usart_instance, &rx_byte) != STATUS_OK);
usart_write_wait(&usart_instance, rx_byte);
}
}
6). Compilez et exécutez le programme dans le simulateur en sélectionnant « Debug » -> « Start Debugging and Break » dans la barre de menu. Vous pouvez ensuite parcourir le code et observer les valeurs des variables dans la fenêtre « Watch ».
C'est tout ! Vous pouvez désormais utiliser le simulateur SAMD21 pour tester et déboguer vos projets de microcontrôleurs.
Exemples supplémentaires de code SAMD21
En général, des exemples de code samd21 sont disponibles dans Atmel Software Framework et Atmel mbed Online Compiler. De plus, leur bon fonctionnement dépend de la carte de développement utilisée. Voici quelques exemples de base :
LED clignotante :
#include <Arduino.h>
#define LED_PIN 13
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
digitalWrite(LED_PIN, HIGH);
delay(1000);
digitalWrite(LED_PIN, LOW);
delay(1000);
}
Lecture des entrées analogiques :
#include <Arduino.h>
#define ANALOG_PIN A0
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(ANALOG_PIN);
float voltage = sensorValue * (3.3 / 1023.0);
Serial.print("Sensor Value: ");
Serial.print(sensorValue);
Serial.print(", Voltage: ");
Serial.println(voltage);
delay(1000);
}
Servocommande :
#include <Arduino.h>
#include <Servo.h>
#define SERVO_PIN 9
Servo myservo;
void setup() {
myservo.attach(SERVO_PIN);
}
void loop() {
myservo.write(0);
delay(1000);
myservo.write(90);
delay(1000);
myservo.write(180);
delay(1000);
}
Exemple d'interruption :
#include <Arduino.h>
#define INTERRUPT_PIN 2
volatile int counter = 0;
void setup() {
pinMode(INTERRUPT_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), interruptHandler, FALLING);
Serial.begin(9600);
}
void loop() {
Serial.println(counter);
delay(1000);
}
void interruptHandler() {
counter++;
}
Comparaison entre SAMD21 et STM32
Les microcontrôleurs tels que le SAMD21 et le STM32 sont très similaires à bien des égards. Tous deux sont des microcontrôleurs 32 bits basés sur des cœurs ARM® Cortex™-M0+ et disposent d'un large éventail de fonctionnalités périphériques. Cependant, il existe également quelques différences clés entre les deux. Les détails sont présentés dans le tableau ci-dessous :
| Feature | SAMD21 | STM32 |
|---|---|---|
| Processor | ARM Cortex-M0+ | ARM Cortex-M |
| SRAM | 32KB | Up to 128KB |
| Flash Memory | 128KB | Up to 1MB |
| Clock Frequency | 48 MHz | 16-32 MHz (depending on model) |
| GPIO Pins | 33 | Up to 82 |
| Communication protocols | SPI, I2C, UART | CAN, USB, Ethernet, SPI, I2C, UART |
| Power Efficiency | Lower power consumption, sleep mode, and designed to run at lower clock speeds | Consumes slightly more power (2-3mA/MHz) |
| Advanced Features | Fewer | Built-in floating point unit, DDR memory controller, and multiple serial interfaces |
| Price | More cost-effective | More expensive, better suited for more complex applications |
