1 LPC_SYSCON->PDRUNCFG &= ~(1<<4)

   1 #include <cr_section_macros.h>
   2 #include <LPC8xx.h>
   3 #include <syscon.h>
   4 
   5 //bits de GPIO utilises
   6 #define blue (1<<11)
   7 
   8 int main(void){
   9     int cpt;
  10     LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0);
  11     LPC_GPIO_PORT -> DIR0 |= blue;
  12 
  13         while(1){
  14                 LPC_GPIO_PORT -> PIN0 ^= blue; // OU exclusif pour changer l'état de la LED
  15                 for(cpt=0;cpt<200000;cpt++); // temporisation sale pour attendre à peu près 1s
  16         }
  17 }

   1 #include <cr_section_macros.h>
   2 #include <LPC8xx.h>
   3 #include <syscon.h>
   4 
   5 //bits de GPIO utilises
   6 #define button (1<<13)
   7 
   8 int main(void){
   9     int cpt;
  10     LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0);
  11 
  12     while(1){
  13         if ((LPC_GPIO_PORT -> PIN0 & button)==0){ // le bouton est enfoncé
  14             // Des instructions...
  15         }
  16         else{ // il ne l'est pas
  17             // Encore des instructions...
  18         }
  19         // Toujours des instructions...
  20     }
  21 }

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

   1 #include <cr_section_macros.h>
   2 #include "LPC8xx.h"
   3 #include "syscon.h"
   4 #include "Multi_Shield.h"
   5 
   6 #define CTIMER (1<<25)
   7 
   8 int main(void) {
   9         // préparation des entrées/sorties et périphériques
  10         LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0);
  11         LPC_GPIO_PORT->DIR0 |= (SEG_SDAT|SEG_SCLK|SEG_LCLK); // afficheur 4*7 segments
  12 
  13         // Initialisation du timer principal (Timer Counter)
  14         LPC_SYSCON->SYSAHBCLKCTRL0 |= CTIMER;   // Activation
  15         LPC_SYSCON->PRESETCTRL0 &= ~CTIMER;    // Allumer le reset
  16         LPC_SYSCON->PRESETCTRL0 |= CTIMER;    // Éteindre le reset
  17 
  18         // CETTE LIGNE NECESSITE DES COMMENTAIRES
  19         // Initialisation de la SM
  20         LPC_SYSCON->SYSAHBCLKCTRL0 |= SWM;              // Activation
  21         LPC_SWM->PINASSIGN4 = 0xFFFF01FF;               // Association de MATCH1 et LED1
  22         LPC_SYSCON->SYSAHBCLKCTRL0 &= ~SWM;             // Extinction de la SM
  23 
  24         LPC_CTIMER0->PR = 469; // réglage du diviseur de fréquence
  25 
  26         // MCR (Match Control Register) sert à configurer quoi faire quand un des Match Register atteint le Timer Counter
  27         LPC_CTIMER0->MCR |= 1 << 1;             // Active le reset du Timer Counter quand il match MR[0]
  28         LPC_CTIMER0->MR[0] = 255;               // Valeur stockée dans le Match Register 0. Lorsque la valeur du Timer Counter atteindra celle ci, le TC se resetera.
  29 
  30         LPC_CTIMER0->MR[1] = 0;                 // Idem pour le Match Register 1 à priori mais on ne lui a pas assigné d'action. /!\ Cette ligne est possiblement inutile /!\
  31 
  32         // Le PWMC (PWM Controle register) sert à configurer la sortie de la PWN
  33         LPC_CTIMER0->PWMC = 1 << 1;     // PWMEN1 à 1 enable PWM for chanel 1
  34 
  35         // TCR (Time Control Register) sert à controler le Timer Counter. On l'allume + reset
  36         LPC_CTIMER0->TCR = 3; // équivalent à (1<<1)|(1<<2) (enable: bit 1 , reset: bit 2)
  37         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
  38 
  39         int largeur = 0; // gestion de la largeur en cours de la PWM
  40         int sens = 0; // gestion du sens de variation (plus ou moins intense)
  41 
  42         while(1) {
  43              if((LPC_CTIMER0->TC & 0x3F) == 0){
  44                 if(largeur == 0 || largeur == 255) // si on atteint un extrême, on change de sens
  45                         sens = !sens;
  46                 if(sens)
  47                         largeur = (largeur + 1) % 256; // augmentation de la largeur
  48                 else
  49                         largeur = (largeur + 255) % 256; // diminution de la largeur
  50 
  51                 LPC_CTIMER0->MR[1] = largeur; // Assignation de la largeur
  52         }
  53 
  54         segments(largeur & 0xFFFF,0);
  55     }
  56     return 0 ;
  57 }

   1 #include "lib_UE441_lcd.h" // contient les fonctions utiles pour l'utilisation de l'écran
   2 
   3 int main(void) {
   4         char text[32];// contiendra le texte à afficher
   5 
   6         init_lcd();
   7         lcd_position(0,0); // on positionne le curseur au début (ligne,colonne). 16 colonnes sur l'écran.
   8         sprintf(text,"\O_O/ \O_O/ \O_O/");// formate la chaîne pour l'affichage et la stocke dans text
   9         lcd_puts(text);// affiche le texte
  10         lcd_position(1,0);// seconde ligne
  11         lcd_puts("Second line boss !");// On n'est pas obligé d'utiliser la fonction sprintf si le texte est simple
  12         while(1); // si on attend pas, on verra rien
  13 
  14     return 0 ;
  15 }

   1 int main(void) {
   2 
   3         char text[32];
   4         uint32_t i;
   5 
   6         //Configuration de l'horloge à 15 MHz
   7         LPC_PWRD_API->set_fro_frequency(30000);
   8 
   9         // Peripheral reset to the GPIO0 and pin interrupt modules. '0' asserts, '1' deasserts reset.
  10         LPC_SYSCON->PRESETCTRL0 &=  (GPIO0_RST_N & GPIOINT_RST_N);
  11         LPC_SYSCON->PRESETCTRL0 |= ~(GPIO0_RST_N & GPIOINT_RST_N);
  12 
  13         //Mise en fonctionnement des périphériques utilisés
  14         LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0 | SWM | CTIMER0 | GPIO_INT);
  15 
  16         //initialisation de l'affichuer lcd avec un affichage
  17         init_lcd();
  18         sprintf(text,"Waiting...");
  19         lcd_gohome();
  20         lcd_puts(text);
  21 
  22     // Configuration des interruptions sur front descendant des boutons
  23 
  24     // Configure P0.18, P0.19 as pin interrupts 1, 0
  25     // Make PORT0.18, PORT0.19 outputs driving '0'.
  26         LPC_GPIO_PORT->DIR0 |= (1<<19)|(1<<17)|(1<<21)|(1<<11);
  27 
  28         // Configure P0.18 - P0.19 as pin interrupts 1 - 0 by writing to the PINTSELs in SYSCON
  29         LPC_SYSCON->PINTSEL[0] = 13;  // PINTSEL0 is P0.13
  30         LPC_SYSCON->PINTSEL[1] = 12;  // PINTSEL1 is P0.12
  31 
  32         // Configure the Pin interrupt mode register (a.k.a ISEL) for edge-sensitive on PINTSEL1,0
  33         LPC_PIN_INT->ISEL = 0x0;
  34 
  35         // Configure the IENR (pin interrupt enable rising) for rising edges on PINTSEL0,1
  36         //LPC_PIN_INT->IENR = 0x0;
  37 
  38         // Configure the IENF (pin interrupt enable falling) for falling edges on PINTSEL0,1
  39         LPC_PIN_INT->IENF = 0x3;
  40 
  41         // Clear any pending or left-over interrupt flags
  42         LPC_PIN_INT->IST = 0xFF;
  43 
  44         // Enable pin interrupts 0 - 1 in the NVIC (see core_cm0plus.h)
  45         NVIC_EnableIRQ(PININT0_IRQn);
  46         NVIC_EnableIRQ(PININT1_IRQn);
  47 
  48         // config priority. De base elles sont prioritaires mais on redéfinit leurs priorités
  49         NVIC->IP[6]= (0<<6)|(3<<14);
  50 
  51     while(1) {
  52         // affichage du timer sur l'écran LCD
  53                 sprintf(text," %d ",i++);
  54                 lcd_position(1,1);
  55                 lcd_puts(text);
  56     }
  57     return 0 ;
  58 }
  59 
  60 //fonction interruption 0 GPIO sur front descendant
  61 void PININT0_IRQHandler(void){
  62         LED1= !LED1;               // Falling edge on PIN INT0, LED off
  63         LPC_PIN_INT->FALL = 1<<0;       // Clear the interrupt flag
  64     return;
  65 }
  66 
  67 }

   1 #include <cr_section_macros.h>
   2 #include <stdio.h>
   3 #include "LPC8xx.h"
   4 #include "fro.h"
   5 #include "rom_api.h"
   6 #include "syscon.h"
   7 #include "swm.h"
   8 #include "i2c.h"
   9 #include "ctimer.h"
  10 #include "core_cm0plus.h"
  11 
  12 #include "lib_UE441_lcd.h"
  13 
  14 //periode en ms des notes de la gamme LA440
  15 #define P_DO  3822
  16 #define P_RE  3405
  17 #define P_MI  3033
  18 #define P_FA  2862
  19 #define P_SOL 2550
  20 #define P_LA  2271
  21 #define P_SI  2024
  22 #define P_DOA 1911
  23 int Gamme[8]={P_DO,P_RE,P_MI,P_FA,P_SOL,P_LA,P_SI,P_DOA};
  24 
  25 //boutons et leds de la carte
  26 #define BP1 LPC_GPIO_PORT->B0[13]
  27 #define BP2 LPC_GPIO_PORT->B0[12]
  28 #define LED1 LPC_GPIO_PORT->B0[19] //utilisée ici en PWM
  29 #define LED2 LPC_GPIO_PORT->B0[17]
  30 #define LED3 LPC_GPIO_PORT->B0[21]
  31 #define LED4 LPC_GPIO_PORT->B0[11]
  32 
  33 volatile int temps=0; // temps actuel qui descend toutes les secondes
  34 volatile int total=1; // temps total de secondes que l'on doit compter
  35 volatile int prochain=1; // Prochain nombre de secondes que l'on comptera
  36 
  37 int main(void) {
  38         char text[32]; //text utilisé pour l'afficheur LCD
  39 
  40         //Configuration de l'horloge a 15 MHz
  41         LPC_PWRD_API->set_fro_frequency(30000);
  42 
  43         // Peripheral reset to the GPIO0 and pin interrupt modules. '0' asserts, '1' deasserts reset.
  44         LPC_SYSCON->PRESETCTRL0 &=  (GPIO0_RST_N & GPIOINT_RST_N);
  45         LPC_SYSCON->PRESETCTRL0 |= ~(GPIO0_RST_N & GPIOINT_RST_N);
  46 
  47         //Mise en fonctionnement des peripheriques utilisés
  48         LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0 | SWM | CTIMER0 | GPIO_INT);
  49 
  50         //initialisation de l'affichuer lcd
  51         init_lcd();
  52 
  53         // Configuration de l'interruption pour le bouton comme précédemment
  54         LPC_GPIO_PORT->DIR0 |= (1<<19)|(1<<17)|(1<<21)|(1<<11);
  55         LPC_SYSCON->PINTSEL[1] = 12;  // PINTSEL1 is P0.12
  56         LPC_PIN_INT->ISEL = 0x0;
  57         LPC_PIN_INT->IENF = 0x3;
  58         LPC_PIN_INT->IST = 0xFF;
  59         NVIC_EnableIRQ(PININT1_IRQn);
  60 
  61         // config priority. De base elles sont prioritaires
  62         NVIC->IP[6]= (0<<6)|(3<<14);
  63 
  64         // configuration du SysTick Timer
  65         SysTick -> CTRL |= (1<<0); // active le timer
  66         SysTick -> LOAD = 0xb71aff; // compte à peu près une seconde
  67         SysTick -> CTRL |= (1<<1); // active les interruptions par le SysTick
  68 
  69         //Affichage du texte de base qui restera sur l'ecran LCD.
  70         sprintf(text,"Temps: ",temps,total);
  71         lcd_position(0,0);
  72         lcd_puts(text);
  73         sprintf(text,"Prochain: ",temps,total);
  74         lcd_position(1,0);
  75         lcd_puts(text);
  76 
  77     while(1) {
  78         // efface l'espace des infos
  79         sprintf(text,"         ",prochain);
  80         lcd_position(0,7);
  81         lcd_puts(text);
  82         sprintf(text,"  ",prochain);
  83         lcd_position(1,10);
  84         lcd_puts(text);
  85 
  86         // affichage les nouvelles infos
  87         sprintf(text,"%u sur %u ",temps,total);
  88         lcd_position(0,8);
  89         lcd_puts(text);
  90         sprintf(text,"%u",prochain);
  91         lcd_position(1,10);
  92         lcd_puts(text);
  93     }
  94     return 0 ;
  95 }
  96 
  97 //Interruption du timer
  98 void SysTick_Handler(void){
  99         temps++; // incrémente le nombre de secondes
 100 
 101         if(temps>=total){// on est arrivé à la fin du temps
 102                 LED1= !LED1; // la LED change
 103                 temps=0; // le compte revient a 0
 104                 total=prochain; // on prend en compte le prochain temps
 105         }
 106 }
 107 
 108 //Interruption du bouton
 109 void PININT1_IRQHandler(void){
 110         prochain=(prochain+1) % 20; //Incrémentation du prochain temps pris en compte
 111         LPC_PIN_INT->FALL = 1<<1;       // Efface l'interruption
 112   return;
 113 
 114 }

   1 #include "LPC8xx.h"
   2 #include <cr_section_macros.h>
   3 #include "syscon.h"
   4 #include "swm.h"
   5 #include "utilities.h"
   6 #include "uart.h"
   7 #include "chip_setup.h"
   8 #include "lib_UE441_lcd.h"
   9 
  10 // Boutons:
  11 #define BP1 (1<<13)
  12 // LED:
  13 #define blue (1<<11)
  14 
  15 
  16 void envoyer(char lettre){
  17         // on commence par attendre que la liaison soit libre
  18         while((LPC_USART0->STAT & TXRDY) == 0);
  19         // Le registre est maintenant disponible
  20         LPC_USART0->TXDAT  = lettre;
  21         // on ecrit notre lettre dedans et le LPC804 fait le reste
  22         return;
  23 
  24 }
  25 
  26 
  27 //
  28 // Main routine
  29 //
  30 
  31 int passe = 1; // garde la valeure precedente du bouton
  32 int lettre = 'b';
  33 
  34 char text[32];
  35 
  36 
  37 
  38 
  39 int main(void) {
  40   // Enable clocks to relevant peripherals
  41   LPC_SYSCON->SYSAHBCLKCTRL0 |= (UART0 | SWM);
  42   LPC_SYSCON->SYSAHBCLKCTRL0 |= (IOCON | GPIO0);
  43 
  44   // Connect UART0 TXD, RXD signals to port pins
  45   ConfigSWM(U0_TXD, DBGTXPIN);
  46   ConfigSWM(U0_RXD, DBGRXPIN);
  47 
  48   // Select frg0clk as the source for fclk0 (to UART0)
  49   LPC_SYSCON->UART0CLKSEL = FRGCLKSEL_MAIN_CLK;
  50 
  51   // Give USART0 a reset
  52   LPC_SYSCON->PRESETCTRL0 &= (UART0_RST_N);
  53   LPC_SYSCON->PRESETCTRL0 |= ~(UART0_RST_N);
  54 
  55   // le registre BRG contient la valeure par laquelle diviser l'horloge pour obtenir la bonne fréquence en
  56   // fonction du baud rate voulue. La fréquence de base est 12Mhz donc on divise par 104 pour avoir 115384
  57   LPC_USART0->OSR = 4;
  58   LPC_USART0->BRG = 20;
  59 
  60   // Configure the USART0 CFG register:
  61   // 8 data bits, no parity, one stop bit, no flow control, asynchronous mode
  62   // mode par défaut pour le minicom sur debian
  63   LPC_USART0->CFG = DATA_LENG_8|PARITY_NONE|STOP_BIT_1;
  64 
  65   // Configure the USART0 CTL register (nothing to be done here)
  66   // No continuous break, no address detect, no Tx disable, no CC, no CLRCC
  67   LPC_USART0->CTL = 0;
  68 
  69   // Clear any pending flags, just in case
  70   LPC_USART0->STAT = 0xFFFF;
  71 
  72   // Enable USART0
  73   LPC_USART0->CFG |= UART_EN;
  74 
  75   // Enable the USART0 RX Ready Interrupt
  76 //  LPC_USART0->INTENSET = RXRDY;
  77 //  NVIC_EnableIRQ(UART0_IRQn);
  78 
  79   // initialisation du LCD et positionement au début.
  80   init_lcd();
  81   lcd_position(0,0);
  82 
  83   while(1){
  84     // gestion du bouton
  85     if ((LPC_GPIO_PORT -> PIN0 & BP1) != passe){ // le bouton change d'etat
  86         passe = LPC_GPIO_PORT -> PIN0 & BP1;
  87         if(passe==0){
  88                 // envoyer 'B'
  89                 envoyer('B');
  90         }
  91         else{
  92                 //envoyer 'b'
  93                 envoyer('b');
  94         }
  95 
  96     }
  97     // stocke la valeure précédente pour détecter les fronts
  98     passe = LPC_GPIO_PORT -> PIN0 & BP1;
  99 
 100 
 101     // Detection de la récéption d'une trame
 102     if ((LPC_USART0->STAT & RXRDY) == 1){
 103         // on a reçu un octet
 104         lettre = LPC_USART0->RXDAT; // on le stocke dans lettre
 105         envoyer(lettre);// renvoit la lettre
 106 
 107         text[0]=(int)lettre;// place la lettre dans un mot
 108         lcd_puts(text);// affiche le mot à la suite sur l'afficheur
 109 
 110         // si la trame représente un appui sur la touche retour:
 111         // on efface tout l'ecran et on se place au debut
 112         if (lettre == '\b'){
 113                 lcd_position(0,0);
 114                 lcd_puts("                ");
 115                 lcd_position(1,0);
 116                 lcd_puts("                ");
 117                 lcd_position(0,0);
 118         }
 119 
 120         // si la trame represente un appui sur la touche entre
 121         // on se place en debut de seconde ligne
 122         if (lettre == 13){
 123                         lcd_position(1,0);
 124                 }
 125     }
 126   };
 127 } // end of main
 128