Connexion

Forum

Système et matériels » Autres matériels et périphériques [Réglé] Programmation MSP430 Programmation d'un MSP430 uniquement sous Mageia

Jybz Membre non connecté

Rang

Avatar

Modérateur

Inscrit le : 10/10/2018 à 10h26

Messages: 1868

Le 01/11/2018 à 10h28
Pour les travaux pratiques sur les microcontrôleurs à la Fac, il y a écrit dans les pré-requis qu'il faut avoir windows. Il serait possible de compiler sous Linux, mais d'après les tuteurs, il serait impossible de programmer le microcontrôleur à cause du programmeur uniquement fonctionnel pour windows.

Bon. Je vais montrer que c'est possible. J'en profite pour l'écrire ici, pour me souvenir de la méthode pour la prochaine fois :)

Les outils utilisés :
Eclipse-C pour programmer en C, pas en java
msp430gcc
mspdebug
les fichiers d'entête pour le microcontrôleur

MSP430-Gcc est fourni par TI :
ici la "racine" :
http://www.ti.com/tool/MSP430-GCC-OPENSOURCE
là la liste des fichiers téléchargeable :
http://software-dl.ti.com/msp430/msp430_public_sw/mcu/msp430/MSPGCC/latest/index_FDS.html
On prendra le fichier msp430-gcc-7.3.1.24_linux64.tar.bz2 Mitto Systems GCC Linux - toolchain only
Pourquoi pas prendre l'installeur ?
1) Je ne sais pas ce qu'il fait.
2) avoir les logiciels d'installé peut avoir des effets inattendu, par exemple, changer de projet et de microcontrôleur, il se peut que le compilateur pour MSP de TI soit utilisé pour compiler des logiciels pour notre système lui même s'il est lié à un fichier avec un nom générique comme $gcc ou le même effet pour d'autre microcontrôleur comme des STM32.
Le fichier est décompressé dans le dossier de l'utilisateur, par exemple ici : ~/outils/msp430-gcc


Sur cette même page, nous téléchargeons aussi les entête prévu pour le microcontrôleur, le dossier contient aussi les scripts de liage pour construire le binaire pour le microcontrôleur.
msp430-gcc-support-files-1.205.zip - Header and Support Files

Avec ces deux dossiers télécharger, il nous est déjà possible de compiler et lier l'exécutable. Mais on n'en fera rien sans une méthode pour transférer l'exécutable dans le microcontrôleur, pour ça il nous faut deux programmeurs. Pour le MSP430g2553 que j'ai, le programmeur mspdebug est bon.

(ça c'est la ligne intéressante $lsusb : "Bus 001 Device 013: ID 0451:f432 Texas Instruments, Inc. eZ430 Development Tool"

mspdebug est trouvable ici :
https://dlbeer.co.nz/mspdebug/
Bon prenons directement depuis github
$cd ~/outils
$git clone https://github.com/dlbeer/mspdebug.git

On est prêt, mais on aime se simplifier la vie, on va utiliser Eclipse comme IDE.
Il le trouve ici :
http://www.eclipse.org/downloads/packages/release/2018-09/r/eclipse-ide-cc-developers
Et on choisit la version de son choix, mais un "Eclipse IDE for C/C++ Developers", ce point est assez important.
On le décompresse aussi là où on veut, et on le veut ici ~/outils/Eclipse-c .
Pourquoi une version précompilée portable (= non installée) ?
Car lorsqu'on installe un plugin, comme par exemple les plugins de Mediatek, il nous laisse pas le de choix simple pour démarrer Eclipse sans le plugin, il se peut que se soit très modifier. Je n'aime pas mélanger les version d'Eclipse et mélanger les plugins. Ici c'est bien défini, l'Eclipse dans ce dossier c'est celui là, sans plugin, pour le C.

Tip top. Maintenant, il faut préparer tout ça.
Pour les entêtes, c'est fini, il n'y a rien à faire.
Pour msp430gcc, on a pris la version précompilé j'espère ! Il n'y a rien à faire.
Eclipse, il est prêt ! Il manque plus qu'à configurer le(s) projet(s), qu'on verra plus tard.
Pour mspdebug : on n'est pas prêt ! Il faut le compiler, et pouvoir accéder au matériel.
Code BASH :
$cd ~/outils/mspdebug/
make
#Non, on ne fait pas d'installation ^^ Peut-être un jour je préparerai des paquets quand je serai serein que ça se fait sans effet de bord sur d'autre logiciels.
#on ajoute l'utilisateur aux groupes dialout et usb. (Bon en vrai dialout n'est pas nécessaire, mais dans 90% des cas, on utilisera un port série dans un projet, donc dialout.)
#On peut ajouter l'utilisateur dans ces groupes avec le CCM -> Système -> utilisateurs -> doubleClicSurL'utilisateur -> onglet Groupes -> On sélectionne usb et dialout
#Vous pouvez le faire en CLI, je vous laisse chercher un peu ^^
#Il faut maintenant créer une règle udev pour le périphérique usb, avec root saississez :
su
echo 'ATTRS{idVendor}=="0451", ATTRS{idProduct}=="f432", MODE="0660", GROUP="dialout"' > /etc/udev/rules.d/69-ti-lauchpad.rules 

Hahaha bon apparemment j'ai mis le périphérique comme dialout... Bon, ça à l'air de fonctionner quand même !

Petit conseil : quand l'utilisateur à une modification de groupe, il vaut mieux relancer la session pour prendre en compte les modifictions.

Bien, tout est là, ya pu qu'a....

Configurer un projet avec Eclipse !
On créer un nouveau projet,
On choisit "C Managed Build" [suivant]
Faites vous plaiz pour le nom du projet
Pour la localisation du projet, faites vous aussi plaisir, personnellement, je mets ça là :
/home/user/workspaces/msp430/projetX
On choisit Executable->Empty Project et Cross GCC puis [suivant]
et [suivant] car je ne sais pas à quoi ça sert,
là on défini le préfixe du compilateur croisé (la permière portion du nom des exécutable dans /home/user/outils/msp430-gcc/bin, soit) msp430-elf-
et bien sûr le chemin /home/user/outils/msp430-gcc/bin et [Finish] !

Bon le projet est un peu nu...
Clic droit et on créer plein de truc, un dossier src (ou n'importe, on a le choix pour y mettre les sources), et deux fichiers un nommé mspdebug.conf et un nommé postbuild.sh, et enfin un dernier fichier main.c dans le dossier src.
Les explications pour les fichiers viendront après.

Dernier clic-droit et propriété sur le projet.
On se modifie un peu la variable d'environnement PATH dans :
C/C++ Build -> Environnment
PATH : /home/jybz/outils/msp430-headers/include:$PATH
Ainsi, les entêtes seront trouvées dans le projet.

Dans C/C++ Build -> Settings
Caché :
Ici on a du boulot !
Dans Tool Settings, nous avons dans le tableau de droite
Cross Settings : Normalement, sur la partie droite, tout est déjà bien configuré dès la création du projet, prefix msp430-elf-
et Path /home/user/outils/msp430-gcc/bin
CrossGCC Compiler : command: gcc
\ Dialect : on ne touche à rien
\Preprocessor : On ajoute le symbole (-D) pour définir notre microprocesseur pour la compilation, c'est lié au entêtes fournies : __MSP430G2553__ Bien sûr, si avec un autre MSP430, changez la valeur.
\Includes : on ajout le chemin vers les entêtes (-I) : /home/user/outils/msp430-headers/include
\Optimization : pour déboguer, le mieux c'est None (-O0), mais quand votre projet est conséquent, changez vers -O3 ou -Os pour une optimisation de la taille (size)
\Debugging : Debug Level : Default (-g)
\Warnings : activez All Warnings (-Wall)
\Miscellaneous : dans other Flags : '-c -mmcu=msp430g2553', là encore, si ce n'est pas le msp430g2553, changez ;)
Cross GCC Linker : Normalement, tout est bon, c'est gcc utilisé.
\General : rien d'activé.
\Librairies : On ajoute le chemin (-L) : /home/user/outils/msp430-headers/include
\Miscellaneous : Linker glafs : '-mcpu=msp430 -T/home/user/outils/msp430-headers/include/msp430g2553.ld -T/home/user/outils/msp430-headers/include/msp430g2553_symbols.ld'
avec mcpu on prévice le type de processeur, et avec -T ou ajoute des scripts de liage, ces scripts contiennent des informations, pour savoir où placer les morceaux de code dans le microcontrôleur.
\shared Library Settings : vide
Cross GCC Assembler : command : as
\general : on ajoute les entêtes (-I) '/home/user/outils/msp430-headers/include'


Là un gros morceau est fait ! À partir de maintenant, le fichier compilé sera le bon, pour le bon microcontrôleur. Je suis sûr qu'il est possible d'optimiser, ajouter une variable d'environnement avec le type de microcontrôleur et l'insérer dans les -T, ou les Miscelleanous linker flag, et réduirait le nombre d'erreur en cas de microcontrôleur différent, mais j'ai pas le temps de vérifier la faisabilité.

On n'en a pas avec cette fenêtre de propriété, avant de la fermer, on va dans l'onglet 'Build Steps', et on ajoute un script post-compilation. Dans Post-Build Steps : Command: '${workspace_project_locations}/postbuild.sh'
Alors pourquoi ce fichier ? Le fichier ELF ne me suffit pas, je ne peux rien en faire. Je dois d'abord le transformer en fichier hex, puis le programmer sur le microcontrôleur, car je n'y arrive pas avec GDB lui même. On le programme avec mspdebug (aussi).

[Apply and close] !

Finissons avec ce fichier de HEX, nous avons créé un fichier postbuild.sh, il est temps de le rendre exécutable avec la commande $chmod +x ~/workspaces/msp430/projetX/postbuild.sh et ajoutons ces lignes dedans :
Code BASH :
#!/bin/sh
#on redéfini la variable du projet qui n'existe pas à l'exécution de ce script
project_name=projetX
workspace_project_locations=~/workspaces/msp430/${project_name}
#on exécute la commande pour transformer le fichier elf en fichier intel hex
~/outils/msp430-gcc/bin/msp430-elf-objcopy -O ihex ${workspace_project_locations}/Debug/${project_name}.elf ${workspace_project_locations}/Debug/${project_name}.hex
#On affiche quelques informations quant au fichier créé
ls -lisah ${workspace_project_locations}/Debug/${project_name}.hex
file ${workspace_project_locations}/Debug/${project_name}.hex
#on programme (ou "flash") le microcontrôleur avec mspdebug, en utilisant le pilote "rf2500".
~/outils/mspdebug/mspdebug rf2500 "prog ${workspace_project_locations}/Debug/${project_name}.hex"


Déboguage

Le programmeur, mspdebug, doit être lancé en arrière plan, il fait le lien entre le microcontrôleur, et le debogueur GDB. On doit le lancer après la compilation (car il est lancé une première fois dans le "post-build" pour programmer le microcontrôleur, si on le lance avant en débogueur et qu'on essaie de charger/flasher le programme après, la nouvelle session de mspdebug échouera car le microcontrôleur sera déjà occupé avec la première session).

Configuration du débogueur
Run -> External tools -> External tools configuration
Dans cette nouvelle fenêtre, on clic dans le menu à gauche sur program, et au dessus on clic sur le premier icone, une feuille blanche avec un plus. (C'est la logique eclipse, on clic sur ce qu'on souhaite, puis on revient en arrière (en haut) pour demander un nouveau truc du type sélectionné.
Dans Name, on nomme comme on veut, moi j'ai nommé mspDeburg (faute de frappe, mais pas grave).
Dans location, on met le chemin : '/home/user/mspdebug/mspdebug'
Dans Arguments :
-C ${workspace_project_locations}/mspdebug.conf rf2500
là on précise un fichier de configuration (-C) et le pilote à utiliser rf2500.
Je n'ai aucune idée de l'ordre ou la pertinance des paramètre, je n'ai aucun exemple.

[Apply] ! (ouais c'est tout...)

Mais ! On doit encore modifier le fichier de configuration (mspdebug.conf) ! ;)

J'y ai mis ces simples lignes, sans savoir si c'est juste :
Code BASH :
opt color true
opt gdb_default_port 2001
opt gdb_loop true
gdb
exit


On sauvegarde, bien sur.

Ouhlala, ça en fait des lignes, on vient de dépasser la 200e.
Aller, on fait une pause code !
Dans le dossier src, on a créé un fichier main.c, on l'ouvre, et on copie/colle ces lignes :

Code C :
//Ce fichier est le fichier entête le plus important ! Il classe toutes les entêtes, et trouve la macro et define associé au microcontrôleur, souvenez vous, on a défini -D__msp430g2553__ dans les configurations du projet.
#include <msp430.h>
//petite fonction de configuration.
int setup(){
    int retVal = 0;
    //On défini le port 1.0 en sortie, on définit sa valeur à 0
    P1DIR |= 0x01; //change P1 to set P1.0 output.
    P1OUT &= 0xfe; //set P1.0 to 0
    return(retVal);
}
//la (fausse)fonction d'entré du programme (fausse car les scripts de liage en définissent une autre :p) 
int main(void){
    //On éteint le watchdog, celui-ci est par défaut activé, il fera un reset intempestif du contrôleur.
    //j'aimerai le mettre dans la fonction setup, mais j'ai un doute quant à l'échéance du chien de garde ;)
     WDTCTL = WDTPW + WDTHOLD;    // Stop WDT
     setup();
    //petite boucle sans fin, plus qu'obligatoire, car on a aucune idée de ce qu'il se passerait après l'exécution du main... Peut-être explosera-t-il ?
     while(1){
        //deux proposition pour faire une non-opération, l'instruction la plus simple...
         //__nop();
         __asm__ volatile ("nop");
        //et on permute la sortie du port 1.0
         P1OUT ^= 0x01; //set or unset P1.0 to 0
     }
 }


Ayé, on peut flasher/programmer :) Mais on ne peut pas encore déboguer...

Dans le menu 'Run' -> 'Debug configurations...' il faut sélectionner "GNU Hardware Debugging" puis (logique Eclipse) cliquer sur le premier icône au dessus 'Run Launch configuration'. En haut de la partie droite, on change le nom (car j'aime bien changer les noms), il n'y a plus grand chose à faire, dans le second onglet nommé 'Debugger' on précise la commande : /home/jybz/outils/msp430-gcc/bin/msp430-elf-gdb ainsi que 'JTAG device : Generic TCP/IP', pour le hostname on précise 'Localhost' (en vrai c'est déjà précisé), pour le Port Number, '2001' comme nous l'avons précisé dans le fichier mspdebug.conf .

variante en test : dans l'onglet startup, dans l'encart 'load image', on précise avec 'Use file:' le fichier .hex du répertoire Debug, puis on commande la ligne du post-build pour programmer le microcontrôleur. Resultat : Echec.

Une image de l'arborescence des outils :

Code BASH :
[jybz@jeeebz ~]$ tree ~/outils/
./outils/
├── eclipse-c
│   └── [...]
├── msp430-gcc
│   ├── bin
│   │   └── [...]
│   ├── include
│   │   └── [...]
│   ├── lib
│   │   └── [...]
│   ├── lib64
│   │   └── [...]
│   ├── libexec
│   │   └── [...]
│   ├── msp430-elf
│   │   └── [...]
│   ├── ReleaseNotes-MSP430-GCC-7.3.1.24.txt
│   ├── share
│   │   └── [...]
│   └── version.properties
├── msp430-headers
│   ├── include
│   │   └── [...]
│   └── Revisions_Header.txt
├── mspdebug
│   ├── AUTHORS
│   ├── BSDmakefile
│   ├── ChangeLog
│   ├── chipinfo.db
│   ├── COPYING
│   ├── drivers
│   │   └── [...]
│   ├── EmbeddedMode.txt
│   ├── FichersInstalles
│   ├── formats
│   │   └── [...]
│   ├── Makefile
│   ├── mspdebug
│   ├── mspdebug.man
│   ├── README
│   ├── simio
│   │   └── [...]
│   ├── ti_3410.fw.ihex
│   ├── ti_3410.fw.txt
│   ├── transport
│   │   └── [...]
│   ├── ui
│   │   └── [...]
│   └── util
│       └── [...]
└── openocd
    └── [...]
451 directories, 5404 files



Épilogue : J'ai demandé de l'aide au tuteur pour "optimiser" le tout, je sais qu'il y a des erreurs, des choses inutiles, des répétitions et je suis sûr qu'il est possible de transférer le programme depuis GDB, sans savoir comment. Il n'a pas su me répondre, et à peur que les autres tuteurs (qui corrigeront mes codes) soient dépassés... :hehe: Edité par Jybz Le 11/05/2019 à 13h01
   
Papoteur Membre non connecté

Rang

Avatar

Modérateur Équipe Mageia

Inscrit le : 03/10/2011 à 22h16

Localisation : Metz

Messages: 6735

Le 01/11/2018 à 11h47
Salut jb
C'est un boulot monstrueux.
J'ai pas compris grand chose :mdr2:
Ce qui m'interpelle un peu, c'est que le programme pour écrire sur le microcontrôleur s'appelle "debug". Mais bon, c'est le choix du fournisseur, si j'ai compris.
Donc, tu n'es pas arrivé à écrire sur le contrôleur, c'est bien ça ?
Un autre truc, c'est qu'est-ce que vient faire le localhost et TCP/IP ?
Bon courage.


Yves
   
Jybz Membre non connecté

Rang

Avatar

Modérateur

Inscrit le : 10/10/2018 à 10h26

Messages: 1868

Le 01/11/2018 à 11h58
Salut papoteur,

Oui, je réussi à écrire sur le micro-controleur les programmes, et surtout les déboguer ! En peut lire le code assembleur présent dans le microcontrôleur.

En fait, le logiciel (MSPDebug) pour écrire sur le micro-controleur est en permanence en connexion avec lui, en arrière plan.
Quand on souhaite déboguer le micro-programme du µC, on utilise GDB, qui est un utilitaire plutôt très standard, et GDB vient se connecter au premier logiciel MSPDebug vient la pile TCP/IP. C'est un moyen IPC (Inter Process Communication) très répandu pour faire communiquer deux logiciels essemble, là GDB et MSPDebug, MSPdebug communique avec le microcontrôleur, et ouvre un serveur TCP, GDB se connecte à ce serveur pour interagir avec le microcntrôleur.
C'est plus clair ?

Mais là j'ai deux soucis, 1) apparemment il me manque des fichiers d'entêtes (d'après un rapport de bug sur Arch, je ne suis pas le seul), et 2) j'aime pas la fausse instruction #pragma pour compilateur qui n'est pas du C, et je ne trouve pas de moyen d'utiliser les interruptions matériels sans passer outre. :/

Y a des pros MSP dans le coin ? :)
   
Papoteur Membre non connecté

Rang

Avatar

Modérateur Équipe Mageia

Inscrit le : 03/10/2011 à 22h16

Localisation : Metz

Messages: 6735

Le 01/11/2018 à 13h55
Oui, c'est plus clair :)
Tu as gagné un ticket pour faire une page wiki :langue2:


Yves
   
magnux77 Membre non connecté

Rang

Avatar

Inscrit le : 21/09/2009 à 11h49

Localisation : Champs-sur-Marne France

Messages: 5039

Le 01/11/2018 à 14h46
Face à Jybz, je me sens comme Obélix face aux romains et je me dis :
"Il est fou ce Jybz !"

Enfin, il faut moduler. Pas à tout-à-fait les romains d'Uderzo qui sont ne sont quand même pas très fute-fute, les vrais romains, ceux qui ont inventé (ou presque) l'urbanisme, les grandes infrastructures, la république, l'administration, etc. Quand je dis "Il est fou ce Jybz", ça a la valeur du jugement d'un buveur de cervoise tiède face à la civilisation romaine. ;-)


...depuis Mandrake 7
Membre de l'April - « promouvoir et défendre le Logiciel Libre»
Soutien Framasoft - « Changer le monde, un octet à la fois»
Config n°1 : cpu=AMD64x6 mem=16G SSD=64G HDD=1T OS=Mageia7-64 DE=Xfce, Config n°2 : Dell Latitude E6410 SSD=120G OS=Mageia7 DE=Xfce, Config n°3 : ThinkpadR40 SSD=32G OS=[Manjaro, Parabola, Mageia6] DE=Xfce, Config n°4 : EeePC901 SSD=20Gb, OS=[SliTaz5/Lxde, Mageia6/Xfce]
   
Jybz Membre non connecté

Rang

Avatar

Modérateur

Inscrit le : 10/10/2018 à 10h26

Messages: 1868

Le 21/12/2018 à 11h25
Après quelques TP, je redonne une configuration un peu plus raffinée :

Dans la configuration d'un projet C sous Eclipse :
C/C++ Build => Settings
Dans l'onglet Tool Settings
Code TEXT :
 
Cross Settings : Prefix : msp430-elf-
                 Path : /home/User/outils/msp430-gcc/bin
Cross Gcc Compiler : Command : gcc
                   Dialect : vide
                   Preprocessor : Defined Symbols -D : __MSP430G2553__
                                  Rien d'autre
                   Includes : include paths -l : /home/user/outils/msp430-headers/include
                              Rien d'autre
                   Optimization : None
                   Debuging : Debug Level : -g3 maximum (par défaut) rien d'autre
                   Warnings : par défaut, juste "-Wall"
                   Miscellaneous : Other flags : -c -fmessage-length=0 -mmcu=msp430g2553
                                   Rien d'autre.
Cross Gcc Linker : command : gcc
                    General : vide
                    Libraires : Librairies (-l) vide
                               Librairy search path (-L) : /home/user/outils/msp430-headers/include
                    Miscellaneous : Linker flags : -mcpu=msp430 -T/home/user/outils/msp430-headers/include/msp430g2553.ld -T/home/user/outils/msp430-headers/include/msp430g2553_symbols.ld
                                    Rien d'autre.
                    Shared Librairy Settings : vide
Cross Gcc Assembler : Command : as
                      Reste par défaut
                      General : include paths (-l) : /home/user/outils/msp430-headers/include
 


Dans l'onglet Build Steps :
Code TEXT :
Pre-build steps : Command: make clean
Post-build steps : command : ${workspace_project_locations}/postbuild.sh
 


Dans l'onglet Build Artifact, tout par défaut, sauf :
Code TEXT :
 
Artifact extension : elf
 


Dans la racine du projet, il faut ajouter le script : postbuild.sh sans oublier de lui donner les droits d'exécution. Voici son contenu :
Code BASH :
#!/bin/sh
## Set the tools path here
tool_path=~/outils
gcc_path=${tool_path}/msp430-gcc/bin
mspdebug_path=${tool_path}/mspdebug
## Define project location and name
if [ $# == 1 ]; then
    project_root=$1
    debug_loc=${project_root}/Debug
    project_name=$(echo $1 | sed -e "s/^.*\///")
else
    if [ $(pwd | sed -e "s/^.*\///") == "Debug" ]; then
        debug_loc=$(pwd)
        cd ../
        project_root=$(pwd)
        cd ${debug_loc}
        project_name=$(echo ${project_root} | sed -e "s/^.*\///")
    else
        echo -e "\nERROR : no project path given !\n"
        exit -1
    fi
fi
## Create the .HEX file
${gcc_path}/msp430-elf-objcopy -O ihex ${debug_loc}/${project_name}.elf ${debug_loc}/${project_name}.hex
## Create the assembly listing .LLS
${gcc_path}/msp430-elf-objdump -DS ${debug_loc}/${project_name}.elf > ${debug_loc}/${project_name}.lss
## programm the microcontroller
${mspdebug_path}/mspdebug rf2500 "prog ${debug_loc}/${project_name}.hex"
 


Voilou. Je ne représente pas comment déboguer. Maintenant lorsqu'on fait "build" dans Eclipse, il transfert automatiquement le code compilé sur la carte. :)

J'en profite pour donner quelques fonctions, c'est mal ! Mauvais ! Mais je n'avais pas le choix car elles étaient demandé comme tel pour les TP, fonctions "delay" calibré pour une fréquence à 1MHz, je ne sais pas si ça fonctionnera pour toutes les cartes et toutes les configurations :

Code C :
/*
 *
 *  Created on: 9 nov. 2018
 *      Author: jybz
 */
#ifndef SRC_TIGCCCOMPATIBILITY_H_
#define SRC_TIGCCCOMPATIBILITY_H_
static void __inline__ pause500us() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(500);
#else
    register unsigned int n = 158;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause1ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(1000);
#else
    register unsigned int n = 324;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause2ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(2000);
#else
    register unsigned int n = 658;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause4ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(4000);
#else
    register unsigned int n = 1326;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause5ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(5000);
#else
    register unsigned int n = 1660;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause10ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(10000);
#else
    register unsigned int n = 3331;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause20ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(20000);
#else
    register unsigned int n = 6672;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause25ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(25000);
#else
    register unsigned int n = 8345;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause40ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(40000);
#else
    register unsigned int n = 13355;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause50ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(50000);
#else
    register unsigned int n = 16695;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause80ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(80000);
#else
    register unsigned int n = 26714;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause100ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(100000);
#else
    register unsigned int n = 33400;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause125ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(125000);
#else
    register unsigned int n = 41745;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause250ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(250000);
#else
    register unsigned int n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 17980;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause500ms() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(500000);
#else
    register unsigned int n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 35973;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
static void __inline__ pause1s() {
#ifdef __TI_COMPILER_VERSION__
    __delay_cycles(1000000);
#else
    register unsigned int n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 65535;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
    n = 6400;
    __asm__ __volatile__ (
            "1: \n"
            " dec %[n] \n"
            " jne 1b \n"
            : [n] "+r"(n));
#endif
}
/*
__attribute__((interrupt(TRAPINT_VECTOR)))
void TRAPINT_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(PORT1_VECTOR)))
void PORT1_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(PORT2_VECTOR)))
void PORT2_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(USCIAB0TX_VECTOR)))
void USCIAB0TX_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(TIMER0_A1_VECTOR)))
void TIMER0_A1_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(TIMER0_A0_VECTOR)))
void TIMER0_A0_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(WDT_VECTOR)))
void WDT_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(COMPARATORA_VECTOR)))
void COMPARATORA_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(TIMER1_A1_VECTOR)))
void TIMER1_A1__ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(TIMER1_A0_VECTOR)))
void TIMER1_A10_ISR(void) {
    while(1){
        _NOP();
    }
}
__attribute__((interrupt(NMI_VECTOR)))
void NMI_ISR(void) {
    while(1){
        _NOP();
    }
}
*/
/*
#define TRAPINT_VECTOR          ( 1)                     // 0xFFE0 TRAPINT
#define PORT1_VECTOR            ( 3)                     // 0xFFE4 Port 1
#define PORT2_VECTOR            ( 4)                     // 0xFFE6 Port 2/
#define ADC10_VECTOR            ( 6)                     // 0xFFEA ADC10
#define USCIAB0TX_VECTOR        ( 7)                     // 0xFFEC USCI A0/B0 Transmit
#define USCIAB0RX_VECTOR        ( 8)                     // 0xFFEE USCI A0/B0 Receive
#define TIMER0_A1_VECTOR        ( 9)                     // 0xFFF0 Timer0)A CC1, TA0
#define TIMER0_A0_VECTOR        (10)                     // 0xFFF2 Timer0_A CC0
#define WDT_VECTOR              (11)                     // 0xFFF4 Watchdog Timer
#define COMPARATORA_VECTOR      (12)                     // 0xFFF6 Comparator A
#define TIMER1_A1_VECTOR        (13)                     // 0xFFF8 Timer1_A CC1-4, TA1
#define TIMER1_A0_VECTOR        (14)                     // 0xFFFA Timer1_A CC0
#define NMI_VECTOR              (15)                     // 0xFFFC Non-maskable
#define RESET_VECTOR            ("reset")                // 0xFFFE Reset [Highest Priority]
*/
#endif /* SRC_TIGCCCOMPATIBILITY_H_ */
 


Petit cadeau bonus, un main.c presque nu :

Code C :
/*
 * main.c
 *
 *  Created on: 19 déc. 2018
 *      Author: Jybz
 */
#include <msp430.h>
#include "TiGccCompatibility.h"
int setup(){
    int retval = 0;
    WDTCTL = WDTPW | WDTHOLD;    // Stop WDT
    return(retval);
}
int main(void){
    setup();
    while(1){
    }
#ifndef __TI_COMPILER_VERSION__
    return(0);
#endif
}
Edité par Jybz Le 21/12/2018 à 11h30
   
Jybz Membre non connecté

Rang

Avatar

Modérateur

Inscrit le : 10/10/2018 à 10h26

Messages: 1868

Le 11/05/2019 à 16h13
Apparemment je n'ai jamais mentionné des dépendances pour la compilations des outils :

Code BASH :
urpmi lib64readline7 lib64readline-devel lib64usb1.0-devel libusb-devel-doc lib64usb-compat0.1-devel gdb gdb-gdbserver gdb-headless lib64ncursesw5 lib64ncursesw6 lib64ncursesw-devel


Il y en a peut-être certains qui sont de trop, mais là ça compile et fonctionne.

Pour déboguer, il faut lancer l'outil, par exemple :
/home/user/outils/mspdebug/mspdebug -C ${workspace_project_locations}/mspdebug.conf rf2500
avec le fichier de configuration :
Citation :
opt color true
opt gdb_default_port 10000
opt gdb_loop true
gdb
exit


Pour déboguer, il faut créer un profil "GDB Hardware Debugging"
Dans Debugger, on met en tant que GDB Command : /home/user/outils/msp430-gcc/bin/msp430-elf-gdb
On laisse localhost et le port 10000 comme notre premier fichier de configuration

Ne vous laissez par surprendre, le débogage commence dès l'étape d'initialisation, bien avant le main() ! ;)
   
Répondre
Vous n'êtes pas autorisé à écrire dans cette catégorie