La programmazione e il debug con simulatori possono essere un ottimo modo per iniziare con il microcontrollore SAMD21. Fornisce una piattaforma eccellente per chi è nuovo ai sistemi embedded e desidera comprendere meglio come funzionano. Utilizzando una varietà di simulatori, è possibile sviluppare progetti e applicazioni in modo rapido e semplice. Attraverso una combinazione di tutorial ed esperienza pratica, puoi acquisire familiarità con le basi della programmazione SAMD21 in pochissimo tempo. In questo post imparerai i tipi di simulatori SAMD21, come eseguire il debug dei programmi sui simulatori, esempi di codice SAMD21 e altro ancora.
Cos'è un simulatore SAMD21?
Il simulatore SAMD21 è un programma per computer che consente agli utenti di simulare il comportamento di un microcontrollore SAMD21. Questo simulatore può essere utilizzato per testare programmi per il processore SAMD21 o per sviluppare applicazioni embedded. Fornisce un ambiente per eseguire il debug e testare programmi sul microcontrollore SAMD21, senza la necessità di hardware fisico. Include una gamma di periferiche, come UART, SPI, I2C, timer e modulatori di larghezza di impulso. Il simulatore include anche un IDE con un assembler, un compilatore e un debugger. Ad esempio, se un utente sta sviluppando un programma per un dispositivo basato su SAMD21, può utilizzare il simulatore per testare il programma e correggerlo senza la necessità di hardware fisico.
Tipi di simulatori per SAMD21
I simulatori sono programmi per computer che simulano il comportamento di un sistema fisico. Sono spesso utilizzati per la programmazione di sistemi embedded, in quanto consentono di testare il codice senza la necessità di hardware fisico. I simulatori per il SAMD21 includono Arduino Create, Proteus e QEMU.
Atmel Studio 7
Atmel Studio 7 è una piattaforma di sviluppo integrata (IDP) sviluppata da Atmel, un produttore leader di microcontrollori. È un potente ambiente di sviluppo che consente agli utenti di scrivere, compilare, eseguire il debug e distribuire applicazioni per i microcontrollori Atmel AVR e ARM. Supporta un’ampia gamma di schede di sviluppo e fornisce strumenti grafici (GUI) per la codifica, il debug e la programmazione. Dispone inoltre di una suite completa di strumenti per il debug del software, l’analisi della traccia e la simulazione. Esempi di funzionalità includono il debug, l’emulatore in-circuit, l’editor di codice, la programmazione del dispositivo e i sistemi di controllo della versione.
Proteus
Proteus è un simulatore che può essere utilizzato per simulare una varietà di sistemi embedded, incluso il SAMD21. Supporta un’ampia gamma di componenti, inclusi sensori, attuatori e display. Fornisce inoltre strumenti di debug e consente l’esecuzione del codice sull’hardware simulato.
QEMU
QEMU è un simulatore open source comunemente utilizzato per la programmazione di sistemi embedded. Supporta un’ampia gamma di architetture, inclusa ARM, e può essere utilizzato per simulare il SAMD21. Fornisce strumenti di debug ed è spesso utilizzato per testare il codice senza la necessità di hardware fisico.
Come eseguire il debug del programma SAMD21 con i simulatori?
Il debug è una parte importante della programmazione SAMD21. Ti consente di trovare e correggere errori nel tuo codice prima che causino problemi al tuo progetto. L’utilizzo del debugger e del monitor seriale può essere un ottimo modo per risolvere i problemi del codice e trovare errori nel tuo programma. È importante assicurarsi di avere una buona conoscenza del funzionamento di questi strumenti prima di iniziare a eseguire il debug del codice. Qui forniamo un esempio sul simulatore Atmel Studio 7:
1). Scarica e installa un pacchetto software compatibile per il microcontrollore SAMD21. Atmel Studio 7 è un esempio di tale software e può essere scaricato dal sito Web Atmel o dal seguente URL.
https://atmel-studio.software.informer.com/download/
2). Crea un nuovo progetto in Atmel Studio 7 selezionando “File” -> “New” -> “Project”. Scegli l’opzione “GCC C ASF Board Project” e clicca “OK”.
3). Scegli la scheda e il microcontrollore che simulerai. In questo esempio, utilizzeremo la scheda SAMD21 Xplained Pro e il microcontrollore ATSAMD21J18A.
4). Nella finestra di dialogo “ASF Wizard”, cerca e seleziona il driver “SERCOM USART”. Quindi clicca “Apply” per generare il progetto.
5). Ora puoi iniziare a codificare il tuo progetto. In questo esempio, scriveremo un semplice programma che invia e riceve dati tramite l’interfaccia USART. Il programma invierà la stringa “Hello World” e quindi attenderà i dati in arrivo. La finestra dell’editor di codice si trova in genere al centro dell’interfaccia utente di Atmel Studio. Se non vedi la finestra dell’editor di codice, puoi aprirla facendo doppio clic sul file .c aggiunto al tuo progetto nel riquadro Solution Explorer. In alternativa, puoi selezionare il file nel riquadro Solution Explorer e quindi cliccare “View” > “Code” dalla barra dei menu per aprire la finestra dell’editor di codice.
#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). Compila ed esegui il programma nel simulatore selezionando “Debug” -> “Start Debugging and Break” dalla barra dei menu. Quindi puoi eseguire il codice passo passo e osservare i valori delle variabili nella finestra “Watch”.
Fatto! Ora puoi utilizzare il simulatore SAMD21 per testare e debuggare i tuoi progetti di microcontrollori.
Esempi di codice SAMD21 aggiuntivi
In generale, gli esempi di codice samd21 possono essere trovati nell’Atmel Software Framework e nell’Atmel mbed Online Compiler. Inoltre, il loro normale funzionamento dipende dalla scheda di sviluppo utilizzata. Ecco alcuni esempi di base:
LED lampeggiante:
#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);
}
Lettura dell'ingresso analogico:
#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);
}
Controllo del servo:
#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);
}
Esempio di interrupt:
#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++;
}
Confronto tra SAMD21 e STM32
I microcontrollori come SAMD21 e STM32 sono molto simili in molti modi. Entrambi sono microcontrollori a 32 bit basati su core ARM® Cortex™-M0+ e hanno un’ampia gamma di funzionalità periferiche. Tuttavia, ci sono anche alcune differenze chiave tra i due. I dettagli sono mostrati nella tabella sottostante:
| 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 |
