Programmation GPIO par adressage des registres (HW)
RCC ( Reset ClockControl)
-Le contrôleur de la circuiterie de
Reset est d’horloge.
-Permet de synchroniser les trois bus
du Cortex-M4 (AHB, APB1 et
APB2) avec le bus interne du système
le bus matrix.
-Les GPIOx sont montés sur le bus
AHB1.
-GPIOx x :A..I (9 GPIO)
xAHB1_RSTR
-Ce registre permet de remettre à
l’état initial le périphérique à utiliser
par une écriture de 1.
-Suite à cette écriture de 1, il faut
écrire 0 pour que le périphérique
sorte de son état de reset.
-1 bit pour chaque GPIO
xAHB1_ENR
-Peripheral clock enable register
-1 bit pour chaque GPIO
xMODREG
-Registre utilisé pour sélectionner la
direction (Entrée ou Sortie), Fonction
alternée et analogique (input [0,0],
output [0,1], AF, analog)
-2 bits pour chaque pine.
xOTYPE
-Registre utilisé pour sélectionner le
type de sortie PP(pushpull ) ou OD
(open-drain)
-1 bits pour chaque pine.
xSPEED
-Registre utilisé pour sélectionner la
vitesse quel que soit la direction I/O
-2 bits pour chaque pine.
xPUPDR
-Registre utilisé pour la sélection du
mode PU ou PD (pull-up/pull-down)
quelque soit la direction I/O
-2 bits pour chaque pine.
xIDR
-Récupérer les données entrantes du
port x, accédé en lecture seule
-1 bits pour chaque pine
xODR
Envoyer les données en sorties du
port x, accédé en écriture et en lecture
-1 bits pour chaque pine
Exemple
volatile unsigned int * DAHB1_ENR=(unsigned int *) 0x40023830;
volatile unsigned int * DAHB1_RSTR=(unsigned int *)
0x40023810;
volatile unsigned int * DMODREG=(unsigned int *) 0x40020C00;
volatile unsigned int * DOTYPE=(unsigned int *) 0x40020C04;
volatile unsigned int * DSPEED=(unsigned int *) 0x40020C08;
volatile unsigned int * DPUPDR=(unsigned int *) 0x40020C0C;
volatile unsigned int * DODR =(unsigned int *) 0x40020C14;
volatile unsigned int * AIDR =(unsigned int *) 0X40020010;
volatile unsigned int * AMODREG=(unsigned int *) 0x40020000;
volatile unsigned int * APUPDR=(unsigned int *) 0x4002000C;
void tempo(unsigned int cnt)
{for(;cnt>0;cnt--);}
int main() {
* DAHB1_RSTR |=0XFFFFFFF9; //intialisation de GPIOD
*DAHB1_RSTR&=0XFFFFFFF0;//DESACTIVATION DE RESET
*DAHB1_ENR|=0XFFFFFFF9; //ACTIVATION DE GPTOD //LES
PIN 12,13,14,15 SONT DES OUTPUT
*DMODREG &=0X55FFFFFF;
*DMODREG |=0X55000000;
*AMODREG &=0XFFFFFFFC;
GPIOD SONT EN MODE PUSH PULL
*DOTYPE &=0XFFFF0FFF;
*DSPEED &=0XAAFFFFFF;
*DSPEED |=0XAA000000;
*DPUPDR &=0X55FFFFFF;
*DPUPDR |=0X55000000;
*APUPDR &=0XFFFFFFFC;
while(1){
if (*AIDR &= 0X1) {
if ((*DODR & 0X3000)== 0X3000)
{ *DODR |=0XFFFFCFFF; //LED3 &LED4
*DODR &=0X0000C000;
tempo(0Xffff); }
else
{ *DODR |=0XFFFF3FFF; //LED1 &LED2
*DODR &=0X00003000;
tempo(0Xffff); }
}}}}
Calcul des addresses
Exemples :
GPIOC_ODR = GPIOC_BASE + OFSET_ODR
GPIOH_PUPDR = GPIOC_BASE + OFSET_ PUPDR
@ RCC_AHB1ENR = @base_RCC+ @offset AHB1ENR
GPIOD @BASE=0x40020C00 GPIOA @BASE 0X40020000
JEBRI Mejdi
 Programmation GPIO en utilisant la bibliothéque (CMSIS)
typedefstruct{
__IO uint32_t MODER; /* Addressoffset: 0x00 */
__IO uint32_t OTYPER; /* Addressoffset: 0x04 */
__IO uint32_t OSPEEDR; /* Addressoffset: 0x08 */
__IO uint32_t PUPDR; /* Addressoffset: 0x0C */
__IO uint32_t IDR; /* Addressoffset: 0x10 */
__IO uint32_t ODR; /* Addressoffset: 0x14 */
__IO uint32_t BSRR; /* Addressoffset: 0x18 */
……
} GPIO_TypeDef;
GPIOx est un pointeur sur la structure GPIO_TypeDef.
L’accès au champ IDR (ou autre) de la structure se fait comme suit:
(*GPIOx).IDR ou encore GPIOx->IDR en utilisant l’écriture simplifiée.
#include "stm32f4xx.h"
void tempo(unsigned int cnt)
{ for(;cnt>0;cnt--); }
int main() {
RCC->AHB1ENR |=0XFFFFFFF9; //initialisation de GPIOD
RCC->AHB1RSTR&=0XFFFFFFF0; //DESACTIVATION DE RESET
RCC->AHB1ENR|=0XFFFFFFF9; //ACTIVATION DE GPTOD
//LES PIN 12,13,14,15 SONT DES OUTPUT
GPIOD->MODER &=0X55FFFFFF;
GPIOD->MODER |=0X55000000;
GPIOA->MODER &=0XFFFFFFFC; //PIN 0 DE GPIOA INPUT
/*OTYPE IS PUSH_PULL,,LES PIN(12,13,14,15) DE GPIOD SONT EN MODE PUSH PULL*/
GPIOA->OTYPER &=0XFFFF0FFF; //FREQUENCE=25MHZ
GPIOD->OSPEEDR &=0XAAFFFFFF;
GPIOD->OSPEEDR |=0XAA000000;
GPIOD->PUPDR &=0X55FFFFFF; //LES OUTPUT EN MODE PULL_UP
GPIOD->PUPDR |=0X55000000;
GPIOA->PUPDR &=0XFFFFFFFC; //INPUT

while(1)
{
if (GPIOA->IDR &= 0X1)
{
if ((GPIOD->ODR & 0X3000)== 0X3000)
{ GPIOD->ODR |=0XFFFFCFFF; //LED3 &LED4
GPIOD->ODR &=0X0000C000;
tempo(0Xffffff);
}
else {
{ GPIOD->ODR |=0XFFFF3FFF; //LED1 &LED2
GPIOD->ODR &=0X00003000;
tempo(0Xffffff);
}}}}

JEBRI Mejdi
 Programmation GPIO par HAL
HAL_GPIO_Init() Exemple 4 LED permutes 2 par 2 à chaque excitation par bouton
Typedef struct{ #include "stm32f4xx_hal.h"
uint32_t Pin; void tempo(volatile unsigned int CNT){
uint32_t Mode; for (; CNT > 0 ;CNT --); }
uint32_t Pull; int main(void) {
uint32_t Speed; uint32_t B;
uint32_t Alternate; GPIO_InitTypeDef ma_structure ;
} GPIO_Init TypeDef; GPIO_InitTypeDef Ima_structure ;
HAL_GPIO_DeInit() __HAL_RCC_GPIOD_FORCE_RESET();
Void HAL_GPIO_DeInit ( __HAL_RCC_GPIOD_RELEASE_RESET();
GPIO_TypeDef *GPIOx ; __HAL_RCC_GPIOD_CLK_ENABLE();
uint32_t GPIO_Pin ) __HAL_RCC_GPIOA_FORCE_RESET();
HAL_GPIO_ReadPin() __HAL_RCC_GPIOA_RELEASE_RESET();
GPIO_PinStat HAL_GPIO_ReadPin( __HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_TypeDef* GPIOx; ma_structure.Pin = GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 |
uint16_t GPIO_Pin) GPIO_PIN_15;
typedefenum ma_structure.Mode = GPIO_MODE_OUTPUT_PP;
{ ma_structure.Pull = GPIO_NOPULL;
GPIO_PIN_RESET = 0, ma_structure.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_PIN_SET HAL_GPIO_Init(GPIOD, &ma_structure);
}GPIO_PinState ; Ima_structure.Pin = GPIO_PIN_0;
Ima_structure.Mode = GPIO_MODE_INPUT;
HAL_GPIO_WritePin() Ima_structure.Pull = GPIO_NOPULL;
Void HAL_GPIO_WritePin ( HAL_GPIO_Init(GPIOA, &Ima_structure);
GPIO_TypeDef* GPIOx ; B=0;
uint16_t GPIO_Pin ; while(1){
GPIO_PinState PinState ) if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)){
HAL_GPIO_TogglePin() if (B){
Void HAL_GPIO_TogglePin( HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12 |
GPIO_TypeDef* GPIOx ; GPIO_PIN_13 , GPIO_PIN_SET);
uint16_t GPIO_Pin ) HAL_GPIO_WritePin(GPIOD,GPIO_PIN_14 |
{ GPIOx->ODR ^= GPIO_Pin ; } GPIO_PIN_15 , GPIO_PIN_RESET);
tempo(0xfffff);}
Chaque broche (PINE) peut être
else {
configurée en mode input, output,
HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12 |
analog,EXTI, EVENT.
Lorsque le mode EXTI est utilisé: GPIO_PIN_13 , GPIO_PIN_RESET);
–L’utilisateur doit appeler la fonction HAL_GPIO_WritePin(GPIOD,GPIO_PIN_14 |
GPIO_PIN_15 , GPIO_PIN_SET);
HAL_GPIO_EXTI_IRQHandler()
tempo(0xfffff); }
dans le fichier stm32f4xx_it.c
B=~B;
–L’utilisateur doit implémenter la
fonctionHAL_GPIO_EXTI_Callback() }}}

JEBRI Mejdi
 Programmation de l’interruption avec EXTI en HAL
Exemple d'interruption en EXTI
void ConfigEXTI(void)
{
/*Enable clock du GPIOD*/
__HAL_RCC_GPIOD_FORCE_RESET();
__HAL_RCC_GPIOD_RELEASE_RESET();
__HAL_RCC_GPIOD_CLK_ENABLE();
/*Configure GPIO pin : PA0,PA1,PA2,PA3 */
GPIO_InitTypeDef str;
str.Pin = GPIO_PIN_0;
str.Mode = GPIO_MODE_IT_RISING; // front montant
str.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &str);
/*Initialisation de l’interruption en EXTI*/
/*definir les 4 bit de priority en PreemptPriority, 0 bit pour SubPriority*/
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
/*definir l'ordre de chaque priorité, celui qui a le poids le plus faible est celui qui est le plus prioritaire*/
HAL_NVIC_SetPriority(EXTI0_IRQn, 1, 0);
HAL_NVIC_SetPriority(EXTI1_IRQn, 1, 0);
HAL_NVIC_SetPriority(EXTI2_IRQn, 1, 0);
HAL_NVIC_SetPriority(EXTI3_IRQn, 1, 0);
/*activation du NVIC de chaque interruption*/
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
HAL_NVIC_EnableIRQ(EXTI1_IRQn);
HAL_NVIC_EnableIRQ(EXTI2_IRQn);
HAL_NVIC_EnableIRQ(EXTI3_IRQn);
}
/*corps de l'interruption*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET) ;
Delay_us(500000); // fonction defini dans l'exercice
switch (GPIO_Pin) { //par defaut GPIO_Pin prend la pine qui a déclencher l'interruption
/*variable defini dans le corps du programme de l'exercice, char Message(10);*/
case GPIO_PIN_0:strcopy(Message,"B4 Active");Break;
case GPIO_PIN_1:strcopy(Message,"B1 Active");Break;
case GPIO_PIN_2:strcopy(Message,"B2 Active");Break;
case GPIO_PIN_3:strcopy(Message,"B3 Active");Break; }
for (i=0;i<strlen(Message);i++)
{LCD_ecrire.octet(Donnee,Message[i])// fonction défini dans l'exercice
}}

JEBRI Mejdi