La gamme de microcontrôleurs tinyAVR® de Microchip, dotée de périphériques indépendants du cœur (CIP), d'oscillateurs internes haute vitesse et de systèmes d'événements, est très appréciée. Le nouveau microcontrôleur megaAVR® MCU – série ATmega4809 de Microchip, qui vient d'être lancé, offre une plus grande capacité de stockage et un plus grand nombre de broches. Il s'agit d'une extension de la série tinyAVR. Cette nouvelle série ATmega4809 est un microcontrôleur auxiliaire idéal pour les systèmes complexes utilisant des microprocesseurs et peut devenir un excellent processeur autonome dans les conceptions de systèmes de commande et de contrôle.
Caractéristiques de l'ATmega4809
En tant que premier dispositif megaAVR à intégrer des périphériques indépendants du cœur (CIP), l'ATmega4809 exécute des tâches au niveau matériel plutôt que logiciel. Il étend également les capacités des systèmes de contrôle en temps réel en combinant des périphériques matériels intelligents avec les fonctionnalités basse consommation du cœur AVR®.
- CPU AVR® 8 bits avec multiplicateur matériel
- Mémoire flash jusqu'à 48 Ko
- Jusqu'à 16 canaux ADC 10 bits haute vitesse
- Périphériques logiques personnalisables
- Convertisseur analogique-numérique (ADC) haute vitesse intégré
Ces caractéristiques font de la nouvelle série de microcontrôleurs megaAVR la solution idéale pour une utilisation en tant que microcontrôleurs compagnons dans les systèmes à microprocesseur, ou en tant que processeur autonome parfait dans les conceptions de systèmes de commande/contrôle.
Schéma ATmega4809 Curiosity Nano
Code de démarrage ATmega4809
Outils nécessaires
- Matériel : carte de développement ATmega4809 Curiosity Nano
- Logiciel : MPLAB X IDE v5.5, compilateur XC8
Paramètres des options de compilation
Par défaut, le code de démarrage par défaut (intégré à MicroChip) est utilisé dans MPLAB. Si vous souhaitez utiliser un code de démarrage personnalisé dans votre projet, vous devez définir les options de compilation suivantes :
Sélectionnez le projet et ouvrez le panneau des propriétés du projet. Ajoutez l'option « -nostartfiles » dans Options supplémentaires et enregistrez les modifications.
Traitement des fonctions d'interruption du microcontrôleur
En l'absence d'instruction de saut, le code est exécuté une fois après l'autre depuis le début. Lorsqu'une interruption se produit, le programme saute automatiquement à l'adresse d'entrée d'interruption correspondante, qui est une adresse continue. En général, nous appelons cette adresse d'entrée d'interruption continue une table de vecteurs d'interruption. L'espace mémoire correspondant à l'adresse d'entrée d'interruption n'étant que de 16 bits (2 octets), cet espace ne peut en aucun cas enregistrer notre code de fonction de service d'interruption. Nous placerons donc une instruction de saut à l'adresse d'entrée d'interruption afin de sauter à l'adresse d'entrée de notre fonction de service d'interruption pour exécuter notre fonction de service d'interruption.
Code de démarrage - version d'assemblage
/* This file uses not the AVRASM2.exe assembler but the gnu assembler as - the GNU assembler */
/* Replace the rjmp command with jmp */
#include <xc.h>
.extern main; refers to the main function in the Main.c file
/* Interrupt vector table. Place jump instructions. When an interrupt occurs, jump to the corresponding interrupt service function to execute the interrupt function */
.section .vectors
jmp __ctors_end;
jmp CRCSCAN_NMI
jmp BOD_VLM
jmp RTC_CNT_MEGA4809
jmp RTC_PIT
jmp CCL_CCL
jmpPORTA_PORT
jmp TCA0_OVF_vect
/* Code storage area that runs before the main function is run */
.section .init2
clr r1; Clear r1 register. Some compilers require this
clr r16; Clear SREG status register
out SREG, r16
; Init the STACK Pointer. Initialization stack. Used for calling sub-functions
ldi r16,(RAMEND & 0xff); initialize
out CPU_SPL,r16; stack pointer.
ldi r16,(RAMEND >> 8) ; to RAMEND
out CPU_SPH,r16
.section .init9
rcall main ; jump to main function
jmp 0x00; Function executed after the main function ends. Jump directly to 0x00 to reset the MCU
// code space
.section .text
//interrupt service function
.weak CRCSCAN_NMI; Use the .weak directive to define the function. When this function is defined externally, the externally defined function is used
.globalCRCSCAN_NMI
CRCSCAN_NMI:
reti
.weak BOD_VLM
.global BOD_VLM
BOD_VLM:
reti
.weak RTC_CNT_MEGA4809
.global RTC_CNT_MEGA4809
RTC_CNT_MEGA4809:
reti
.weak RTC_PIT
.globalRTC_PIT
RTC_PIT:
reti
.weak CCL_CCL
.global CCL_CCL
CCL_CCL:
reti
.weakPORTA_PORT
.globalPORTA_PORT
PORTA_PORT:
reti
.end
Code de test
Compilez le code de test de ce fichier de démarrage dans la fonction principale afin de détecter si le démarrage que nous avons écrit peut entrer dans l'interruption de débordement TCA0.
#include "mcc_generated_files/mcc.h"
volatile uint8_t flag = 0;
int main(void)
{
/* Initializes MCU, drivers and middleware */
SYSTEM_Initialize();
/* Replace with your application code */
// protected_write_io(&(CLKCTRL.MCLKCTRLB),IO_KEY,0x01);
PORTF.DIR = 0x20;
TCA0.SINGLE.PERH = 0x4C;
TCA0.SINGLE.PERL = 0x4B;
TCA0.SINGLE.CTRLA = 0x0D;
TCA0.SINGLE.INTCTRL = 0x01;
ENABLE_INTERRUPTS();
while(1)
{
if(flag==1)
{
flag = 0;
PORTF.OUTTGL = 0x20;
}
}
}
ISR(TCA0_OVF_vect)
{
flag = 1;
TCA0.SINGLE.INTFLAGS = 0x01;//??????
}
Boîtier de développement ATmega4809 - Sortie GPIO
Outils nécessaires
- Matériel : carte de développement ATmega4809 Curiosity Nano
- Logiciel : Microchip Studio 7
Créer un nouveau projet
Créez un nouveau projet dans Microchip Studio 7 et ajoutez-y un nouveau dossier.
Sélectionnez le projet, puis cliquez avec le bouton droit de la souris et sélectionnez Ajouter >> Nouveau dossier.
Ajoutez des fichiers au dossier, sélectionnez le fichier C et entrez le nom du fichier C VPORT.c.
Suivez la même méthode pour créer un nouveau fichier VPORT.h.
Définir le chemin d'accès au fichier d'en-tête
Ouvrez la fenêtre des paramètres du projet, cliquez sur les paramètres du projet pour définir le chemin d'accès au fichier d'en-tête :
Écrivez le code
Nous utilisons des structures pour faire fonctionner les périphériques. Étant donné que l'adresse mémoire occupée par la structure est continue comme le tableau, et lorsque nous consultons le manuel de la puce, nous constatons également que l'adresse du groupe de registres périphériques VPORTF est également connectée. Nous pouvons donc attribuer l'adresse de base du registre VPORF au pointeur de structure.
typedef struct VPin_x_Jack{
uint8_t PIT_0: 1;
uint8_t PIN_1: 1;
uint8_t PIN_2: 1;
uint8_t PIN_3: 1;
uint8_t PIN_4: 1;
uint8_t PIN_5: 1;
uint8_t PIN_6: 1;
uint8_t PIN_7: 1;
}VPINx_Jack_TypeDef;
typedef struct VPort_x_Jack{
VPINx_Jack_TypeDef DIR;
VPINx_Jack_TypeDef OUT;
VPINx_Jack_TypeDef IN;
VPINx_Jack_TypeDef INTFLAGS;
}VPORTx_Jack_TypeDef;
#define VPORTA_Jack (*(VPORTx_Jack_TypeDef *)0x0000)
#define VPORTB_Jack (*(VPORTx_Jack_TypeDef *)0x0004)
#define VPORTC_Jack (*(VPORTx_Jack_TypeDef *)0x0008)
#define VPORTD_Jack (*(VPORTx_Jack_TypeDef *)0x000C)
#define VPORTE_Jack (*(VPORTx_Jack_TypeDef *)0x0010)
#define VPORTF_Jack (*(VPORTx_Jack_TypeDef *)0x0014)
Fichier d'en-tête d'épingle dans le fichier main.c
#include <avr/io.h>
#include "VPORTx.h"
extern protected_write_io(void *addr, uint8_t KEY,uint8_t value);
static inline void System_Clock_Setting(void *addr,uint8_t value)
{
protected_write_io(addr,0xD8,value);
}
void LED_Init(void)
{
VPORTF_Jack.DIR.PIN_5 = 1; // PF5 output
VPORTF_Jack.OUT.PIN_5 = 1; // LED off
}
int main(void)
{
//Configure the system clock to 10MHZ
System_Clock_Setting((void *)&(CLKCTRL.MCLKCTRLB),CLKCTRL_PDIV_2X_gc | 1 << CLKCTRL_PEN_bp);
//Initialize LED port
LED_Init();
while (1)
{
}
}
Code de commande de la lumière LED :
Vérifiez le schéma électrique pour confirmer que le port IO connecté à la broche LED est PF5. Étant donné que la borne positive de la LED est connectée à l'alimentation électrique, lorsque la borne négative de la LED est basse, la LED s'allume. Sinon, la LED s'éteint.
VPORTF_Jack.OUT.PIN_5 = 1; // LED off
VPORTF_Jack.OUT.PIN_5 = 0; // LED is on
Débogage du code
Comme indiqué dans la figure ci-dessous, configurez le projet en tant que simulateur et utilisez le débogueur de simulation pour déboguer le code.
Ouvrez la vue E/S pour afficher l'état du registre des broches.
