Affichage des articles dont le libellé est LCD. Afficher tous les articles
Affichage des articles dont le libellé est LCD. Afficher tous les articles

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 :





lundi 2 novembre 2015

PWM, SPI and I2C Protocols in Raspberry Pi !!

PWM (Pulse Width Modulation) ou en français le MLI (Modulation avec Largeur d’Impulsion).
Commençons tout d’abord par une définition générale du PWM. Ce terme on le trouve presque partout au domaine d’électronique et surtout dans les variateurs de vitesse de moteur a courant continu ou le clignotement d’une diode LED.


Le PWM ou le MLI c’est une outil capable a gérer la valeur de signal de sortie en la partageant entre deux états 1 logique ou 0 logique suivant un rapport cyclique nommé (Alpha) qui représente le pourcentage en niveau haut par rapport au pourcentage totale du période. Autrement dit la largeur de l’impulsion.


Au premier tram l’impulsion est ­a 5% de la valeur de la période et au deuxième tram l’impulsion est à 50% mais a la dernière l’impulsion est à 90%.
Donc logiquement si on va alimenter l’anode d’une diode LED avec ces 3 signaux celle la dernière c’est celle qui va clignoter plus rapidement que les autres.
Sur le même plan si on va alimenter un moteur à courant continu avec ces trois signaux celui l’alimenté avec le dernier signal va tourner avec une vitesse plus haut que les deux autres. Et celui qui sera alimenté avec le deuxième signal tournera à la vitesse plus fort que celui l’alimenté avec le premier signal.
D’ici on peu conclure que le rapport cyclique α est proportionnelle à la vitesse de basculement de diode Led ou à la vitesse de moteur DC.
Passons maintenant a comment faire pour fournir un signal PWM avec le Raspberry Pi et comment faire pour changer le rapport cyclique.

On va réaliser ce petit montage en essayant de voir le comportement de PWM fourni par le pin 21 de Raspberry Pi sur la diode LED.
                               


         Le programme on va l’écrire en python et l’exécuter âpres.


// Lets electronic By Aymen Lachkhem

import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BOARD)
GPIO.setup(21, GPIO.OUT) #mettre le PWM en sortie de 21
p = GPIO.PWM(21,50)        #enclencher la valeur d’impulsion a 50%
p.start(0) 
try:
while True:
for i in range (100):
p.ChangeDutyCycle(i)
time.sleep(0.02)         
for i in range(100):
p.ChangeDutyCycle(100-i)
time.sleep(0.02 )
p.stop()
GPIO.cleanup()




 Juste après réaliser le montage suivant et exécuter le programme si dessus le comportement de la diode LED va bien indiquer la mise en évidence de l’existence de PWM sur Pin 21.





 On peut varier le vitesse d’un moteur à courant continu comme on veut juste on le branchant a un hacheur tel que le L293D ou un transistor suivant les besoins.
Passons à la deuxième partie . Comment on peut interfacer un capteur ANALOGIQUE avec la Raspberry Pi ?
La Raspberry Pi comme j’ai déjà indiqué avant que c’est un micro-ordinateur basé sur un micro-processeur capable qu’a lire des valeurs numériques 0 ou 1 Logique. Une valeur dedans c’est invisible.

Avant sa il fait bien comprendre les deux protocoles que la réalisation de cette objectif va se baser sur
Protocol I2C :
Historiquement la norme I2C (Inter Integrated Circuit) a été développée par Philips en 1982. Depuis elle est maintenue par NXP (ex-division semiconducteurs de Philips).
La version 1.0 a été publiée en 1992, la version 2.0 en 1998, la version 2.1 en 2000, la version 3.0 en 2007 et la version actuelle 4.0 en 2012.

On peut définir L’I2C sous série synchrone bidirectionnel half-duplex.
Plusieurs équipements, soit maîtres, soit esclaves, peuvent être connectés au bus.
Les échanges ont toujours lieu entre un seul maître et un (ou tous les) esclave(s), toujours à l'initiative du maître (jamais de maître à maître ou d'esclave à esclave). Cependant, rien n'empêche un composant de passer du statut de maître à esclave et réciproquement.
La connexion est réalisée par l'intermédiaire de deux lignes :
·          SDA (Serial Data Line) : ligne de données bidirectionnelle,
·         SCL (Serial Clock Line) : ligne d'horloge de synchronisation bidirectionnelle.
Il ne faut également pas oublier la masse qui doit être commune aux équipements.

 Protocole SPI :
 Une liaison SPI (pour Serial Peripheral Interface) est un bus de données série synchrone baptisé ainsi par Motorola, qui opère en mode Full-duplex. Les circuits communiquent selon un schéma maître-esclaves, où le maître s'occupe totalement de la communication. Plusieurs esclaves peuvent coexister sur un même bus, dans ce cas, la sélection du destinataire se fait par une ligne dédiée entre le maître et l'esclave appelée chip select.

Alors ce qu’on peut prendre ici c’est qu’il faut réaliser une conversion analogique numérique en se basant sur un ADC (Analog Direct Converter) qui fonctionne déjà sous les protocoles suivants.
La communication sera comme ceci : le convertisseur analogique numérique inclus plusieurs entrées analogiques qui joueront les rôles d’esclaves (slaves) et une sortie vers le Raspberry Pi qui jouera le rôle de maitre
Prenons par exemple le convertisseur analogique numérique MCP3008 D/A chip qui contient plusieurs entrées analogiques telles que capteurs ou afficheurs …  .
Comme il est indiqué sur la graphe de GPIO antécédente il existe plusieurs protocoles qu’on a connu avec des autres cartes électroniques déjà utilisée tels que le protocole I2C, UART,…. .



Résultat de recherche d'images pour "raspberry pi gpio"



Ces protocoles seront pas automatiquement activées on aura besoin de les activés manuellement avant de les utilisées. Alors il faut réaliser les étapes suivantes avant :   
  • Ouvrons un terminal, depuis une interface graphique, et/ou lancons la commande suivante :

sudo raspi-config
  • Cela lance l'interface de configuration du Raspberry Pi, sélectionnons « Advanced Options » puis validons :

Résultat de recherche d'images pour "enable spi"

  • Sur le nouvel écran, sélectionnons « I2C » par exemple puis validons :
Résultat de recherche d'images pour "enable spi"

  • Répondons « Yes » à toutes les questions qui suivent.
  • Rebootons notre machine en tapant

sudo reboot
  • Testons que l'I2C est active avec la commande suivante :

lsmod | grep i2c_

Le même principe avec les restes de protocoles au but d’activer le protocole qu’on va utilisée selon la tache.