IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Embarqué Discussion :

Update microcontrôleur ATMEL ATSAMD20J17 [SAM D]


Sujet :

Embarqué

  1. #1
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut Update microcontrôleur ATMEL ATSAMD20J17
    Bonjour à tous,
    Je suis en train de faire un programme pour un microcontrôleur en C, en l’occurrence un ATMEL ATSAM D20 J17.
    Je dois mettre en place dessus un système de mise à jour du code, et ce via HTTP (système doté d'une SIM808).

    Mon problème est que c'est la première fois pour moi que je fais du hardware, et je n'ai aucune idée de comment procéder.

    En parcourant les fichiers du projet, j'ai cru tombé sur le fichier qui déclenchais le main(), je pensais jouer la dessus avec une variable stocké dans la mémoire non-volatile du microcontrôleur pour déterminer si une mise à jour a été effectuée, et donc, choisir le bon main à exécuter. Est-ce une voie possible ? y a-t-il plus simple ?
    Après cela, il y a également la gestion de plantage qui devra être mis en place.

    PS : désolé si ce post n'est pas a sa place !

    Merci !

  2. #2
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Salut,
    Ce que tu recherches s'appelle un bootloader. C'est un programme qui se place dans un endroit bien précis de la mémoire pour ne pas géner le programme principal.

    Son rôle est simple, si il est appelé (séquence particulière, bouton hardware,...) il prend le contrôle total et toutes les données qui lui seront envoyées, avec un formalisme à respecter bien entendu, seront écrites dans la mémoire.

    - On invoque le bootloader
    - On lui envoie donc le nouveau programme
    - La mise à jour est effectuée

    Suivant les microcontrôleurs, les données envoyées au bootloader peuvent arriver part l'UART, I2C, SPI, USB, CAN ou Ethernet.

    Atmel n'est pas le fabricant que je connais le mieux mais il faudrait que tu regardes sur le site officiel si il fournit un bootloader (c'est sur à 100%) et sur quel port il peut travailler (par ethernet c'est beaucoup moins sur)

    Ça dépend vachement du micro, c'est à dire si il est prévu pour ça initialement.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  3. #3
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    Bonjour Vincent, merci pour ta réponse,
    depuis hier j'ai eu le temps de voir des tonnes de doc et c'est ce que j'en avais compris.
    Atmel fourni un fichier .hex (le bootloader je suppose), a l'heure actuelle je pense avoir correctement décalé la mémoire pour le boot.

    Maintenant je suis en train de mettre en place le code.
    Merci !

    Edit : j'ai ajouté la ligne "port_pin_set_output_level(PIN_PA15, 1);" dans mon main().
    Depuis l'edison (qui me sert d'affichage de la sortie standard pour les printf et autre) n'affiche plus rien, pour moi c'est que l'activation du bootloader a marché.
    Faut t'il lui faire un affichage ? car il n'a visiblement pas lancé le code user.

    Edit 2 : Je n'avais pas vu mais un code est fourni avec le bootloader d'atmel, j’intègre celui-ci et je vois si mon pb est résolu

  4. #4
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Et juste par curiosité, tu as pris quel bootloader ?
    UART ?
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  5. #5
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    Oui UART, enfin, celui-ci a l'air d'être fait pour de USB et de l'UART,
    je vais devoir le modifier car j'ai décaler la mémoire a 0x1000, c'est trop peu pour un bootloader a deux mode.

    Je le fait en UART car la mise a jour se fera par un protocole HTTP, au fait, en étant dans le bootloader, peut-on activé et utilisé la carte ? car j'ai besoin de ça pour utilisé la sim808 et donc obtenir la mise a jour.

  6. #6
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Le bootloader est modifiable, chez Texas ils donnent les sources et depuis ce dernier tu peux accéder aux I/O du microcontrôleur, dans ton cas tu dois pouvoir accéder à ton module SIM808 (comme tous les micros se ressemblent très forts)

    Pour moi le problème n'est pas là, c'est plutôt que j'ai l'impression que ton module SIM808 cause avec des commandes AT, donc sous un certain format qui est différent de celui que le bootloader est sensé recevoir.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  7. #7
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    Effectivement c'est des commandes AT pour la sim808, je verrai ce problème plus tard.

    Pour le moment mon problème est que je ne saisie pas comment le bootloader fonctionne, mon edison est configurer pour être sur le SERCOM5, et le bootloader sur le SERCOM3.
    Le bootloader attend bien une information ?

    Voici la configuration que j'ai fait : j'ai ecris le fichier .hex sur mon micro; dans ARM/GNU Linker, j'ai ajouté un "FLASH segment" : ".text=0x10000" (pb avec le bootloader SAM-BA qui s'attend a ce que le debut de l'application user ce trouve a 0x00000800 ?).

    Cela te semble bon ?
    Comme mon affichage (edison) passe par le SERCOM5, il nécessite une configuration, qui malheureusement s'effectue au lancement de l'app user, donc a la fin du bootloader. Ce qui fait que je n'ai aucun affichage, de même, je n'arrive pas a faire allumé une des LED de la board ...

  8. #8
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Je ne sais pas sur quel hardware tu bosses du coup c'est pas simple de répondre.

    Le document qui décrit comment fonctionne le bootloader UART est celui ci : http://ww1.microchip.com/downloads/e...te_AT04189.pdf

    En effet, tu l'as bien compris le bootloader s'attend a recevoir les infos sur SERCOM3. Pour être invoqué, le bootloader doit voir la broche PA15 à l'état bas durant la phase de démarrage, donc juste après le RESET. En parlant du RESET justement, le bootloader se loge dans la mémoire programme, entre l'adresse 0x000 et 0x800 (sachant qu'au RESET ton micro démarre à l'adresse 0x000) il te faut donc décaler ton programme principal pour qu'il se loge à la suite.

    Nom : im22.PNG
Affichages : 365
Taille : 124,4 Ko

    La première question est : Est ce que le hardware colle avec le bootloader ?

    Ensuite tu peux programmer le bootloader avec le .hex que Atmel donne. Pour le lancer il suffit de suivre la procédure

    Nom : im23.PNG
Affichages : 479
Taille : 61,9 Ko

    Reset + Maintenir PA15 à l'état bas et tu accèdes au Bootloader. Dans le cas où tu n'as pas d'application dans le micro, c'est à dire que tu n'as que le bootloader, c'est ce dernier qui se lance. A partir de là, tu n'as plus besoin d'un IDE comme Atmel Studio et de ça sonde Jtag (intégré ou pas sur le hard) pour programmer ton micro. Un simple logiciel de programmation qui cause par le port série suffit a programmer (Atmel semble en fournir un).

    Il faut que tu arrives à cette étape avant de continuer sinon sa ne sert à rien (ce que j'espère c'est que Atmel donne les sources de son Bootloader comme le fait Texas Instruments )
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  9. #9
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    Je suis sur un atmel ATSAMD20J17, mais sa ne risque pas de t'aider beaucoup.

    Comment je peux être sur que mon programme est a la bonne place dans la mémoire (aussi bien le bootloader que le programme user) ?

    http://ww1.microchip.com/downloads/e...te_AT04189.pdf <--- je me sers de ce fichier comme base depuis hier,
    dans celui-ci il me semble qu'il est précisé que le bootloader (fourni dans AT04189) est compatible avec mon micro.

    " Ensuite tu peux programmer le bootloader avec le .hex que Atmel donne. Pour le lancer il suffit de suivre la procédure", c'est ce que je pense avoir fait, par contre je ne sais pas du tout si atmel fourni le code source.

    D'après ce schéma (https://www.developpez.net/forums/at...0j17/im23.png/)
    si je n'ai pas de code (application user, donc uniquement le bootloader) et que la pin PA_15 n'est pas en LOW, si je met une condition dans le main() "if (0x804 == 0xFFFFFFFF)" je suis sensé arriver sur le bootloader ?

    En parlant de main, comme celui-ci s'organise t'il ? la fonction "system_init()" doit elle être avant ou après le bootloader ?
    Est ce que je peux rediriger l'affichage du bootloader sur SERCOM5 de manière a ce qu'il soit afficher par mon edison ?

    Merci !

  10. #10
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Tu utilises quoi comme outils pour développer sur cette carte ?
    La carte sur laquelle tu développes est une démo board ? On peut trouver une doc sur internet ? Ou bien c'est du hard qui a été développé sur mesure ?

    Citation Envoyé par cracked
    Comment je peux être sur que mon programme est a la bonne place dans la mémoire (aussi bien le bootloader que le programme user) ?
    Lorsque tu compiles ton programme, en regardant dans les fichiers d'assemblages tu devrais le voir que ton programme démarre à l'adresse que tu souhaites.
    Le bootloader que Atmel fournit est normalement déjà compilé/linké/assemblé pour se loger à l'adresse 0x000


    Citation Envoyé par cracked
    D'après ce schéma (https://www.developpez.net/forums/at...0j17/im23.png/)
    si je n'ai pas de code (application user, donc uniquement le bootloader) et que la pin PA_15 n'est pas en LOW, si je met une condition dans le main() "if (0x804 == 0xFFFFFFFF)" je suis sensé arriver sur le bootloader ?
    Il y a une contradiction dans ce que tu écris.
    Si tu n'as pas de code alors tu ne peux pas mettre quelques conditions que ce soient dans le main. Pas de programme, pas de main.

    Ne te préoccupes pas de ce genre de condition, le programme principal ne tient absolument pas compte de la présence du bootloader qui est situé juste au dessus de lui, dans la mémoire. Celui ci est autonome, si PA_15 n'est pas à l'état bas au démarrage alors, on saute à l'adresse 0x800 et c'est là qu'est ton programme.

    Citation Envoyé par cracked
    En parlant de main, comme celui-ci s'organise t'il ? la fonction "system_init()" doit elle être avant ou après le bootloader ?
    Le main est exactement comme si tu n'avais pas de bootloader. Tout ce qu'il faut, c'est dire au compilateur que tu décales ton programme dans la mémoire.

    Citation Envoyé par cracked
    Est ce que je peux rediriger l'affichage du bootloader sur SERCOM5 de manière a ce qu'il soit afficher par mon edison ?
    L'affichage du bootloader ? Je ne sais pas si il affiche quelques choses ? Son rôle est de prendre les données arrivant sur SERCOM3 et de programmer le micro avec.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  11. #11
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    D'accord, je comprend un peu mieux !

    Dans les fichier d'assemblage (projet.map) :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    START GROUP
    LOAD ../src/ASF/thirdparty/CMSIS/Lib/GCC\libarm_cortexM0l_math.a
    LOAD c:/program files (x86)/atmel/studio/7.0/toolchain/arm/arm-gnu-toolchain/bin/../lib/gcc/arm-none-eabi/6.2.1/../../../../arm-none-eabi/lib/thumb/v6-m\libm.a
    END GROUP
    Address of section .text set to 0x800
    START GROUP
    LOAD c:/program files (x86)/atmel/studio/7.0/toolchain/arm/arm-gnu-toolchain/bin/../lib/gcc/arm-none-eabi/6.2.1/thumb/v6-m\libgcc.a
    LOAD c:/program files (x86)/atmel/studio/7.0/toolchain/arm/arm-gnu-toolchain/bin/../lib/gcc/arm-none-eabi/6.2.1/../../../../arm-none-eabi/lib/thumb/v6-m\libc_nano.a
    END GROUP
    Il y a bien :
    END GROUP
    Address of section .text set to 0x800
    START GROUP

    Cependant aucune trace du fichier samd20_sam-ba_image.hex (bootloader).

    Dans le bootloader de ATMEL pour ma puce, il y a des fichiers founi avec dans un fichier "SAM-BA_Monitor", peut tu m'expliquer ce que fait le main (pièce jointe) si le bootloader est indépendant de celui-ci ?

    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    /**
     * \file
     *
     * \brief SAM D20 SAM-BA Bootloader
     *
     * Copyright (c) 2014 Atmel Corporation. All rights reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions are met:
     *
     * 1. Redistributions of source code must retain the above copyright notice,
     *    this list of conditions and the following disclaimer.
     *
     * 2. Redistributions in binary form must reproduce the above copyright notice,
     *    this list of conditions and the following disclaimer in the documentation
     *    and/or other materials provided with the distribution.
     *
     * 3. The name of Atmel may not be used to endorse or promote products derived
     *    from this software without specific prior written permission.
     *
     * 4. This software may only be redistributed and used in connection with an
     *    Atmel microcontroller product.
     *
     * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
     * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
     * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
     * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     * POSSIBILITY OF SUCH DAMAGE.
     *
     */
     
    /**
     * --------------------
     * SAM-BA Implementation on SAMD20
     * --------------------
     * Requirements to use SAM-BA :
     *
     * Supported communication interfaces :
     * --------------------
     *
     * SERCOM3 : TX:PA24 RX:PA25
     * Baudrate : 115200 8N1
     *
     * Pins Usage
     * --------------------
     * The following pins are used by the program :
     * PA25 : input
     * PA24 : output
     * PA15 : input
     *
     * The application board shall avoid driving the PA25,PA24 and PA15 signals
     * while the boot program is running (after a POR for example)
     *
     * Memory Mapping
     * --------------------
     * SAM-BA code will be located at 0x0 and executed before any applicative code.
     *
     * Applications compiled to be executed along with the bootloader will start at
     * 0x800
     * Before jumping to the application, the bootloader changes the VTOR register
     * to use the interrupt vectors of the application @0x800.<- not required as
     * application code is taking care of this
     *
    */
     
    #include "samd20.h"
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "conf_bootloader.h"
    #include "sam_ba_monitor.h"
    #include "usart_sam_ba.h"
     
    static void check_start_application(void);
     
    /**
     * \brief Check the application startup condition
     *
     */
    static void check_start_application(void)
    {
    	uint32_t app_start_address;
     
    	/* Load the Reset Handler address of the application */
    	app_start_address = *(uint32_t *)(APP_START_ADDRESS + 4);
     
    	/**
             * Test reset vector of application @APP_START_ADDRESS+4
             * Stay in SAM-BA if *(APP_START+0x4) == 0xFFFFFFFF
             * Application erased condition
             */
    	if (app_start_address == 0xFFFFFFFF) {
    		/* Stay in bootloader */
    		return;
    	}
     
    	volatile PortGroup *boot_port = (volatile PortGroup *)(&(PORT->Group[BOOT_LOAD_PIN / 32]));
    	volatile bool boot_en;
     
    	/* Enable the input mode in Boot GPIO Pin */
    	boot_port->DIRCLR.reg = GPIO_BOOT_PIN_MASK;
    	boot_port->PINCFG[BOOT_LOAD_PIN & 0x1F].reg = PORT_PINCFG_INEN | PORT_PINCFG_PULLEN;
    	boot_port->OUTSET.reg = GPIO_BOOT_PIN_MASK;
    	/* Read the BOOT_LOAD_PIN status */
    	boot_en = (boot_port->IN.reg) & GPIO_BOOT_PIN_MASK;
     
    	/* Check the bootloader enable condition */
    	if (!boot_en) {
    		/* Stay in bootloader */
    		return;
    	}
     
    	/* Rebase the Stack Pointer */
    	__set_MSP(*(uint32_t *) APP_START_ADDRESS);
     
    	/* Rebase the vector table base address */
    	SCB->VTOR = ((uint32_t) APP_START_ADDRESS & SCB_VTOR_TBLOFF_Msk);
     
    	/* Jump to application Reset Handler in the application */
    	asm("bx %0"::"r"(app_start_address));
    }
     
     
    #if DEBUG_ENABLE
    #	define DEBUG_PIN_HIGH 	PORT->Group[0].OUTSET.reg=(1u<<BOOT_LED)
    #	define DEBUG_PIN_LOW 	PORT->Group[0].OUTCLR.reg=(1u<<BOOT_LED)
    #else
    #	define DEBUG_PIN_HIGH 	do{}while(0)
    #	define DEBUG_PIN_LOW 	do{}while(0)
    #endif
     
     
    /**
     *  \brief SAMD20 SAM-BA Main loop.
     *  \return Unused (ANSI-C compatibility).
     */
    int main(void)
    {
     
    #if DEBUG_ENABLE
            /* Set BOOT_LED pin as output */
            PORT->Group[0].DIRSET.reg=(1u<<BOOT_LED);
    #endif
    	DEBUG_PIN_HIGH;
     
    	/* Jump in application if condition is satisfied */
    	check_start_application();
     
            /* Make OSC8M prescalar to zero rather divide by 8 */
            SYSCTRL->OSC8M.bit.PRESC = 0;
     
    	/* UART is enabled in all cases */
    	usart_open();
     
    	DEBUG_PIN_LOW;
    	/* Wait for a complete enum on usb or a '#' char on serial line */
    	while (1) {
    		/* Check if a '#' has been received */
    		if (usart_sharp_received()) {
    			sam_ba_monitor_init(SAM_BA_INTERFACE_USART);
    			/* SAM-BA on UART loop */
    			while(1) {
    				sam_ba_monitor_run();
    			}
    		}
    	}
    }

    C'est vrai que je ne l'avais pas précisé, effectivement c'est une board faite sur mesure. Je ne peux pas te fournir de doc, malheureusement.

    Dans ce doc : http://ww1.microchip.com/downloads/e...te_AT04189.pdf
    A la partie 2.3.2, impossible pour moi de faire reconnaitre ma board par SAM-BA 2.17.
    Est-ce une partie importante, dans le sens ou j'ai l'impression que cette partie est pour définir au bootloader où il doit sauvegarder les fichiers reçu, donc inutile pour moi pour le moment ?

    Je dois avouer que je commence a mieux voir la chose, mais je suis autant perdu
    C'est pas évident ces ptites bêtes !

  12. #12
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Attention, il faut distinguer deux choses :
    Je vais commencer mon explication dans un sens différent du tien, dans ton message précédent.




    Citation Envoyé par cracked
    Cependant aucune trace du fichier samd20_sam-ba_image.hex (bootloader).
    Dans le bootloader de ATMEL pour ma puce, il y a des fichiers founi avec dans un fichier "SAM-BA_Monitor", peut tu m'expliquer ce que fait le main (pièce jointe) si le bootloader est indépendant de celui-ci ?
    Tout d'abord je suis surpris que Atmel ne donne pas son .hex tout fait ! Mais à défaut il donne les sources et le main dont tu parles est une partie du programme "bootloader". Tu devrais aussi avoir :
    • conf_bootloader.h et peut être un conf_bootloader.c
    • sam_ba_monitor.h et peut être un sam_ba_monitor.c
    • usart_sam_ba.h et peut être un usart_sam_ba.c

    C'est rassurant dans le sens où comme tu as les sources, tu vas pouvoir le moment venu modifier tout ça pour prendre en compte l'arriver d'un nouveau programme, non pas en données bruts mais avec des commandes AT (ce qui est carrément différent.) A défaut d'avoir un .hex, tu dois compiler les fichiers cités plus haut et l'envoyer dans ton micro. /!\ Attention /!\, juste avant tu as configuré Atmel Studio pour qu'il fasse démarrer ton programme à 0x800 mais ici il faut remettre la config initial car ce n'est pas ton programme que tu vas compiler, c'est le bootloader et lui il a besoin de démarrer à l'adresse 0x000. Remet les bons réglages avant de compiler le bootloader et l'envoyer dans le micro via Atmel Studio.


    Une fois que c'est fait, la méthode de programmation de ton programme utilisateur change. Elle se fait au travers de par SAM-BA 2.17 et du bootloader préalablement programmé. Atmel Studio ne te sert plus qu'a compiler le programme principal avec un démarrage à 0x800 mais plus besoin de Atmel Studio et d'une sonde Jtag (intégré ou non) pour programmer.


    impossible pour moi de faire reconnaitre ma board par SAM-BA 2.17.
    Il faut trouver ce qui se passe car c'est déterminant pour la suite. Regarde si ce n'est pas un problème de pilote USB/Série ?


    Est-ce une partie importante, dans le sens ou j'ai l'impression que cette partie est pour définir au bootloader où il doit sauvegarder les fichiers reçu, donc inutile pour moi pour le moment ?
    Hum... oui et non.
    SAM-BA 2.17. charge un fichier .hex et l'envoi via l'UART à ta carte électronique. Si tu as invoqué le bootloader avec la broche PA_15 = LOW lors du démarrage alors le bootloader et SAM-BA 2.17. vont se comprendre et le .hex va se retrouvé programmé dans la mémoire. Ce fichier .hex doit démarrer à l'adresse 0x800 via un petit réglage de Atmel Studio et que tu as réussi a faire visiblement.


    Je ne sais pas si c'est plus clair ?

    ps : ok pour le hard sur mesure.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  13. #13
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    OK !! Ce sont des fichiers sources ! Je pensais que c'était des fichiers a intégrer dans le projet pour que celui-ci le prenne en compte !
    Excuse-moi du coup, merci pour l'explication. "_Source" à la place de "_Monitor" aurai été intelligent de la part de microchip ...

    Modifier le bootloader a l'aide de commande AT me permettra de faire du http je suppose ?

    J'ai donc un fichier .hex (donc le bootloader compilé), redéclarer la mémoire de ma puce (a 0x000) est donc inutile, ce que j'ai fait me semble correct.

    Je vais donc me concentrer sur ce problème de pilote avec SAM-BA 2.17,
    car si je comprend bien ce que tu me dit, dans le doc http://ww1.microchip.com/downloads/e...te_AT04189.pdf la partie 2.1 avec la figure 2-1 n'était pas du tout l'ecriture du bootloader dans la puce ?
    Ce qui expliquerai le fait que la valeur qui ce trouve dans la case "flash (256 KB)" reviens toujours a sa valeur par défaut.

    Quelque chose m'embête, je n'ai rien pour envoyer des info en uart au bootloader (pour l'instant), et sans affichage comme je peux savoir si mon bootloader fonctionne ?
    A l'aide d'une LED tu me dira, sauf que pour ça il faut modifier les fichiers sources du bootloader pour que celui-ci initialise les ports uart et ainsi pouvoir l'allumer.
    On verra après tu me dira, mais je me pose la question.

    Merci bcp pour ton temps !

  14. #14
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Citation Envoyé par cracked Voir le message
    Modifier le bootloader a l'aide de commande AT me permettra de faire du http je suppose ?
    Je l'espère ou alors il faudra peut être ruser. Le bootloader comprend ce qui arrive de SAM-BA 2.17 (ça doit être les données bruts du fichier .hex du genre [adresse][données]) et le moment venu ceux sont des commandes AT qui arriveront du module SIM808 et encapsulé dans http, et c'est tout ça qui devra être décodé pour en extraire les données bruts. Note qu'il est fort probable que le bootloader gonfle et du coup il faudra décaler un peu plus le programme principal dans la mémoire.

    Dans un premier temps, il faut déjà que le bootloader fonctionne le plus simplement possible (par SAM-BA 2.17 via l'UART). Ensuite tu le modifiera pour qu'il prenne en entrée un autre canal (SIM808 et http)


    Citation Envoyé par cracked Voir le message
    J'ai donc un fichier .hex (donc le bootloader compilé), redéclarer la mémoire de ma puce (a 0x000) est donc inutile, ce que j'ai fait me semble correct.
    Pourquoi inutile ?

    Citation Envoyé par cracked Voir le message
    Je vais donc me concentrer sur ce problème de pilote avec SAM-BA 2.17,
    Oui, il faut que ça fonctionne sinon pas moyen de savoir si le bootloader fonctionne.


    Citation Envoyé par cracked Voir le message
    car si je comprend bien ce que tu me dit, dans le doc http://ww1.microchip.com/downloads/e...te_AT04189.pdf la partie 2.1 avec la figure 2-1 n'était pas du tout l'ecriture du bootloader dans la puce ?
    Si si, ça sert a balancer le bootloader dans le micro. Une fois que c'est fait, plus besoin de ça, on passe par SAM-BA 2.17 pour envoyer un programme principal ou pour mettre à jour le programme principal. Il ne me semble pas avoir dit le contraire ?
    Je te fais un petit schéma car si tu n'as jamais fricoté avec des microcontrôleurs, je me doute que ça peut paraître hyper flou.

    Nom : im24.PNG
Affichages : 382
Taille : 207,7 Ko

    C'est hyper important d'arriver a faire fonctionner un truc minimaliste comme le dessin ci dessus pour commencer a modifier le bootloader sereinement.


    Citation Envoyé par cracked Voir le message
    Quelque chose m'embête, je n'ai rien pour envoyer des info en uart au bootloader (pour l'instant), et sans affichage comme je peux savoir si mon bootloader fonctionne ?
    A l'aide d'une LED tu me dira, sauf que pour ça il faut modifier les fichiers sources du bootloader pour que celui-ci initialise les ports uart et ainsi pouvoir l'allumer.
    Tu n'as pas besoin d'afficheur.
    - Tu envoies le bootloader dans la carte tel quel.
    - Tu envois un programme .hex, qui ne fait que clignoter une LED, via SAM-BA 2.17 (en oubliant pas d'invoquer le bootloader sinon ça marche pas !)

    Si la LED clignote alors c'est que tout à fonctionner
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  15. #15
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    Ok pour les commandes AT, chaque choses en son temps,
    parce qu'en relisant le post je me rend compte que je n'avais pas du tout pigé ce que j'étais censé faire.

    Remettre la mémoire programme a 0x00 est inutile car j'ai le bootloader déjà compilé, j'ai donc flashé la puce (figure 2-1) a l'aide du bootloader.hex (a 0x000), puis j'ai précisé a atmel ".text=0x800".
    Avec ce paramètre (.text=), Atmel est censé écrire le programme compilé (autre que le bootloader, un programme qui allume une led par exemple) a l'emplacement 0x800, donc après le bootloader.

    Mais avec ce que je comprend de ce que tu me dis, je pense avoir seulement réécrit par dessus le bootloader et il y a donc un espace mémoire libre de 0x000 à 0x800.

    Atmel sert soit a envoyer des programmes sur une board sans bootloader, soit a envoyer un bootloader lui même et ainsi se passer d'atmel, c'est bien ça ?

    Ton schéma est très clair, il m'a permis de comprendre quelques points.
    Je commence a comprendre ou je vais, merci !

  16. #16
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Citation Envoyé par cracked Voir le message
    Remettre la mémoire programme a 0x00 est inutile car j'ai le bootloader déjà compilé, j'ai donc flashé la puce (figure 2-1) a l'aide du bootloader.hex (a 0x000), puis j'ai précisé a atmel ".text=0x800".
    Avec ce paramètre (.text=), Atmel est censé écrire le programme compilé (autre que le bootloader, un programme qui allume une led par exemple) a l'emplacement 0x800, donc après le bootloader.
    C'est exactement ça.

    Citation Envoyé par cracked Voir le message
    Atmel sert soit a envoyer des programmes sur une board sans bootloader, soit a envoyer un bootloader lui même et ainsi se passer d'atmel, c'est bien ça ?
    99% du boulot va se faire sans bootloader, il se fera avec Atmel Studio car il permet de programmer et surtout debugguer en temps réel comme tu le ferais avec Éclipse + GDB. Tu pourras mettre des points d'arrêts dans le programme, le faire dérouler en pas à pas, voir l'état de la RAM et des registres.

    Si je me suis autant étalé sur les 1% du problème, c'est d'une part parce que c'était la question initiale et d'autre part, la modification d'un bootloader n'est pas simple car ça demande une bonne maîtrise du microcontroleur.

    Si je te demande de mettre en place le bootloader minimaliste c'est pour être sûr que ça fonctionne sinon c'est un coup à se retrouver dans l'impasse complète à la fin (exemple si le hardware monopolise déjà la broche à mettre à l'état bas, il vaut mieux le voir tout de suite plutôt qu'a la fin. Idem si jamais le bootloader devient tellement gros et qu'il n'y a plus assez de place pour le programme)

    Je parle d'expérience être amené à faire une modification du hard ou carrément de changer de micro à la fin ça la fou mal.

    Ps: verifie le hard au niveau de la broche que tu vas devoir maintenir à l'état bas le temps du démarrage. On ne sait jamais si ça se trouve elle sert déjà à quelque chose de précis. A moins qu'un bouton ait été placé par les gars qui ont fait le hard.

    A+
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  17. #17
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    Il faut que je regarde comment débugger sur Atmel Studio avec un outil performant, mon gcc + valgrind me manque :'(

    La modification du bootloader risque d'être périlleuse pour moi, mais je verrai sa une fois que la version basique sera en place.

    Par rapport au PIN PA_15 il n'y a aucun soucis, je bosse avec celui qui fait le hard.

  18. #18
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Ça marche.
    Si tu rencontres un soucis on essaiera de répondre.

    Pour la broche PA_15 qui invoque le bootloader, on devrait retrouver la trace dans le source. Et si c'est ça, on doit pouvoir mettre en place un autre moyen (voir complètement différent) d'invoquer le bootloader au démarrage.
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

  19. #19
    Membre à l'essai
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 46
    Points : 11
    Points
    11
    Par défaut
    Pour le moment le problème que je rencontre réside toujours dans la detection de ma board par SAM-BA V2.17.
    Je ne sais pas par quoi il passe, ni ce dont il a besoin pour fonctionner.

    Nom : Sans titre.png
Affichages : 362
Taille : 22,6 Ko

    J'ai envoyer un mail a Microchip en attendant.

    Edit : la board doit être dans le bootloader pour que SAM-BA la détecte ? Ce qui fait qu'il faut soit que je modifier le bootloader, soit que je pose un bouton sur la board.

    Lorsque la board est débranché, elle redémarre de 0 ? Donc si je maintient le bouton lors du démarrage cela activera le bootloader ?

  20. #20
    Modérateur

    Avatar de Vincent PETIT
    Homme Profil pro
    Consultant en Systèmes Embarqués
    Inscrit en
    Avril 2002
    Messages
    3 191
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Pas de Calais (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Consultant en Systèmes Embarqués
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Avril 2002
    Messages : 3 191
    Points : 11 577
    Points
    11 577
    Par défaut
    Pour rappel, Atmel est l'un des fabricants qui m'est le moins familier mais si je fais le parallèle avec les outils Texas Instruments :


    Citation Envoyé par cracked Voir le message
    Edit : la board doit être dans le bootloader pour que SAM-BA la détecte ?
    Non, le bootloader n'a pas besoin d'être dans le micro pour que SAM-BA la détecte.



    Citation Envoyé par cracked Voir le message
    Ce qui fait qu'il faut soit que je modifier le bootloader, soit que je pose un bouton sur la board.
    Les sources du bootloader tels qu'ils sont fournis par Atmel font que c'est l'état de la broche PA_15 au démarrage qui détermine si on atterrit dans le bootloader ou dans le programme principal juste en dessous dans la mémoire. J'ai trouvé la condition dans le fichier .c que tu avais posté, peu avant. Lit mes commentaires.
    Code C : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    	boot_en = (boot_port->IN.reg) & GPIO_BOOT_PIN_MASK; /* On lit la broche PA_15 */
     
    	/* Si elle est à l'état bas on entre dans le if ci dessous pour lancer le bootloader 
    	 * Bootloader = je prends les données bruts (un nouveau programme) qui arrivent sur le port série 3 et je les programme en mémoire
    	 * le mec qui fait le programme principal prendra soin de le faire démarrer plus loin dans la mémoire pour ne pas que le bootlader s'écrase lui même 
    	 */
    	/* Check the bootloader enable condition  */
    	if (!boot_en) {
    Si tu as envie de dégager ce truc avec PA_15, c'est comme tu veux. Tu peux faire carrément autre chose :
    • Aller sur un serveur web pour vérifier si il y a une mise à jour de dispo au lieu de cette broche mais quid du temps de démarrage ? Et si le serveur n'est pas dispo ou la carte hors connexion ?
    • Mettre un bouton sur la PA_15
    • Démarrer le bootloader si la température a atteint un certain seuil au démarrage
    • ...


    A ta place et avant de tout dézinguer, je m'assurerai que tout fonctionne au poil avec le bootloader tel qu'il est, donc avec la broche PA_15



    Citation Envoyé par cracked Voir le message
    Lorsque la board est débranché, elle redémarre de 0 ?
    Oui elle démarre à 0x000 donc sur le bootloader et celui-ci va regarder la broche PA_15, si elle est à l'état haut, le bootloader saute en 0x800 donc là où est ton programme. Si il n'y a pas de programme, le bootloader semble s'en rendre compte (d'après la datasheet) et il démarre quand même.



    Citation Envoyé par cracked Voir le message
    Donc si je maintient le bouton lors du démarrage cela activera le bootloader ?
    Oui avec le bootloader tel quel, c'est la condition pour le lancer. Si le bootloader ne se lance pas, aucune chance que SAM-BA arrive a causer avec quoi que ce soit.



    En parlant de SAM-BA.
    Je pense qu'il est inutile de chercher ta board dedans. En prenant le même micro sa suffira genre : SAM D20 Xplained Pro. SAM-BA a besoin de le savoir pour deux choses : Causer dans le bon format et faire des vérifications afin de s'assurer que tu ne t'apprêtes pas à balancer un programme 4x plus gros que ce que le micro peut contenir. Souvent ce genre d'outil fait une vérification en relisant le micro + checksum et vérifie si ce qu'il a envoyé dans le micro est bien la même chose que ce qui est dedans.

    Fait attention car en lisant la doc, il est écrit que les sources du bootloader ont été écrit pour un SAM D20 J18 et toi tu as un SAM D20 J17. A voir si c'est problématique ou pas.



    [EDIT]Pas vraiment de problème, la différence est simplement la capacité mémoire[/EDIT]
    Nom : im26.PNG
Affichages : 405
Taille : 58,2 Ko
    La science ne nous apprend rien : c'est l'expérience qui nous apprend quelque chose.
    Richard Feynman

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 4 1234 DernièreDernière

Discussions similaires

  1. Requête update à partir d'une autre table
    Par amiral thrawn dans le forum Langage SQL
    Réponses: 5
    Dernier message: 15/02/2024, 11h40
  2. Réponses: 0
    Dernier message: 06/09/2007, 10h14
  3. [dBase]il y a mieux que la commande sql UPDATE ?
    Par sana72 dans le forum Autres SGBD
    Réponses: 4
    Dernier message: 12/12/2002, 11h59
  4. Réponses: 3
    Dernier message: 10/11/2002, 11h03
  5. update et virgule
    Par Delph dans le forum Bases de données
    Réponses: 8
    Dernier message: 27/08/2002, 14h40

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo