#format wiki
#language fr
#acl +All:read


== Présentation ==
Cette page à pour but de répertorier des exemples de code utiles pour les TP (et pour le partiel) de l'UE441 du M1 IST de EEA. Vous pouvez évidement contribuer à cette page mais assurez vous de rajouter du code compréhensible (commentaire, nom de variable explicite etc), fonctionnel, et bien répertorié (cette page à des sections, respectez les).
Un fichier de présentation un peu général à été rédigé par M. Juton et est disponible ici: [[attachment:Creation_projet_MCUXPRESSOIDE.pdf]].

== Documentation ==
Un de vos meilleur amis et de vos pire ennemis lorsque vous programmerez sur les LPC804 est le [[attachment:LPC804_UserManual.pdf]]. Ce monstre de 355 pages regroupe toute les fonctions utiles et toute la documentation nécessaire pour programmer sur la carte. Le problème est que, si on ne l'a jamais fait, lire cette doc est un peu compliqué. Voici un exemple rapide de lecture de ce document pour réaliser une fonction demandée. Dans le sujet0 fourni pour préparer le partiel de cette année, il est demandé de paramétrer un convertisseur analogique/numérique. Pour cela on nous indique le chapitre 22 de la doc. Il faut dans un premier temps alimenter le ADC. Pour cela on suit la doc à partir du paragraphe d'introduction et on trouve qu'il faut aller voir dans le registre {{{LPC_SYSCON->PDRUNCFG}}}. Dans la table indiquée (Table 84), on trouve que pour alimenter le ADC il faut mettre le bit 4 (première colonne sur la ligne ADC_PD) à 0 (Powered). On en déduit qu'il faut utiliser l'instruction
{{{#!highlight C
LPC_SYSCON->PDRUNCFG &= ~(1<<4)
}}}

De même pour toute les fonctions demandées. Tout est dans là donc, il suffit de trouver la bonne page.

== Code de base ==

== LED ==
La LED est l'élément de base pour sortir une info basique sur ce que fait le programme. Comme toutes les entrée/sortie, il faut définir le sens avec la variable {{{DIR0}}}. Pour une LED, il faut la positionner sur sortie (1). Le registre {{{LPC_GPIO_PORT -> DIR0}}} regroupe les directions pour toutes les entrées sortie. Il faut donc faire un OU logique avec la variable {{{blue (1<<11)}}} qui est un 1 décalé de 11 bits, ce qui correspond à la LED Bleu. Pour choisir ensuite l'état de de la led, il faut faire la même opération avec le registre {{{LPC_GPIO_PORT -> PIN0}}}. Le programme ci-dessous permet de faire clignotter la led bleu de la carte à un fréquence proche de 1Hz. Si l'on considère que la fréquence est réellement de 1Hz, il permet aussi de déduire le temps d'une instruction machine élémentaire (en comptant le nombre d'instruction nécessaire pour finir la boucle de temporisation).

{{{#!highlight C
#include <cr_section_macros.h>
#include <LPC8xx.h>
#include <syscon.h>

//bits de GPIO utilises
#define blue (1<<11)

int main(void){
    int cpt;
    LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON GPIO0);
    LPC_GPIO_PORT -> DIR0 |= blue;

	while(1){
		LPC_GPIO_PORT -> PIN0 ^= blue; // OU exclusif pour changé l'état de la LED
		for(cpt=0;cpt<200000;cpt++); // temporisation sale pour attendre a peu près 1s
	}
}
}}}

{{{#!wiki caution
'''Sens et état de la LED'''
Bien que cela fonctionne, il est fortement déconseillé de changer le sens de la sortie correspondant à la LED pour la faire clignoter. Si vous rendez ça comme solution elle sera très probablement considérée comme fausse ou au moins très fortement pénalisée
}}}

== Boutons ==
Lancer des commandes, c'est bien. Mais récupérer un peu d’interactions avec l'utilisateur, c'est mieux ! Le plus simple pour cela est d'utiliser les boutons. La carte de base en comporte 3 (dont un reset qui peut à tout moment "griller" votre carte donc on va dire 2...). Ils sont monté selon un schéma spécial qui fait que tout appuis sur un bouton allume directement la LED associée (basiquement, chaque LED est en série avec un bouton).

L'utilisation des boutons, comme toutes les I/O du GPIO, se fait au travers du registre {{{LPC_GPIO_PORT}}}. 

{{{#!highlight C
#include <cr_section_macros.h>
#include <LPC8xx.h>
#include <syscon.h>

//bits de GPIO utilises
#define button (1<<13)

int main(void){
    int cpt;
    LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON GPIO0);

    while(1){
	if ((LPC_GPio_PORT -> PIN0 & button)==0){ // le bouton est enfoncé
            // Des instructions...
        }
        else{ // il ne l'est pas
            // Encore des instructions...
        }
        // Toujours des instructions...
    }
}
}}}
D'autres boutons sont utilisables avec l'extension de la carte mais il sont définis dans les header fournit avec.

== Timers ==

La carte utilisée possèdent différents timers, le plus utilisé étant le timer standard {{{CTIMER0}}}. son paramétrage (activation, reset, démarrage, division de fréquence...) se fait donc dans le registre {{{LPC_CTIMER0}}}.

=== Diviseur de Fréquence ===

Le compteur principal {{{TC}}} est incrémenté à chaque fois que le prescale counter {{{PC}}} (cadencé à la fréquence d'horloge, ici 12MHz)  atteint la valeur enregistré dans le prescale register {{{PR}}}. En pratique on a au début du main : 

 
{{{#!highlight C
// Préparation des entrées/sorties et périphériques
LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0 | CTIMER0 );
LPC_GPIO_PORT->DIR0 |= (SEG_SDAT|SEG_SCLK|SEG_LCLK); // Afficheur 4*7 segments
LPC_GPIO_PORT->DIR0 |= (LED1|LED2|LED3|LED4); // 4 leds
LPC_CTIMER0->TCR = 1; // Déclenchement du compteur Timer Control Register
LPC_CTIMER0->PR = 12000; // Diviseur de fréquence
}}}

== PWM ==
Pour générer une pwm sur une sortie de la carte, il faut vérifier plusieurs paramètres. Ces paramètres sont détaillés en fin de sujet du TP3.
 * La sélection de l’horloge: par défaut l’horloge CPU.
 * Préscalaire  dans {{{LPC_CTIMER0->PR}}}
 * Période du timer {{{LPC_CTIMER0->MR[3]}}}
 * Demander au timer de reprendre à 0 une fois la période atteinte {{{LPC_CTIMER0->MCR}}}
 * Le temps à l'état bas de la PWM {{{LPC_CTIMER0->MR[1]}}}
 * Placer la sortie en mode PWM {{{LPC_CTIMER0->PWMC}}}
 * Assigner la PWN à la pin voulue (par exemple 19) {{{LPC_SWM->PINASSIGN4}}}

En plus de tout ça il faut évidement allumer le timer {{{ LPC_SYSCON->SYSAHBCLKCTRL0 }}}, activer la pin 19 en mode sortie {{{LPC_GPIO_PORT->DIR0}}} eet lancer le timer {{{LPC_CTIMER0->TCR}}} comme présenté precedement.

Une fois la PWM configurer , il reste à choisir sa forme à l'aide des Shadow Register: {{{LPC_CTIMER0->MSR[3]}}} pour la période et {{{LPC_CTIMER0->MSR[1]}}} pour le temps bas.

Le code suivant permet de faire "battre" une led. C'est un exercice du TP2.

{{{#!highlight C
#include <cr_section_macros.h>
#include "LPC8xx.h"
#include "syscon.h"
#include "Multi_Shield.h"

#define CTIMER (1<<25)

int main(void) {
	// préparation des entrées/sorties et périphériques
	LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0);
	LPC_GPIO_PORT->DIR0 |= (SEG_SDAT|SEG_SCLK|SEG_LCLK); // afficheur 4*7 segments

	// Initialisation du timer principal (Timer Counter)
	LPC_SYSCON->SYSAHBCLKCTRL0 |= CTIMER;	// Activation
	LPC_SYSCON->PRESETCTRL0 &= ~CTIMER;    // Allumer le reset
	LPC_SYSCON->PRESETCTRL0 |= CTIMER;    // Eteindre le reset
        
        // CETTE LIGNE NECESSITE DES COMMENTAIRES
	// Initialisation de la SM
	LPC_SYSCON->SYSAHBCLKCTRL0 |= SWM;		// Activation
	LPC_SWM->PINASSIGN4 = 0xFFFF01FF; 		// Association de MATCH1 et LED1
	LPC_SYSCON->SYSAHBCLKCTRL0 &= ~SWM;		// Extinction de la SM

	LPC_CTIMER0->PR = 469; // réglage du diviseur de fréquence 

        // MCR (Match Control Register) sert à configurer quoi faire quand un des Match Register atteint le Timer Counter
	LPC_CTIMER0->MCR |= 1 << 1;		// Active le reset du Timer Counter quand il match MR[0]
	LPC_CTIMER0->MR[0] = 255; 		// Valeur stocké dans le Match Register 0. Lorsque la valeur du Timer Counter atteindra celle ci, le TC se resetera.

	LPC_CTIMER0->MR[1] = 0; 		// Idem pour le Match Register 1 à priori mais on ne lui à pas assigné d'action. /!\ Cette ligne est possiblement inutile /!\

        // Le PWMC (PWM Controle register) sert à configurer la sortie de la PWN
	LPC_CTIMER0->PWMC = 1 << 1;	// PWMEN1 à 1 enable  PWM for chanel 1

        // TCR (Time Control Register) sert à controller le Timer Counter. On l'allume donc en le réssétant
	LPC_CTIMER0->TCR = 3; // équivalent à (1<<1)|(1<<2), met des 1 sur les deux premiers bits: Enabled et Reset
	LPC_CTIMER0->TCR = 1; // On aurait pu mettre aussi (1<<1) ou encore LPC_CTIMER0->TCR &= ~(1<<2) pour juste enlever le 1 sur le bit de reset

	int largeur = 0; // gestion de la largeur en cours de la PWN
	int sens = 0; // gestion du sens de variation (plus ou moins intense)

        while(1) {
    	     if((LPC_CTIMER0->TC & 0x3F) == 0){
    		if(largeur == 0 || largeur == 255) // si on atteint un extrême, on change de sens
    			sens = !sens;
    		if(sens)
    			largeur = (largeur + 1) % 256; // augmentation de la largeur
    		else
    			largeur = (largeur + 255) % 256; // diminution de la largeur

    		LPC_CTIMER0->MR[1] = largeur; // Assignation de la largeur
    	}

        segments(largeur & 0xFFFF,0);
    }
    return 0 ;
}
}}}
Ce code sert à faire "battre" la LED. C'est l'objet d'une question dans le TP2.

== Ecran LCD ==

L'écran LCD est présente sur les extensions de carte pour le LPC804. Son utilisation est assez simple et il fait l'objet d'une petite partie du TP3 dans laquelle on s’intéresse à l'espace mémoire occupé par la fonction {{{sprintf}}}. De plus , il peut servir d'affichage très rudimentaire pour le debug (si on à pas envie d'utiliser la console de mcuxpresso ni la visualisation des variables).

=== code ===
Voici un code simple d'utilisation de l'écran LCD. D'autres fonctions sont disponibles.
{{{#!highlight C
#include "lib_UE441_lcd.h" // contient les fonctions utiles pour l'utilisation de l'écran

int main(void) {
	char text[32];// contiendra le texte à afficher

	init_lcd();
	lcd_position(0,0); // on positionne le curseur au début (ligne,colonne). 16 colonne sur l'écran.
	sprintf(text,"\O_O/ \O_O/ \O_O/");// formate la chaîne pour l'affichage et le stocke dans text
	lcd_puts(text);// affiche le texte
	lcd_position(1,0);// seconde ligne
	lcd_puts("Second line bitch !");// On est pas obligé d'utiliser la fonction sprintf si le texte est simple
	while(1); // si on attend pas, on verra rien

    return 0 ;
}
}}}

== Interruptions ==

=== Par bouton ===
Le principe des interruptions est que l'on va assigner une pine à un type d’interruption et on va lui donner une priorité. Si l’événement attendu survient (input, timer, etc), une certaine fonction va être appelée et l'on va interrompre le programme principale. Un des intérêt est que les interruptions sont gérées à un niveau plus bas et les sont donc beaucoup plus rapidement prise en compte que si l'on vérifiais l’appui sur un bouton. En contre partie, c'est chiant à coder.

{{{#!highlight C
int main(void) {

	char text[32];
	uint32_t i;

	//Configuration de l'horloge à 15 MHz
	LPC_PWRD_API->set_fro_frequency(30000);

	// Peripheral reset to the GPIO0 and pin interrupt modules. '0' asserts, '1' deasserts reset.
	LPC_SYSCON->PRESETCTRL0 &=  (GPIO0_RST_N & GPIOINT_RST_N);
	LPC_SYSCON->PRESETCTRL0 |= ~(GPIO0_RST_N & GPIOINT_RST_N);

	//Mise en fonctionnement des périphériques utilisés
	LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0 | SWM | CTIMER0 | GPIO_INT);

	//initialisation de l'affichuer lcd avec un affichage
	init_lcd();
	sprintf(text,"Waiting...");
	lcd_gohome();
	lcd_puts(text);

    // Configuration des interruptions sur front descendant des boutons

    // Configure P0.18, P0.19 as pin interrupts 1, 0
    // Make PORT0.18, PORT0.19 outputs driving '0'.
	LPC_GPIO_PORT->DIR0 |= (1<<19)|(1<<17)|(1<<21)|(1<<11);

	// Configure P0.18 - P0.19 as pin interrupts 1 - 0 by writing to the PINTSELs in SYSCON
	LPC_SYSCON->PINTSEL[0] = 13;  // PINTSEL0 is P0.13
	LPC_SYSCON->PINTSEL[1] = 12;  // PINTSEL1 is P0.12

	// Configure the Pin interrupt mode register (a.k.a ISEL) for edge-sensitive on PINTSEL1,0
	LPC_PIN_INT->ISEL = 0x0;

	// Configure the IENR (pin interrupt enable rising) for rising edges on PINTSEL0,1
	//LPC_PIN_INT->IENR = 0x0;

	// Configure the IENF (pin interrupt enable falling) for falling edges on PINTSEL0,1
	LPC_PIN_INT->IENF = 0x3;

	// Clear any pending or left-over interrupt flags
	LPC_PIN_INT->IST = 0xFF;

	// Enable pin interrupts 0 - 1 in the NVIC (see core_cm0plus.h)
	NVIC_EnableIRQ(PININT0_IRQn);
	NVIC_EnableIRQ(PININT1_IRQn);

	// config priority. De base elles sont prioritaires mais on refefinit leurs priorites
	NVIC->IP[6]= (0<<6)|(3<<14);

    while(1) {
    	// affichage du timer sur l'écran LCD
		sprintf(text," %d ",i++);
		lcd_position(1,1);
		lcd_puts(text);
    }
    return 0 ;
}

//fonction interruption 0 GPIO sur front descendant
void PININT0_IRQHandler(void){
        LED1= !LED1;               // Falling edge on PIN INT0, LED off
        LPC_PIN_INT->FALL = 1<<0;       // Clear the interrupt flag
    return;
}

}
}}}


=== Par Timer ===

Voila pour les interruptions par bouton. Mais on peut également faire des interruption par timer comme explicité dans le code suivant:

{{{#!highlight C
#include <cr_section_macros.h>
#include <stdio.h>
#include "LPC8xx.h"
#include "fro.h"
#include "rom_api.h"
#include "syscon.h"
#include "swm.h"
#include "i2c.h"
#include "ctimer.h"
#include "core_cm0plus.h"

#include "lib_UE441_lcd.h"

//periode en ms des notes de la gamme LA440
#define P_DO  3822
#define P_RE  3405
#define P_MI  3033
#define P_FA  2862
#define P_SOL 2550
#define P_LA  2271
#define P_SI  2024
#define P_DOA 1911
int Gamme[8]={P_DO,P_RE,P_MI,P_FA,P_SOL,P_LA,P_SI,P_DOA};

//boutons et leds de la carte
#define BP1 LPC_GPIO_PORT->B0[13]
#define BP2 LPC_GPIO_PORT->B0[12]
#define LED1 LPC_GPIO_PORT->B0[19] //utilisée ici en PWM
#define LED2 LPC_GPIO_PORT->B0[17]
#define LED3 LPC_GPIO_PORT->B0[21]
#define LED4 LPC_GPIO_PORT->B0[11]

volatile int temps=0; // temps actuel qui descend toute les secondes
volatile int total=1; // temps total de seconde que l'on doit compter
volatile int prochain=1; // Prochain nombre de seconde que l'on comptera

int main(void) {
        char text[32]; //text utilisé pour l'afficheur LCD

        //Configuration de l'horloge a 15 MHz
        LPC_PWRD_API->set_fro_frequency(30000);

        // Peripheral reset to the GPIO0 and pin interrupt modules. '0' asserts, '1' deasserts reset.
        LPC_SYSCON->PRESETCTRL0 &=  (GPIO0_RST_N & GPIOINT_RST_N);
        LPC_SYSCON->PRESETCTRL0 |= ~(GPIO0_RST_N & GPIOINT_RST_N);

        //Mise en fonctionnement des peripheriques utilises
        LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0 | SWM | CTIMER0 | GPIO_INT);

        //initialisation de l'affichuer lcd
        init_lcd();

        // Configuration de l'interruption pour le bouton comme precedement
        LPC_GPIO_PORT->DIR0 |= (1<<19)|(1<<17)|(1<<21)|(1<<11);
        LPC_SYSCON->PINTSEL[1] = 12;  // PINTSEL1 is P0.12
        LPC_PIN_INT->ISEL = 0x0;
        LPC_PIN_INT->IENF = 0x3;
        LPC_PIN_INT->IST = 0xFF;
        NVIC_EnableIRQ(PININT1_IRQn);

        // config priority. De base elles sont prioritaires
        NVIC->IP[6]= (0<<6)|(3<<14);

        // configuration du SysTick Timer
        SysTick -> CTRL |= (1<<0); // active le timer
        SysTick -> LOAD = 0xb71aff; // compte a peu pres une seconde
        SysTick -> CTRL |= (1<<1); // active les interruptions par le SysTick
        
        //Affichage du texte de base qui restera sur l'ecran LCD.
        sprintf(text,"Temps: ",temps,total);
        lcd_position(0,0);
        lcd_puts(text);
        sprintf(text,"Prochain: ",temps,total);
        lcd_position(1,0);
        lcd_puts(text);

    while(1) {
        // efface l'espace des infos
        sprintf(text,"         ",prochain);
        lcd_position(0,7);
        lcd_puts(text);
        sprintf(text,"  ",prochain);
        lcd_position(1,10);
        lcd_puts(text);

        // affichage les nouvelles infos
        sprintf(text,"%u sur %u ",temps,total);
        lcd_position(0,8);
        lcd_puts(text);
        sprintf(text,"%u",prochain);
        lcd_position(1,10);
        lcd_puts(text);
    }
    return 0 ;
}

//Interruption du timer
void SysTick_Handler(void){
        temps++; // incremente le nombre de seconde

        if(temps>=total){// on est arrive a la fin du temps
                LED1= !LED1; // la LED change
                temps=0; // le compte revient a 0
                total=prochain; // on prend en compte le prochain temps 
        }
}

//Interruption du bouton
void PININT1_IRQHandler(void){
        prochain=(prochain+1) % 20; //Incrémentation du prochain temps pris en compte
        LPC_PIN_INT->FALL = 1<<1;       // Efface l'interruption
  return;

}

}}}

== Sujet 0 ==
Voici un début de correction du sujet 0 proposé pour préparer le partiel. Gardez un œil très critique avec ce qui est proposé dans ce document. [[attachment:sujet0_Grizzly.pdf]]