Skip to content

uPesy now ships to the entire European Union

Livraison à partir de seulement 2.50€ !

Contents Menu Expand Light mode Dark mode Auto light/dark mode

Augmenter les fonctionnalités de la carte uPesy One

(Mis à jour le 13/06/2023)

Cet article explique comment programmer la nouvelle version de la puce Atmega328P, l’Atmega328PB avec l’écosystème Arduino. En effet, par défaut la carte uPesy One est vue par l’ordinateur comme une puce Atmega328P, pour assurer une compatibilité complète avec l’écosystème Arduino. Cependant pour les plus avancés, cela peut être frustrant d’avoir une carte avec une puce bridée au niveau logiciel. Ce tutoriel tente d’y remédier : vous pourrez programmer en langage Arduino tout en profitant des nouveautés apportées par la nouvelle version de l’Atmega.

MiniCore : un noyau Arduino alternatif amélioré

Actuellement, le core Arduino officiel ne supporte pas encore l’Atmega328PB (Ils le feront sûrement un jour lorsque l’Atmega328P ne sera plus fabriqué). Ainsi pour programmer la nouvelle version, on doit installer des outils supplémentaires, via le gestionnaire de cartes. L’outil de choix est MiniCore développé par MCUdude , qui supporte la quasi-totalité des puces Atmega.

Note

On peut très bien utiliser MiniCore pour une carte Arduino classique.

On peut l’utiliser sur le logiciel Arduino IDE ou sur PlatformIO .

Installer MiniCore sur l’Arduino IDE pour programmer l’Atmega328PB

La procédure d’installation est identique aux cartes ESP32 ou la Pi Pico :

  • On ajoute ce lien dans les préférences pour référencer MiniCore dans les cartes supplémentaires

    ajouter MiniCore parametre Arduino

    Voici le lien à ajouter :

    https://mcudude.github.io/MiniCore/package_MCUdude_MiniCore_index.json
    
    ajouter MiniCore parametre Arduino
  • On cherche dans le gestionnaire de cartes (Outils → Type de carte → Gestionnaire de cartes ) la ligne MiniCore et on installe la dernière version.

    instllationMiniCore depuis Arduino IDE
  • Une fois l’installation automatique terminée, vous pouvez choisir l’Atmega328 dans le nouveau menu MiniCore.

choisir carte 328PB MiniCore
  • Lorsque l’Atemega328P est sélectionné, de nouveaux paramètres apparaissent dans le menu Outils. Vous pouvez copier ces options suivantes :

    options uPesy One avec 328PB via MiniCore

    Avertissement

    Ces paramètres ne sont pas directement sauvegardés sur la carte, il faut flasher un nouveau bootloader pour qu’ils soient pris en compte.

C’est au niveau de l’option Variant que l’on choisit le modèle 328PB .

Flasher un nouveau bootloader pour l’Atmega328PB

Si vous avez une carte uPesy One, le bootloader actuellement dessus, la fait passer pour un Atmega328P classique. Il faut donc le mettre à jour avec celui fournit par MiniCore pour que cela fonctionne.

Note

Vous avez donc besoin d’une carte Arduino supplémentaire ou un programmateur externe ICSP pour réaliser cette manipulation. Cette carte Arduino supplémentaire doit contenir le programme Arduino : Exemples → 11. ArduinoISP → ArduinoISP . Vous pouvez suivre ce tutoriel pour cette étape .

Lorsque vous avez la carte source avec le programme ArduinoISP et réalisé le câblage entre les 2 cartes, vous devez changer provisoirement le type de programmateur à “Arduino as ISP”.

choisir programmateur Arduino As ISP

Ensuite vous pouvez cliquer sur Graver la séquence d’initialisation pour flasher le nouveau bootloader.

flasher bootloader sur 328PB depuis MiniCore dans Arduino IDE
C:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\tools\avrdude\7.1-arduino.1/bin/avrdude -CC:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\2.2.2/avrdude.conf -v -patmega328pb -cstk500v1 -PCOM8 -b19200 -e -Ulock:w:0xff:m -Uefuse:w:0b11110100:m -Uhfuse:w:0b11010110:m -Ulfuse:w:0b11111111:m

avrdude: Version 7.1-arduino.1
         Copyright the AVRDUDE authors;
         see https://github.com/avrdudes/avrdude/blob/main/AUTHORS

         System wide configuration file is C:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\2.2.2\avrdude.conf

         Using Port                    : COM8
         Using Programmer              : stk500v1
         Overriding Baud Rate          : 19200
         AVR Part                      : ATmega328PB
         Chip Erase delay              : 10500 us
         PAGEL                         : PD7
         BS2                           : PC2
         RESET disposition             : possible i/o
         RETRY pulse                   : SCK
         Serial program mode           : yes
         Parallel program mode         : yes
         Timeout                       : 200
         StabDelay                     : 100
         CmdexeDelay                   : 25
         SyncLoops                     : 32
         PollIndex                     : 3
         PollValue                     : 0x53
         Memory Detail                 :

                                           Block Poll               Page                       Polled
           Memory Type Alias    Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack
           ----------- -------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
           eeprom                 65    20     4    0 no       1024    4      0  3600  3600 0xff 0xff
           flash                  65     6   128    0 yes     32768  128    256  4500  4500 0xff 0xff
           lfuse                   0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           hfuse                   0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           efuse                   0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           lock                    0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           signature               0     0     0    0 no          3    1      0     0     0 0x00 0x00
           calibration             0     0     0    0 no          1    1      0     0     0 0x00 0x00

         Programmer Type : STK500
         Description     : Atmel STK500 version 1.x firmware
         Hardware Version: 2
         Firmware Version: 1.18
         Topcard         : Unknown
         Vtarget         : 0.0 V
         Varef           : 0.0 V
         Oscillator      : Off
         SCK period      : 0.1 us

avrdude: AVR device initialized and ready to accept instructions
avrdude: device signature = 0x1e9516 (probably m328pb)
avrdude: erasing chip
avrdude: reading input file 0xff for lock
         with 1 byte in 1 section within [0, 0]
avrdude: writing 1 byte lock ...
avrdude: 1 byte of lock written
avrdude: verifying lock memory against 0xff
avrdude: 1 byte of lock verified
avrdude: reading input file 0b11110100 for efuse
         with 1 byte in 1 section within [0, 0]
avrdude: writing 1 byte efuse ...
avrdude: 1 byte of efuse written
avrdude: verifying efuse memory against 0b11110100
avrdude: 1 byte of efuse verified
avrdude: reading input file 0b11010110 for hfuse
         with 1 byte in 1 section within [0, 0]
avrdude: writing 1 byte hfuse ...
avrdude: 1 byte of hfuse written
avrdude: verifying hfuse memory against 0b11010110
avrdude: 1 byte of hfuse verified
avrdude: reading input file 0b11111111 for lfuse
         with 1 byte in 1 section within [0, 0]
avrdude: writing 1 byte lfuse ...
avrdude: 1 byte of lfuse written
avrdude: verifying lfuse memory against 0b11111111
avrdude: 1 byte of lfuse verified

avrdude done.  Thank you.

C:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\tools\avrdude\7.1-arduino.1/bin/avrdude -CC:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\2.2.2/avrdude.conf -v -patmega328pb -cstk500v1 -PCOM8 -b19200 -Uflash:w:C:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\2.2.2/bootloaders/optiboot_flash/bootloaders/atmega328pb/16000000L/optiboot_flash_atmega328pb_UART0_115200_16000000L_B5.hex:i -Ulock:w:0xcf:m

avrdude: Version 7.1-arduino.1
         Copyright the AVRDUDE authors;
         see https://github.com/avrdudes/avrdude/blob/main/AUTHORS

         System wide configuration file is C:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\2.2.2\avrdude.conf

         Using Port                    : COM8
         Using Programmer              : stk500v1
         Overriding Baud Rate          : 19200
         AVR Part                      : ATmega328PB
         Chip Erase delay              : 10500 us
         PAGEL                         : PD7
         BS2                           : PC2
         RESET disposition             : possible i/o
         RETRY pulse                   : SCK
         Serial program mode           : yes
         Parallel program mode         : yes
         Timeout                       : 200
         StabDelay                     : 100
         CmdexeDelay                   : 25
         SyncLoops                     : 32
         PollIndex                     : 3
         PollValue                     : 0x53
         Memory Detail                 :

                                           Block Poll               Page                       Polled
           Memory Type Alias    Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack
           ----------- -------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
           eeprom                 65    20     4    0 no       1024    4      0  3600  3600 0xff 0xff
           flash                  65     6   128    0 yes     32768  128    256  4500  4500 0xff 0xff
           lfuse                   0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           hfuse                   0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           efuse                   0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           lock                    0     0     0    0 no          1    1      0  4500  4500 0x00 0x00
           signature               0     0     0    0 no          3    1      0     0     0 0x00 0x00
           calibration             0     0     0    0 no          1    1      0     0     0 0x00 0x00

         Programmer Type : STK500
         Description     : Atmel STK500 version 1.x firmware
         Hardware Version: 2
         Firmware Version: 1.18
         Topcard         : Unknown
         Vtarget         : 0.0 V
         Varef           : 0.0 V
         Oscillator      : Off
         SCK period      : 0.1 us

avrdude: AVR device initialized and ready to accept instructions
avrdude: device signature = 0x1e9516 (probably m328pb)
avrdude: Note: flash memory has been specified, an erase cycle will be performed.
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file C:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\2.2.2/bootloaders/optiboot_flash/bootloaders/atmega328pb/16000000L/optiboot_flash_atmega328pb_UART0_115200_16000000L_B5.hex for flash
         with 484 bytes in 2 sections within [0x7e00, 0x7fff]
         using 4 pages and 28 pad bytes
avrdude: writing 484 bytes flash ...

Writing | ################################################## | 100% 0.08s

avrdude: 484 bytes of flash written
avrdude: verifying flash memory against C:\Users\Alexis\AppData\Local\Arduino15\packages\MiniCore\hardware\avr\2.2.2/bootloaders/optiboot_flash/bootloaders/atmega328pb/16000000L/optiboot_flash_atmega328pb_UART0_115200_16000000L_B5.hex

Reading | ################################################## | 100% 0.00s

avrdude: 484 bytes of flash verified
avrdude: reading input file 0xcf for lock
         with 1 byte in 1 section within [0, 0]
avrdude: writing 1 byte lock ...
avrdude: 1 byte of lock written
avrdude: verifying lock memory against 0xcf
avrdude: 1 byte of lock verified

avrdude done.  Thank you.

Une fois que le bootloader a été flashé, vous pouvez utiliser l’Atmega328PB exactement comme une carte Arduino UNO.

Avertissement

N’oubliez pas de débrancher les fils de la carte ainsi que de remettre le programmateur “AVRSIP mkII” dans l’onglet Outils .

Config utilisation normale Atmega328PB

Lors de vos futurs téléversements via MiniCore, la carte est bien détectée avec la puce Atmega328PB.

carte uPesy One reconnue comme Atmega328PB par l’arduino IDE

Version PlatformIO

https://github.com/MCUdude/MiniCore/blob/master/PlatformIO.md

https://docs.platformio.org/en/latest/boards/atmelavr/ATmega328PB.html#board-atmelavr-atmega328pb

Utiliser les fonctionnalités supplémentaires offertes par la version PB

Les Fonctions Arduino apportées par MiniCore

La version MiniCore ajoute quelques fonctions Arduino pour gérer plus facilement les ports GPIO ainsi que les fonctions de mise en veille :

Les fonctions hardwares additionnels

atmega328PB full pinout

Brochage complet Atmega328PB (MCUDude)

Utiliser les broches PWM additionnelles

En théorie, il y a 3 broches PWM en plus. Mais puisque 2 sont situés sur les broches 0 et 1 , utilisées pour la communication Serial avec l’ordinateur, il n’y a en pratique qu’une broche en plus réellement utilisable : la broche 2 .

int pwmPin = 2;
void setup(){
  pinMode(pwmPin, OUTPUT);
}

void loop(){
    for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){
        analogWrite(pwmPin, dutyCycle);
        delay(50);
    }
}

Utiliser les timers additionnels

Il y a 2 timers 16bits en plus : TC3 et TC4 . Pour les utiliser, vous pouvez prendre des codes existants qui utilisent le Timer TC1 de 16bit de l’Atmega328P et de remplacer tous les 1 par des 3 ou 4 . Par exemple en reprenant, le code de cet article pour le timer TC3 , cela donne :

/*
  Fichier :       1HzTimerSansInterruption.ino

  Description :   Permet de faire clignoter la LED embarquée sur un Atmega328PB, à une fréquence de 1 Hz, via le "timer3"
                  (c'est à dire la voir s'allumer 500ms, puis s'éteindre 500ms, en répétant cela à l'infini !)
                  Pour ce faire, on fera démarrer le timer à partir d'une certaine valeur, et on testera s'il y a débordement du timer à chaque bouclage du programme

  Auteurs :        Jérôme TOMSKI (https://passionelectronique.fr/)
                   Alexis (uPesy) / Version Atmega328PB Timer TC3
*/

void setup()
{
  pinMode (LED_BUILTIN, OUTPUT);      // On définit comme étant une "sortie", la pin où est branché la LED sur l'Arduino Uno

  // Paramétrage du prescaler
  CLKPR = 0b10000000;                 // Tout d'abord, on active le prescaler (en mettant son "1er" bit à 1, et tous les autres à 0)
  CLKPR = 0b00000010;                 // Puis on inscrit le code "0000 0010", signifiant qu'on désire une division par 4 de la fréquence principale

  // Paramétrage du "mode de fonctionnement" du timer3 en "Normal"
  //    -> c'est à dire que le compteur timer3 va compter jusqu'à son maximum, puis revenir à 0, en levant un drapeau au passage (bit TOV3)
  //    -> pour activer ce mode, il faut mettre les bits WGM30, WGM31, WGM32, et WGM13 à 0 (nota : les 2 premiers se trouvent dans le registre TCCR3A, et les 2 autres, dans TCCR3B)
  //    -> pour ce faire, on va se servir de la fonction arduino "bitClear", qui permet de mettre à "0" un bit spécifique, dans un registre donné
  bitClear(TCCR3A, WGM30);
  bitClear(TCCR3A, WGM31);            // Nota : WGM30 et WGM31 se trouvent dans le registre TCCR3A
  bitClear(TCCR3B, WGM32);
  bitClear(TCCR3B, WGM33);            // tandis que WGM32 et WGM13 se trouvent dans le registre TCCR3B

  // Puis on paramètre le prédiviseur du timer3, pour qu'il divise la fréquence issue du prescaler par 64
  //    -> pour faire une division par 64, il faut mettre le bit CS32 à 0, CS31 à 1, et CS30 à 1 également (voir la partie sur les prédiviseurs, pour plus d'infos)
  //    -> et comme juste avant, on va se servir de la fonction "bitClear" pour mettre un bit à 0, et compléter cela avec la fonction "bitSet", pour mettre un autre bit à 1
  bitClear(TCCR3B, CS32);
  bitSet(TCCR3B, CS31);
  bitSet(TCCR3B, CS30);

  // Nota : ici, j'ai tout décomposé pour les "débutants". Mais sachez qu'on aurait pu directement renseigner les registres TCCR3A et TCCR3B, pour aller plus vite
  // Pour cela, il aurait suffit d'écrire les 2 lignes suivantes, pour renseigner ces deux registres :
  //              TCCR3A = 0b00000000;    // pour mettre WGM30 et WGM31 à 0
  //              TCCR3B = 0b00000011;    // pour mettre WGM32 et WGM13 à 0, et activer la division par 64


  // Enfin, on fait démarrer le timer3 non pas à 0, mais à la valeur 34286 (pour rappel, ce timer 16 bits compte jusqu'à 65535, puis revient à 0, en levant au passage le flag TOV3)
  TCNT3 = 34286;

}

void loop()
{
  // À chaque tour de boucle, on test si le bit drapeau "TOV3", contenu dans le registre TIFR3, est levé (c'est à dire à "1")
  // Ainsi, on saura que le timer3 a compté un nombre précis de fois (depuis nos "34286" initiaux), correspondant à nos 500 ms (qui alternés, font bien nos 1 Hz voulus)
  if (bitRead(TIFR3, TOV3) == 1)
  {
    // Pour commencer, on force la valeur du compteur timer3 à "34286" (correspondant à nos 500 ms de délais), parce qu'il a déjà recommencé à compter depuis 0
    TCNT3 = 34286;

    // On en profite pour rabaisser le drapeau ayant signalé l'overflow (bit TOV3), sinon il restera toujours à 1, et on se serait plus jamais averti
    bitSet(TIFR3,TOV3);       // Nota : chose très particulière ici, il faut renvoyer la valeur 1 sur le bit TOV3 pour qu'il passe à 0
                              //        (c'est le constructeur qui impose cette méthode d'acquittement)

    // Puis on inverse l'état de la LED (si elle était allumée, alors on l'éteint, et si elle était éteinte, alors on l'allume)
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }

  // Et... on boucle à l'infini !
}

Les périphériques additionnels

En théorie, la puce Atmega328PB bénéficie de plus de périphériques :

  • +1 Bus Série UART

  • +1 Bus I2C

  • +1 Bus SPI

Avertissement

Actuellement, sur les versions ≤0.4 de la carte uPesy One, les broches supplémentaires de l’Atmega328PB ne sont pas facilement accessibles. En conséquence, les bus I2C et SPI supplémentaires ne pourront pas être utilisés, sauf si vous soudez vous-même des fils directement sur les broches de l’Atmega328PB.

Utiliser le port série UART1

Pour l’utiliser, rien de plus facile : il suffit de rajouter un 1 devant les objets dans le code : Serial.xxSerial1.xx .

Voici un bref exemple :

void setup() {
  Serial.begin(9600);
  Serial1.begin(9600);
  Serial.println("-- uPesy One Demo --");
}

void loop() {
  Serial.println("Message envoyé à l'ordinateur");
  Serial1.println("Message envoyé à une autre carte");
  delay(1000);
}

Avoir une liaison UART supplémentaire est très pratique pour communiquer avec une autre carte tout en ayant la carte uPesy One branchée à l’ordinateur (via l’UART de base).

Avertissement

Les broches de l’UART1 sont utilisées aussi par le bus SPI. On ne peut malheureusement pas utiliser les 2 en même temps.

Fonctionnalités et différences basses niveaux

La version PB possède également des différences basses niveaux, qui sont rarement visibles lorsqu’on programme en code Arduino. Pour ceux qui codent les Atmega en bas niveau, avec les instructions AVR, je vous recommande de consulter ce document qui explique en détail les différences entre l’Atmega328P et l’Atmega328PB :

Differences-between-ATmega328P-and-ATmega328PB_ApplicationNote_AT15007

Ainsi que la datasheet complète:

Atmega328PB_Datasheet