lundi 18 janvier 2016

Play Audio Sound Using STM32

Bonjour, Aujourd'hui comme il est indiqué au titre de cet article je vais essayer de produire une strophe musicale en utilisant la carte STM 32 F4 et un buzzer ou un speaker.





Commençons par définir le son :
Le son, c’est avant tout une vibration. Il faut que quelque chose bouge pour qu’un son soit produit. Par exemple, tu peux sonner une cloche, taper des mains ou pincer les cordes d’une guitare pour produire des vibrations qui vont générer des ondes sonores. Les vibrations voyagent d’un endroit à l’autre dans l’air sous forme d’ondes sonores.

Si les vibrations atteignent ton oreille, celle-ci va envoyer un signal à ton cerveau et tu vas entendre le son.
Résultat de recherche d'images pour "notes musique png"




Mais si vous adore le physique vous pouvez lire ce que j'ai trouvez dans un article trés intéressent sur le son au dessous sinon vous passer directement au test avec l'STM32




   
un son est une vibration de l'air. On peut en faire une représentation graphique avec en abscisse le temps et en ordonnée l'amplitude de la vibration : une onde plus grande aura un volume plus élevé, une courbe "tassée" en largeur représente un son aigu. Car c'est la fréquence de la vibration qui déterminera la hauteur de la tonalité. L'unité de mesure des fréquences est le hertz : 1 hertz correspond à une oscillation par seconde. Comme on le verra, nombre de paramètres concernant le son se mesurent en hertz, mais ne s'appliquent pas aux mêmes choses. Le la du diapason (ou de la tonalité du téléphone) a une fréquence de 440 Hz (la fréquence des notes de musique suit une augmentation logarithmique, le doublement d'une fréquence passe la note à l'octave supérieure). Bien que l'acuité auditive varie d'une personne à l'autre, il est généralement admis que l'oreille humaine est capable de percevoir des fréquences comprises entre 20 Hz et 20.000 Hz, avec une perte dans les aigus à mesure que l'on vieillit.

Une vidéo d'un haut parleur diffuse une fréquence de 120 Hz dont les vibrations font danser ce liquide non-newtonien



Alors on peut conclure que le son en faite électroniquement est une combinaison entre un fréquence et son delay d'ou on va se baser a créer notre programme suivant.
Résultat de recherche d'images pour "stm32f4"   Résultat de recherche d'images pour "buzzer"                     Résultat de recherche d'images pour "stm32f4"      Résultat de recherche d'images pour "buzzer"
J'ai basée sur Mikro c for ARM comme toujours, pour le brochage y a rien de spécial vous pouvez même comprendre ce qu'il faut faire par les commentaires équipées sur le programme,
 Alors si vous avez un buzeur ou un petit speaker apporter le et relier sa borne positive au PIN PE14 d'STM 32 et sa masse au masse d'STM32 et compiler ce programme au dessous et vous voyez la résultat.

      



  


Programme 
// Let's Electronic by Aymen Lachkhem
// How to play Audio Sound with STM32 F4
//www.letselectronic.blogspot.com


void Tone1() {
  Sound_Play(659, 250);   // Frequency = 659Hz, duration = 250ms
}

void Tone2() {
  Sound_Play(698, 250);   // Frequency = 698Hz, duration = 250ms
}

void Tone3() {
  Sound_Play(784, 250);   // Frequency = 784Hz, duration = 250ms
}

void Melody() {           // Plays the melody from tones 1,2 and 3
  Tone1(); 
  Tone2(); 
  Tone3(); 
  Tone3();
  Tone1(); 
  Tone2(); 
  Tone3(); 
  Tone3();
  Tone1(); 
  Tone2(); 
  Tone3();
  Tone1(); 
  Tone2(); 
  Tone3(); 
  Tone3();
  Tone1(); 
  Tone2(); 
  Tone3();
  Tone3(); 
  Tone3(); 
  Tone2(); 
  Tone2(); 
  Tone1();
}

void main() {

  Sound_Init(&GPIOE_ODR, 14);         // the sound output  PE14
  Sound_Play(880, 1000);            // Play sound at 880Hz for 1 second

  Melody();                         //play the Melody that's we maked using Tones;

  while (1) { }    // Do Nothing

}


    Voici une démonstration vidéo de fonctionnement :




   Have Fun :)

dimanche 17 janvier 2016

Interfacing Servo-Motor With STM32


Interfacing Servo-Motor With STM32



Bonjour, Aujourd'hui on va discuter le fonctionnent du servo moteur en essayant de le contrôler avec un STM32F4, contrôler veut dire contrôler quelle angle il la tourne vers. donc Commençons par une petite définition d'un servomoteur.

Un servomoteur est un système motorisé capable d'atteindre des positions prédéterminées, puis de les maintenir. La position est : dans le cas d’un moteur rotatif, une valeur d'angle et, dans le cas d’un moteur linéaire une distance. On utilise des moteurs électriques (continu, asynchrone, brushless) aussi bien que des moteurs hydrauliques. Le démarrage et la conservation de la position prédéterminée sont commandés par un système de réglage.     

Mais savez vous que la commande de servo-moteur est pas totalement comme le moteur dc genre on l'alimente alors il tourne ? savez vous que chaque servo-moteur a sa propre méthode de commande et de fonctionnement ?
On peut tout être d'accord que chaque servo moteur il fonctionne avec un signal PWM pulse with modulation que j'ai déjà définit sur cet article PWM. Mais il faut bien comprendre que chaque servo a sa propre façon de commande qu'on peut seulement la comprendre sur son fichier technique.

Alors pour comprendre le fonctionnement de chaque un, on qu'aller a sa fichier technique et lire exactement le pulse associer a chaque angle par rapport au période cyclique qu'il a chaque un . citons cette exemple 

les servomoteurs sont commander par les envoyer des pulsations. Ici le servo doit recevoir chaque 20 ms une pulsation ou le longueur de cette dernière va indiquer a quelle angle exactement il doit tourner notre servomoteur. 

Voila cette exemple:
  • si a chaque 20 ms j'envoi une pulsation de longueur 1 ms le servo va tourner vers 0 degré 
  • si a chaque 20 ms j'envoi une pulsation de 1.5 ms le servo va tourner précisément vers 90 degré
  • ......


D'ici on peut conclure la méthode de la quelle le servo on doit le commander avec notre microcontrôleur, une seule sortie numérique est capable de le commander si je la met on niveau haut pendant la période ou pulsation est active et je la met en niveau bas pendant le reste de la période (20ms - pulsation).

Aujourd'hui je vais commander ce servomoteur via une carte STM32 F4
Résultat de recherche d'images pour "servomoteurs"
on se référant de sa fichier technique j'ai écris le programme suivant:




//Let's electronic By Aymen Lachkhem
// Interfacing Servo-motor to STM32
// Letselectronic.blogspot.com
void servoRotate0() //0 Degree
{
  unsigned int i;
  for(i=0;i<50;i++)
  {
    gpiob_odr.f3 = 1;
    Delay_us(1000);
    gpiob_odr.f3 = 0;
    Delay_us(19000);
  }
}
     void servoRotate90() //90 Degree
{
  unsigned int i;
  for(i=0;i<50;i++)
  {
    gpiob_odr.f3 = 1;
    Delay_us(2500);
    gpiob_odr.f3 = 0;
    Delay_us(17500);
  }
}
     void servoRotate180() //180 Degree
{
  unsigned int i;
  for(i=0;i<50;i++)
  {
    gpiob_odr.f3 = 1;
    Delay_us(4400);
    gpiob_odr.f3 = 0;
    Delay_us(16000);
  }
}
void main(){


GPIO_Digital_Output(&GPIOB_ODR, _GPIO_PINMASK_3);     // configuration of pb3 as Digital Output
GPIO_Digital_Input (&GPIOA_BASE, _GPIO_PINMASK_3 | _GPIO_PINMASK_4 | _GPIO_PINMASK_5); // configure PORTA pins as speed control input
  while (1) {
     if (GPIOA_IDR.B3) {
    servoRotate0(); //0 Degree
    Delay_ms(2000);}
     if (GPIOA_IDR.B4) {
    servoRotate90(); //90 Degree
    Delay_ms(2000);}
     if (GPIOA_IDR.B5) {
    servoRotate180(); //180 Degree
    Delay_ms(2000);}
  }
}


Il est tout indiquer au commentaire de programme a propos la configuration, le principe est totalement simple ou j'aurai 3 entrées numériques que je vais utiliser comme des boutons poussoires qui vont forcer le servo moteur relier au  sortie numérique a tournée vers une angle bien précise comme il est citer au vidéo au dessous 


Une démonstration vidéo qui résume tout le travail fait.



   




samedi 16 janvier 2016

Speed Motor's Variator Using STM32

Speed Motor's Variator Using STM32


Résultat de recherche d'images pour "stm32 motor"


La variation de vitesse de moteur a courant continu dans cet article est basée sur le protocole PWM qu'on peut le définir comme ceci :


PWM

La modulation de largeur d'impulsions (MLI ; en anglais : Pulse Width Modulation, soit PWM), est une technique couramment utilisée pour synthétiser des signaux continus à l'aide de circuits à fonctionnement tout ou rien, ou plus généralement à états discrets.
Le principe général est qu'en appliquant une succession d'états discrets pendant des durées bien choisies, on peut obtenir en moyenne sur une certaine durée n'importe quelle valeur intermédiaire.
Résultat de recherche d'images pour "pwm mli definition"
Ce phénomène est fortement recommandé pour assurer la variation de vitesse de moteur a courant continu, aujourd'hui je vais vous démontrer comment on peut générer un signal PWM déune STM32 et visualiser son présence sur des diodes LEDs.

Voici un exemple de comment on genere un signal PWM using Mikro C for ARM et STM32F4:
//Let's Electronic By Aymen Lachkhem
// www.letselectronic.blogspot.com
// Hello in this tutoriel we are going to use 4 buttons (digital Input), the first two will increase and decrease the current duty for the
// first Led and the second two will make the same thing with the other Led.
unsigned int current_duty, old_duty, current_duty1, old_duty1;
unsigned int pwm_period1, pwm_period2;

void InitMain() {
  GPIO_Digital_Input (&GPIOA_BASE, _GPIO_PINMASK_3 | _GPIO_PINMASK_4 | _GPIO_PINMASK_5 | _GPIO_PINMASK_6); // configure PORTA pins as input
}

void main() {
  InitMain();
  current_duty  = 100;                        // initial value for current_duty
  current_duty1 = 100;                        // initial value for current_duty1

  pwm_period1 = PWM_TIM1_Init(5000);
  pwm_period2 = PWM_TIM4_Init(5000);

  PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1);  // Set current duty for PWM_TIM1
  PWM_TIM4_Set_Duty(current_duty1, _PWM_NON_INVERTED, _PWM_CHANNEL2);  // Set current duty for PWM_TIM4

  PWM_TIM1_Start(_PWM_CHANNEL1, &_GPIO_MODULE_TIM1_CH1_PE9);

  PWM_TIM4_Start(_PWM_CHANNEL2, &_GPIO_MODULE_TIM4_CH2_PD13);

  while (1) {                                // endless loop
    if (GPIOA_IDR.B3) {                // button on RA3 pressed
      Delay_ms(1);
      current_duty = current_duty + 5;       // increment current_duty
      if (current_duty > pwm_period1) {      // if we increase current_duty greater then possible pwm_period1 value
        current_duty = 0;                    // reset current_duty value to zero
      }
      PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1); // set newly acquired duty ratio
     }

    if (GPIOA_IDR.B4) {                // button on RA4 pressed
      Delay_ms(1);
      current_duty = current_duty - 5;       // decrement current_duty
      if (current_duty > pwm_period1) {      // if we decrease current_duty greater then possible pwm_period1 value (overflow)
        current_duty = pwm_period1;          // set current_duty to max possible value
      }
      PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1); // set newly acquired duty ratio
     }

    if (GPIOA_IDR.B5) {                // button on RA5 pressed
      Delay_ms(1);
      current_duty1 = current_duty1 + 5;     // increment current_duty
      if (current_duty1 > pwm_period2) {     // if we increase current_duty1 greater then possible pwm_period2 value
        current_duty1 = 0;                   // reset current_duty1 value to zero
      }
      PWM_TIM4_Set_Duty(current_duty1, _PWM_NON_INVERTED, _PWM_CHANNEL2);       // set newly acquired duty ratio
     }

    if (GPIOA_IDR.B6) {                // button on RA6 pressed
      Delay_ms(1);
      current_duty1 = current_duty1 - 5;     // decrement current_duty
      if (current_duty1 > pwm_period2) {     // if we decrease current_duty1 greater then possible pwm_period1 value (overflow)
        current_duty1 = pwm_period2;         // set current_duty to max possible value
      }
      PWM_TIM4_Set_Duty(current_duty1, _PWM_NON_INVERTED, _PWM_CHANNEL2);
     }

    Delay_ms(1);                             // slow down change pace a little
  }
}
    Voici une démonstration vidéo de fonctionnement :




L’objectif de ce tutoriel est de mettre en oeuvre le contrôle de vitesse de moteur a courant continu de façon autonome 
Pour ceci on aura besoin de 
Un Moteur DC
STM32 F4
Transistor TIP122
Diode
Deux boutons poussoirs 
deux résistances 1 K

Le principe est tout à fait simple on aura deux boutons poussoirs ou la première va incrémenter la vitesse de moteur et la deuxième va faire exactement le contraire.

L’incrémentation continuera jusqu’à alimenter le moteur en régime de rapport cyclique complet puis conditionnement une autre incrémentation va le remettre a 0 tour/s, le même truc se passe avec la décrémentation de rapport déja nul va le rendre on vitesse maximale.


Voici un exemple de comment on varie le vitesse de moteur a courant continu using Mikro C for ARM et STM32F4:

//Let's Electronic By Aymen Lachkhem
// www.letselectronic.blogspot.com
// In This Tutorial We are going to control the speed of dc motor using Stm32 PWM.
unsigned int current_duty, old_duty;
unsigned int pwm_period1, pwm_period2;

void InitMain() {
  GPIO_Digital_Input (&GPIOA_BASE, _GPIO_PINMASK_3 | _GPIO_PINMASK_4 ); // configure PORTA pins as speed control input
}

void main() {
  InitMain();
  current_duty  = 100;                        // initial value for current_duty


  pwm_period1 = PWM_TIM1_Init(5000);


  PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1);  // Set current duty for PWM_TIM1

  PWM_TIM1_Start(_PWM_CHANNEL1, &_GPIO_MODULE_TIM1_CH1_PE9);



  while (1) {                                // endless loop
    if (GPIOA_IDR.B3) {                // button on RA3 pressed
      Delay_ms(1);
      current_duty = current_duty + 1;       // increment speed
      if (current_duty > pwm_period1) {      // if we increase current_duty greater then possible pwm_period1 value
        current_duty = 0;                    // reset current_duty value to zero
      }
      PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1); // set newly acquired duty ratio
     }

    if (GPIOA_IDR.B4) {                // button on RA4 pressed
      Delay_ms(1);
      current_duty = current_duty - 3;       // decrement speed
      if (current_duty > pwm_period1) {      // if we decrease current_duty greater then possible pwm_period1 value (overflow)
        current_duty = pwm_period1;          // set current_duty to max possible value
      }
      PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1); // set newly acquired duty ratio
     }

    Delay_ms(1);                             // slow down change pace a little
  }
}
    Voici une démonstration vidéo de fonctionnement :




   




vendredi 15 janvier 2016

STM32 F4 PWM:Timers

STM32 F4 : PWM Timers


Résultat de recherche d'images pour "stm32"


On commence par definir ces  grandes protocoles électroniques :

PWM

La modulation de largeur d'impulsions (MLI ; en anglais : Pulse Width Modulation, soit PWM), est une technique couramment utilisée pour synthétiser des signaux continus à l'aide de circuits à fonctionnement tout ou rien, ou plus généralement à états discrets.
Le principe général est qu'en appliquant une succession d'états discrets pendant des durées bien choisies, on peut obtenir en moyenne sur une certaine durée n'importe quelle valeur intermédiaire.
Résultat de recherche d'images pour "pwm mli definition"
Ce phénomène est fortement recommandé pour assurer la variation de vitesse de moteur a courant continu, aujourd'hui je vais vous démontrer comment on peut générer un signal PWM déune STM32 et visualiser son présence sur des diodes LEDs.

Voici un exemple de comment on génére un signal PWM en se basant sur la couche Software de Mikro C for ARM et STM32F4:
//Let's Electronic By Aymen Lachkhem
// www.letselectronic.blogspot.com
// Hello in this tutoriel we are going to use 4 buttons (digital Input), the first two will increase and decrease the current duty for the
// first Led and the second two will make the same thing with the other Led.
unsigned int current_duty, old_duty, current_duty1, old_duty1;
unsigned int pwm_period1, pwm_period2;

void InitMain() {
  GPIO_Digital_Input (&GPIOA_BASE, _GPIO_PINMASK_3 | _GPIO_PINMASK_4 | _GPIO_PINMASK_5 | _GPIO_PINMASK_6); // configure PORTA pins as input
}

void main() {
  InitMain();
  current_duty  = 100;                        // initial value for current_duty
  current_duty1 = 100;                        // initial value for current_duty1

  pwm_period1 = PWM_TIM1_Init(5000);
  pwm_period2 = PWM_TIM4_Init(5000);

  PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1);  // Set current duty for PWM_TIM1
  PWM_TIM4_Set_Duty(current_duty1, _PWM_NON_INVERTED, _PWM_CHANNEL2);  // Set current duty for PWM_TIM4

  PWM_TIM1_Start(_PWM_CHANNEL1, &_GPIO_MODULE_TIM1_CH1_PE9);

  PWM_TIM4_Start(_PWM_CHANNEL2, &_GPIO_MODULE_TIM4_CH2_PD13);

  while (1) {                                // endless loop
    if (GPIOA_IDR.B3) {                // button on RA3 pressed
      Delay_ms(1);
      current_duty = current_duty + 5;       // increment current_duty
      if (current_duty > pwm_period1) {      // if we increase current_duty greater then possible pwm_period1 value
        current_duty = 0;                    // reset current_duty value to zero
      }
      PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1); // set newly acquired duty ratio
     }

    if (GPIOA_IDR.B4) {                // button on RA4 pressed
      Delay_ms(1);
      current_duty = current_duty - 5;       // decrement current_duty
      if (current_duty > pwm_period1) {      // if we decrease current_duty greater then possible pwm_period1 value (overflow)
        current_duty = pwm_period1;          // set current_duty to max possible value
      }
      PWM_TIM1_Set_Duty(current_duty,  _PWM_NON_INVERTED, _PWM_CHANNEL1); // set newly acquired duty ratio
     }

    if (GPIOA_IDR.B5) {                // button on RA5 pressed
      Delay_ms(1);
      current_duty1 = current_duty1 + 5;     // increment current_duty
      if (current_duty1 > pwm_period2) {     // if we increase current_duty1 greater then possible pwm_period2 value
        current_duty1 = 0;                   // reset current_duty1 value to zero
      }
      PWM_TIM4_Set_Duty(current_duty1, _PWM_NON_INVERTED, _PWM_CHANNEL2);       // set newly acquired duty ratio
     }

    if (GPIOA_IDR.B6) {                // button on RA6 pressed
      Delay_ms(1);
      current_duty1 = current_duty1 - 5;     // decrement current_duty
      if (current_duty1 > pwm_period2) {     // if we decrease current_duty1 greater then possible pwm_period1 value (overflow)
        current_duty1 = pwm_period2;         // set current_duty to max possible value
      }
      PWM_TIM4_Set_Duty(current_duty1, _PWM_NON_INVERTED, _PWM_CHANNEL2);
     }

    Delay_ms(1);                             // slow down change pace a little
  }
}
    Voici une démonstration vidéo de fonctionnement :





jeudi 14 janvier 2016

Let's Discover STM32 (Blinking Led, Delay, GPIO I/O)

Let's Discover STM32 (Blinking Led, Delay, GPIO I/O)

La famille des microprocesseurs STM32 de ST Microélectroniques fournit une vaste gamme de périphériques autour d'un cœur d'ARM Cortex, allant du simple GPIO (port d'entrée-sortie généraliste) et interface de communication serie synchrone (SPI) ou asynchrone (RS232) aux interfaces aussi complexes que l'USB, Ethernet ou HDMI. 




 
Un point remarquable est qu'un certain nombre de ces processeurs possèdent deux convertisseurs analogique-numériques, permettant un échantillonnage simultanée de deux grandeurs analogiques. Cadence sur un résonateur interne ou sur un quartz externe haute fréquence 8 MHz (multiplie en interne au maximum  a 72 MHz).
Afficher l'image d'origine



Résultat de recherche d'images pour "stm32 microcontrollers"
Le kit STM32F4Discovery de STMicroelectronics est conçu pour évaluer les caractéristiques des microcontrôleurs des séries STM32F407 et STM32F417. Les microcontrôleurs STM32F407 et STM32F417 sont basés sur le cœur 32 bits ARM Cortex-M4F hautes performances.
Les familles STM32F405, STM32F407, STM32F415, STM32F417 de microcontrôleurs sont basées sur le noyau RISC 32 bits ARM Cortex-M4 de qualité supérieure qui fonctionne à une fréquence de jusqu'à 168 MHz. Le noyau Cortex-M4 offre une unité de virgule flottante (FPU) à précision simple qui prend en charge toutes les instructions de traitement de données et types de données à précision simple ARM. Il exécute également toute une série d'instructions DSP et une unité de protection de mémoire (MPU) qui améliore la sécurité d'application.

·         Microcontrôleur STM32F407VGT6 avec noyau Cortex-M4F 32 bits ARM, flash 1 Mo, 192 Ko de RAM dans un boîtier LQFP100
·         ST-LINK/V2 intégré avec choix de commutation des modes pour utiliser le kit comme
·         ST-LINK/V2 autonome (avec connecteur SWD pour la programmation et le débogage)
·         L'alimentation de la carte se fait par bus USB ou via tension d'alimentation externe de 5 V
·         Alimentation d'application externe : 3 et 5 V
·         Accéléromètre LIS302DL ou LIS3DSH ST MEMS
·         MP45DT02, capteur audio ST MEMS, microphone numérique omnidirectionnel
·         CS43L22, DAC audio avec pilote de haut-parleur de classe D intégré
·         Huit LED : LD1 (rouge/verte) pour la communication USB, LD2 (rouge) pour la mise sous tension 3,3 V.
·         Quatre LED utilisateur, LD3 (orange), LD4 (verte), LD5 (rouge) et LD6 (bleue), 2
·         LED OTG USB LD7 (vertes) VBus et LD8 (rouge), surintensité
·         Deux boutons-poussoirs (utilisateur et Reset)
·         USB OTG FS avec micro-connecteur AB
·         Extension d'embase pour toutes les E/S LQFP100 de connexion rapide pour la
· 
  SDIO (entrée/sortie numérique sécurisée)
USART, SPI, I²C
  I²S (son Inter-IC) + PLL audio
Timers 16 et 32 bits
ADC jusqu'à 3 x 12 bits
Basse tension 1,7 à 3,6 V
     
     Voici des exemples de réalisation pratique équipées avec les codes sources et des vidéos démonstratifs
     
     1- STM32 Tutoriel #1 (Control Leds Using externel Button) 



CODE IS HERE :


/*Let's Electronic By Aymen Lachkhem */ #include "stm32f4xx_hal.h" int main() { GPIO_InitTypeDef GPIO_InitStructure; //HAL_Init(); /* GPIO Ports Clock Enable */ __GPIOD_CLK_ENABLE(); __GPIOA_CLK_ENABLE(); /* Configure PD10 as output pushpull mode */ GPIO_InitStructure.Pin = GPIO_PIN_10; GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStructure.Speed = GPIO_SPEED_LOW; GPIO_InitStructure.Pull = GPIO_PULLDOWN; HAL_GPIO_Init(GPIOD, &GPIO_InitStructure); /* Configure PA1 in input mode*/ GPIO_InitStructure.Pin = GPIO_PIN_1; GPIO_InitStructure.Mode = GPIO_MODE_INPUT; GPIO_InitStructure.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStructure); while(1) { if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_SET) HAL_GPIO_WritePin(GPIOD, GPIO_PIN_10, GPIO_PIN_SET); else HAL_GPIO_WritePin(GPIOD, GPIO_PIN_10, GPIO_PIN_RESET); } }
Have Fun 

   2- STM32 Tutoriel #2 (Control DC Motor in Both Direction) 




CODE IS HERE :

/*Let's Electronic By Aymen Lachkhem*/ #include "stm32f4xx_hal.h" int main() { GPIO_InitTypeDef GPIO_InitStructure; //HAL_Init(); /* GPIO Ports Clock Enable */ __GPIOD_CLK_ENABLE(); __GPIOA_CLK_ENABLE(); /* Configure PD11, PD10 in output pushpull mode to control DC Motor / GPIO_InitStructure.Pin = GPIO_PIN_10 | GPIO_PIN_11 ; GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStructure.Speed = GPIO_SPEED_LOW; GPIO_InitStructure.Pull = GPIO_PULLDOWN; HAL_GPIO_Init(GPIOD, &GPIO_InitStructure); /* Configure PA1 in input mode for DC motor's direction*/ GPIO_InitStructure.Pin = GPIO_PIN_1; GPIO_InitStructure.Mode = GPIO_MODE_INPUT; GPIO_InitStructure.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStructure); while (1) if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1)){ HAL_GPIO_WritePin(GPIOD, GPIO_PIN_11,GPIO_PIN_SET); HAL_GPIO_WritePin(GPIOD, GPIO_PIN_10,GPIO_PIN_RESET); } else { HAL_GPIO_WritePin(GPIOD, GPIO_PIN_11,GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOD, GPIO_PIN_10,GPIO_PIN_SET); }}

Have Fun 

    3 - STM32 Tutoriel #3 (Toggle Leds Using Mikro C for ARM)  




CODE IS HERE :


// Let's Electronic By Aymen Lachkhem unsigned int oldstate; void main() { GPIO_Digital_Input(&GPIOA_IDR, _GPIO_PINMASK_0); // Set PA0 as digital input GPIO_Digital_Output(&GPIOD_ODR, _GPIO_PINMASK_ALL); // Set PORTD as digital output oldstate = 0; do { if (Button(&GPIOA_IDR, 0, 1, 1)) // detect logical one on PA0 pin oldstate = 1; if (oldstate && Button(&GPIOA_IDR, 0, 1, 0)) { // detect one-to-zero transition on PA0 pin GPIOD_ODR = ~GPIOD_ODR; // invert PORTD value oldstate = 0; } } while(1); // endless loop }

Have Fun 

3