exercice MSP430FR4133 langage C

[meliego]

Bonjour,

Je suis en école d'ingénieur et j'ai un exercice à faire sur un MSP430FR4133, mais je n'ai pas de connaissances en langage C. J'ai essayé de m'aider d'internet, de chatgpt et de l'exercice d'un étudiant de l'année précédente, mais lui avait un MSP430FR2433, son code ne fonctionne donc pas avec le mien.
J'ai essayé de changer les informations mais le code ne fonctionne pas.

Voici l'énoncé de mon exercice :

A l'aide du launchpad, on souhaite réaliser une fonction monostable avec le
fonctionnement suivant.
- L’appui sur un Bouton Poussoir S1 (PUSH1) ou S2 (PUSH2) déclenche une
temporisation de 5 secondes.
- La LED verte est allumée le temps de cette temporisation.
- Chaque nouvel appui sur S1 pendant la temporisation allume la LED rouge
pendant l’appui, et stoppe la temporisation en éteignant la LED verte.
- L’appui sur le Bouton Poussoir S2 redémarre la temporisation de 5 secondes,
la LED rouge s’allume pendant l’appui


Voici mon code, pouvez-vous me dire s'il y a des erreurs ? Actuellement le code ne fonctionne pas, mais je ne sais pas où se trouvent les erreurs et ce qu'il faut modifier.

#define RED_LED = BIT0     // LED Rouge P1.0
#define GREEN_LED = BIT4   // LED Verte P4.0
#define BP1 = BIT2         // Bouton-poussoir P1.2
#define BP2 = BIT6         // Bouton-poussoir P2.6

volatile unsigned int timerCount = 0;

void setupLEDs()
{
    P1DIR |= RED_LED;   // Configuration de la LED Rouge en sortie
    P4DIR |= GREEN_LED; // Configuration de la LED Verte en sortie
    P1OUT &= ~RED_LED;  // Désactive la LED Rouge
    P4OUT &= ~GREEN_LED; // Désactive la LED Verte
}

void setupButtons()
{
    P1DIR &= ~BP1; // Configuration du bouton-poussoir P1.2 en entrée
    P2DIR &= ~BP2; // Configuration du bouton-poussoir P2.6 en entrée

    P1REN |= BP1; // Activation de la résistance de pull-up pour P1.2
    P2REN |= BP2; // Activation de la résistance de pull-up pour P2.6

    P1OUT |= BP1; // Configure P1.2 en pull-up
    P2OUT |= BP2; // Configure P2.6 en pull-up

    P1IES |= BP1; // Interruption sur front descendant pour P1.2
    P2IES |= BP2; // Interruption sur front descendant pour P2.6

    P1IFG &= ~BP1; // Efface le flag d'interruption pour P1.2
    P2IFG &= ~BP2; // Efface le flag d'interruption pour P2.6

    P1IE |= BP1; // Active l'interruption pour P1.2
    P2IE |= BP2; // Active l'interruption pour P2.6

    __enable_interrupt(); // Active les interruptions
}

void delay(unsigned int milliseconds)
{
    while (milliseconds--)
    {
        __delay_cycles(1000); // Attente d'une milliseconde
    }
}

void startTimer()
{
    CCTL0 = CCIE;                  // Active l'interruption du Timer
    TACTL = TASSEL_2 + MC_1 + ID_3; // Source d'horloge SMCLK, mode Up, division d'horloge 8
    TACCR0 = 4096 * 5;             // Compteur du Timer pour 5 secondes
}

void stopTimer()
{
    TACTL = 0; // Désactive le Timer
}

void turnOnGreenLED()
{
    P4OUT |= GREEN_LED;
}

void turnOffGreenLED()
{
    P4OUT &= ~GREEN_LED;
}

void turnOnRedLED()
{
    P1OUT |= RED_LED;
}

void turnOffRedLED()
{
    P1OUT &= ~RED_LED;
}

void main()
{
    WDTCTL = WDTPW + WDTHOLD; // Arrêt du watchdog timer

    setupLEDs();
    setupButtons();

    while (1)
    {
        // Attente infinie
    }
}

#pragma vector=PORT1_VECTOR
__interrupt void Port1_ISR(void)
{
    if (P1IFG & BP1) // Interruption causée par le bouton
    {
        P1IFG &= ~BP1; // Efface le flag d'interruption pour P1.2

        if (timerCount == 0) // Si la temporisation n'est pas déjà en cours
        {
            turnOnGreenLED();  // Allume la LED Verte
            startTimer();      // Démarre la temporisation de 5 secondes
        }
        else // Si la temporisation est déjà en cours
        {
            turnOnRedLED();    // Allume la LED Rouge
            stopTimer();       // Arrête la temporisation
            turnOffGreenLED(); // Éteint la LED Verte
        }
    }
}

#pragma vector=PORT2_VECTOR
__interrupt void Port2_ISR(void)
{
    if (P2IFG & BP2) // Interruption causée par le bouton-poussoir P2.6
    {
        P2IFG &= ~BP2; // Efface le flag d'interruption pour P2.6

        if (timerCount > 0) // Si la temporisation est en cours
        {
            startTimer();    // Redémarre la temporisation de 5 secondes
            turnOnGreenLED(); // Allume la LED Verte
        }
    }
}

#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer0_A0_ISR(void)
{
    timerCount++; // Incrémente le compteur de temporisation

    if (timerCount >= 5) // Si la temporisation est terminée
    {
        stopTimer();       // Arrête la temporisation
        turnOffGreenLED(); // Éteint la LED Verte
        timerCount = 0;    // Réinitialise le compteur de temporisation
    }
}

Merci d'avance
-----

[umfred]

Déjà, que fait le programme quand tu l'exécutes ? comment réagit-il ?

les 2 MSP430 me semblent suffisamment similaires pour que le code puisse fonctionner sur l'un comme sur l'autre pour cet exercice (ils ont une doc commune https://www.ti.com/lit/ug/slau445i/slau445i.pdf ). La différence pourrait être principalement au niveau du schéma.

[meliego]

Bonsoir, en fait je me suis trompé de programme, celui là me parait bon mais impossible de le compiler ...

Voici celui de l'ancien étudiant que j'ai adapté au niveau des entrées / sorties (lui se compile mais il ne se passe rien quand j'appui sur les boutons):

#include <msp430.h> 

int main(void)
{
	WDTCTL = WDTPW | WDTHOLD;	// stop watchdog timer

	return 0;
}
const int red_led = BIT0; //Constante pour la LED Rouge P1.0;
const int green_led = BIT4; //Constante pour la LED Verte P4.0;
const int bp1 = BIT2; //Constante pour le bouton poussoir P1.2;
const int bp2 = BIT6; //Constante pour le bouton poussoir 2.6;

const unsigned int timer_5 = 4096 * 5; //Initialise la variable pour un timer de 5s;

int switch_case; //Variable pour gerer le switch;
int setup_bp1_input(void);
int setup_bp2_input(void);
int setup_red_led_output(void);
int setup_green_led_output(void);
int turn_on_green_led(void);
int turn_on_red_led(void);
int turn_off_green_led(void);
int turn_off_red_led(void);
int timer_setup(void);
int launch_timer(void);
int stop_timer(void);

int setup_bp1_input(void) { //Initialise le bouton poussoir P1.2 comme une entrée;

    P1DIR &= ~bp1;
    P1REN |= bp1;
    P1OUT |= bp1;
    P1IES |= bp1;
    P1IFG &= ~bp1;
    P1IE |= bp1;
    return (0);
}

int setup_bp2_input(void) { //Initialise le bouton poussoir P2.6 comme une entrée;

    P2DIR &= ~bp2;
      P2REN |= bp2;
      P2OUT |= bp2;
      P2IES |= bp2;
      P2IFG &= ~bp2;
      P2IE |= bp2;
      return (0);
  }

int setup_red_led_output(void) { //Initialise la LED P1.0 comme une sortie;
    P1DIR |= red_led;
    P1OUT &= ~red_led;
    return (0);
}

int setup_green_led_output(void) { //Initialise la LED P4.0 comme une sortie;
    P4DIR |= green_led;
    P4OUT &= ~green_led;
    return (0);
}

int turn_on_red_led(void) { //Fonction pour allumer la LED rouge;
    P1OUT = red_led;
    return (0);
}

int turn_on_green_led(void) { //Fonction pour allumer la LED verte;
    P4OUT = green_led;
    return (0);
}

int turn_off_red_led(void) { //Fonction pour eteindre la LED Rouge;
    P1OUT &= ~red_led;
    return (0);
}

int turn_off_green_led(void) { //Fonction pour eteindre la LED Verte;
    P4OUT &= ~green_led;
    return (0);
}

int timer_setup(void) { //Parametrage du Timer A0;
    TA0CCTL0 = CCIE;
    TA0CTL |= TASSEL_1 + MC_1 + ID_3;
    TA0CCR0 = timer_5;
    return (0);
}

int launch_timer(void) { //Lancement du Timer A0;
    timer_setup();
    TA0CTL |= MC_1;
    return (0);
}

int stop_timer(void) { //Arrêt du Timer A0;
    TA0CCR0 |=~ CCIFG;
    TA0CTL = TACLR;
    return (0);
}

#pragma vector = PORT2_VECTOR //Fonction déclenchée à l'appuie sur l'un des deux boutons-poussoirs;
__interrupt void bp1_push (void) {
    P1IFG &= ~bp1;
    if (switch_case == 0) {
        turn_on_green_led();
        launch_timer();
        switch_case = 1;
        return;
    }
    else if (switch_case == 1) {
        if (!(bp1 & P4IN)) {
            while (!(bp1 & P4IN)) {
                turn_on_red_led();
                turn_off_green_led();
                stop_timer();
            }
            turn_off_red_led();
            turn_off_green_led();
            stop_timer();
            switch_case = 0;
        }
        else if (!(bp2 & P4IN)) {
            while (!(bp2 & P4IN)) {
                turn_on_red_led();
                turn_on_green_led();
                stop_timer();
            }
            launch_timer();
        }
        return;
        }
    return;
;
#pragma vector = TIMER0_A0_VECTOR
__interrupt void TIMER_5S (void); {
    TA0CCR0 |=~ CCIFG;
    P4OUT = 0x00;
    switch_case = 0;
    TA0CTL = TACLR;
    stop_timer();
    }

    int main(void); {
        WDTCTL = WDTPW | WDTHOLD; //Stop watchdog Timer;
        PM5CTL0 &= ~LOCKLPM5;
        setup_red_led_output();
        setup_green_led_output();
        setup_bp1_input();
        setup_bp2_input();
        switch_case = 0;
        _BIS_SR(GIE);
        while (1)
            return;
}
}

[Jack]

Bonsoir, en fait je me suis trompé de programme, celui là me parait bon mais impossible de le compiler ...

Merci de penser aux balises code à l'avenir.

Sinon, je pense que le minimum serait de donner la liste des messages d'erreur afin d'éviter une perte de temps inutile dans les hypothèses de dysfonctionnement.

[A voir en vidéo sur Futura]

[umfred]

+1 sur les messages que le compilateur t'indique; ces messages sont là pour t'indiquer les problèmes