Truth Machine en embed C

/*
 * 06/06/2021
 *******************
 * Auteur: Wistaro *
 * Wistaro#9487    *
 *******************
 *
 * Implémentation d'un "Truth Machine" en c sur embarqué
 *
 * Principe:
 * - Si l'utilisateur rentre "0", alors le programme affiche "0" sur la sortie (ici, la liaison série)
 * - Si l'utilisateur rentre "1", alors le programme affiche des "1" de manière infinie
 *
 * Contraintes:
 * - Ne PAS UTILISER de boucles "For", "While", "Goto" et "Do-While" pour le traitement
 * - Ne PAS UTILISER des conditions "If", "Switch-Case" et ternaires
 *
 * Board: Texas Instruments MSP432P401R
 * Compiler: TI v20.2.5 LTS
 * IDE: Code Composer Studio v10.3.1
 *
 * Démonstration en vidéo: https://www.youtube.com/watch?v=Onrtpy0hs_4
 */

#include <ti/devices/msp432p4xx/driverlib/driverlib.h>

void sendData(char data);
void sendIntro(void);
char isOneReceived(char data);
char isZeroReceived(char rData);

#define GET_COUNT(T) T*(CS_12MHZ / 16) //calcul pour déterminer le nombre de comptages pour 1s
#define TIME_COUNT GET_COUNT(0.1) //1 dixieme de seconde

#define OFFSET_ASCII 0x30
#define TIMER_NOT_COUNTING -1

char isZero;
char isOne;

const eUSCI_UART_ConfigV1 uartConfig =
{
        EUSCI_A_UART_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source (128kHz pour la clock de référence)
        78,                                     // BRDIV = 78
        2,                                       // UCxBRF = 2
        0,                                       // UCxBRS = 0
        EUSCI_A_UART_NO_PARITY,                  // No Parity
        EUSCI_A_UART_LSB_FIRST,                  // LSB First
        EUSCI_A_UART_ONE_STOP_BIT,               // One stop bit
        EUSCI_A_UART_MODE,                       // UART mode
        EUSCI_A_UART_OVERSAMPLING_BAUDRATE_GENERATION,  // Oversampling
        EUSCI_A_UART_8_BIT_LEN                  // 8 bits de donnée
};

int main(void){

    MAP_WDT_A_holdTimer(); //empêche le watchdog de continuer
    CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_12); //sélection de la clock à 12Mhz

    //Configure une led pour le debug
    P1->DIR |= BIT0;
    P1->OUT &= ~BIT0;

    /*Configure le timer1 sur 32 bits, avec un prescaler de 16, en mode périodique, et basé sur l'horloge MCLK*/
    MAP_Timer32_initModule(TIMER32_BASE, TIMER32_PRESCALER_16, TIMER32_32BIT, TIMER32_PERIODIC_MODE);
    MAP_Interrupt_enableInterrupt(INT_T32_INT1); //active les interruptions sur le timer

    TIMER32_1->LOAD= TIMER_NOT_COUNTING; //désactive compteur au démarrage

    MAP_Timer32_startTimer(TIMER32_BASE, true);

    /*Configure l'UART pour la liaison série*/
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN2 | GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);

    MAP_UART_initModule(EUSCI_A0_BASE, &uartConfig); //initialise l'uART
    MAP_UART_enableModule(EUSCI_A0_BASE); //active le module UART
    MAP_UART_enableInterrupt(EUSCI_A0_BASE, EUSCI_A_UART_RECEIVE_INTERRUPT);
    MAP_Interrupt_enableInterrupt(INT_EUSCIA0);

    MAP_Interrupt_enableMaster(); //active les interruptions générales

    sendIntro();

    isZero = 0;
    isOne = 0;

    while(1) MAP_PCM_gotoLPM0(); //empêche la mise en veille du MCU

}


/* Fonction d'interruption de l'UART de reception */
void EUSCIA0_IRQHandler(void)
{
    uint32_t status = MAP_UART_getEnabledInterruptStatus(EUSCI_A0_BASE);

    while(!(status & EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG)); //attente du flag de transmission

    isZero = isZeroReceived((char)MAP_UART_receiveData(EUSCI_A0_BASE));
    isOne = isOneReceived((char)MAP_UART_receiveData(EUSCI_A0_BASE));

    TIMER32_1->LOAD= TIMER_NOT_COUNTING + (isZero | isOne);
}

/* Envoi un octet sur la liaison série */
void sendData(char data){

    uint32_t status = MAP_UART_getEnabledInterruptStatus(EUSCI_A0_BASE);

    while((status & EUSCI_A_UART_TRANSMIT_INTERRUPT_FLAG)); //attente du flag de transmission

    MAP_UART_transmitData(EUSCI_A0_BASE, data);

}

/* Envoi "?>" sur la liaison série */
void sendIntro(void){
    sendData('\n');
    sendData('\n');
    sendData('?');
    sendData('>');
    sendData(' ');
}

/* Fonction d'interruption du TIMER1 */
void T32_INT1_IRQHandler(void)
{
    MAP_Timer32_clearInterruptFlag(TIMER32_BASE);
    MAP_GPIO_toggleOutputOnPin(GPIO_PORT_P1, GPIO_PIN0);

    TIMER32_1->LOAD= TIMER_NOT_COUNTING + isOne*TIME_COUNT;

    sendData((1-isZero)+OFFSET_ASCII); //envoi "0" ou "1" suivant ce qu'à saisi l'utilisateur
}

/*
 * Input: valeur ascii lue depuis l'uart
 * Ouput: 0x01 si l'entrée est '1', 0x0 sinon
 *
 * */
char isOneReceived(char rData){

    return (char)(((rData&(1<<5))>>5) + ((rData&(1<<4))>>4) + ((rData&(1<<0))>>0) + (1-((rData&(1<<1))>>1)) + (1-((rData&(1<<2))>>2)) + (1-((rData&(1<<3))>>3)) )/6;
}

/*
 * Input: valeur ascii lue depuis l'uart
 * Ouput: 0x01 si l'entrée est '0', 0x0 sinon
 *
 * */
char isZeroReceived(char rData){

    return (char)( (1-((rData&(1<<0))>>0)) +  (1-((rData&(1<<1))>>1)) + (1-((rData&(1<<2))>>2)) + (1-((rData&(1<<3))>>3)) + ((rData&(1<<4))>>4) + ((rData&(1<<5))>>5)  )/6;
}