A programação e a depuração com simuladores podem ser uma ótima maneira de começar a usar o microcontrolador SAMD21. Ele oferece uma excelente plataforma para quem é novo em sistemas embarcados e deseja entender melhor como eles funcionam. Utilizando uma variedade de simuladores, é possível desenvolver projetos e aplicativos de forma rápida e fácil. Através de uma combinação de tutoriais e experiência prática, você pode se familiarizar com os fundamentos da programação SAMD21 em pouco tempo. Nesta postagem, você aprenderá os tipos de simuladores SAMD21, programas de depuração em simuladores, exemplos de código SAMD21 e muito mais.
O que é o SAMD21 Simulator?
O Simulador SAMD21 é um programa de computador que permite aos usuários simular o comportamento de um microcontrolador SAMD21. Este simulador pode ser usado para testar programas para o processador SAMD21 ou para desenvolver aplicações embarcadas. Ele fornece um ambiente para depurar e testar programas no microcontrolador SAMD21, sem a necessidade de hardware físico. Ele inclui uma variedade de periféricos, como UART, SPI, I2C, temporizadores e moduladores de largura de pulso. O simulador também inclui um IDE com um assembler, compilador e depurador. Por exemplo, se um usuário estiver desenvolvendo um programa para um dispositivo baseado em SAMD21, ele poderá usar o simulador para testar o programa e depurá-lo sem a necessidade de hardware físico.
Tipos de simuladores para SAMD21
Simuladores são programas de computador que simulam o comportamento de um sistema físico. Eles são frequentemente usados para programação de sistemas embarcados, pois permitem testar códigos sem a necessidade de hardware físico. Simuladores para o SAMD21 incluem Arduino Create, Proteus e QEMU.
Atmel Studio 7
O Atmel Studio 7 é uma plataforma de desenvolvimento integrada (IDP) desenvolvida pela Atmel, fabricante líder de microcontroladores. É um ambiente de desenvolvimento poderoso que permite aos usuários escrever, compilar, depurar e implantar aplicativos para microcontroladores Atmel AVR e ARM. Ele suporta uma ampla gama de placas de desenvolvimento e fornece ferramentas de interface gráfica do usuário (GUI) para codificação, depuração e programação. Ele também possui um conjunto completo de ferramentas para depuração de software, análise de rastreamento e simulação. Exemplos de recursos incluem depuração, emulador em circuito, editor de código, programação de dispositivos e sistemas de controle de versão.
Proteus
O Proteus é um simulador que pode ser usado para simular uma variedade de sistemas embarcados, incluindo o SAMD21. Ele suporta uma ampla gama de componentes, incluindo sensores, atuadores e displays. Ele também fornece ferramentas de depuração e permite a execução de código no hardware simulado.
KVM
O QEMU é um simulador de código aberto comumente usado para programação de sistemas embarcados. Ele suporta uma ampla gama de arquiteturas, incluindo ARM, e pode ser usado para simular o SAMD21. Ele fornece ferramentas de depuração e é frequentemente usado para testar código sem a necessidade de hardware físico.
Como depurar o programa SAMD21 com simuladores?
A depuração é uma parte importante da programação SAMD21. Ela permite que você encontre e corrija erros no seu código antes que eles causem problemas no seu projeto. Usar o depurador e o monitor serial pode ser uma ótima maneira de solucionar problemas no código e encontrar erros no seu programa. É importante garantir que você tenha um bom entendimento de como essas ferramentas funcionam antes de começar a depurar o seu código. Aqui, fornecemos um exemplo no simulador Atmel Studio 7:
1). Baixe e instale um pacote de software compatível com o microcontrolador SAMD21. O Atmel Studio 7 é um exemplo desse tipo de software e pode ser baixado do site da Atmel ou do seguinte URL.
https://atmel-studio.software.informer.com/download/
2). Crie um novo projeto no Atmel Studio 7 selecionando "Arquivo" -> "Novo" -> "Projeto". Escolha a opção "Projeto de placa GCC C ASF" e clique em "OK".
3). Escolha a placa e o microcontrolador que você irá simular. Neste exemplo, usaremos a placa SAMD21 Xplained Pro e o microcontrolador ATSAMD21J18A.
4). Na caixa de diálogo "ASF Wizard", procure e selecione o driver "SERCOM USART". Em seguida, clique em "Apply" para gerar o projeto.
5). Agora você pode começar a codificar seu projeto. Neste exemplo, vamos escrever um programa simples que envia e recebe dados através da interface USART. O programa enviará a string "Hello World" e aguardará os dados recebidos. A janela do editor de código normalmente está localizada no centro da interface do usuário do Atmel Studio. Se você não vir a janela do editor de código, poderá abri-la clicando duas vezes no arquivo .c que você adicionou ao seu projeto no painel Solution Explorer. Como alternativa, você pode selecionar o arquivo no painel Solution Explorer e clicar em "View" > "Code" na barra de menus para abrir a janela do editor de código.
#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). Compile e execute o programa no simulador selecionando "Debug" -> "Start Debugging and Break" na barra de menus. Você pode então percorrer o código e observar os valores das variáveis na janela "Watch".
É isso! Agora você pode usar o simulador SAMD21 para testar e depurar seus projetos de microcontroladores.
Exemplos adicionais de código SAMD21
Em geral, exemplos de código samd21 podem ser encontrados no Atmel Software Framework e no Atmel mbed Online Compiler. Além disso, o funcionamento normal depende da placa de desenvolvimento utilizada. Aqui estão alguns exemplos básicos:
LED piscando:
#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);
}
Leitura da entrada analógica:
#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);
}
Controle 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);
}
Exemplo de interrupção:
#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++;
}
Comparando SAMD21 com STM32
Microcontroladores como o SAMD21 e o STM32 são muito semelhantes em muitos aspectos. Ambos são microcontroladores de 32 bits baseados em núcleos ARM® Cortex™-M0+ e possuem uma ampla gama de recursos periféricos. No entanto, também existem algumas diferenças importantes entre os dois. Os detalhes são mostrados na tabela abaixo:
| 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 |
