Go Down

Topic: besoin d aide signal pwm (Read 336 times) previous topic - next topic

tursio

Bonjour,
Je cherche à créer un petit module à base d'Attiny 45 et de 2 octocoupleurs qui , branchés sur une radiocommande à la mise sous tension me générerait à sa sortie pwm un signal à 50 Hz et une pulsation d'1 microseconde au bout d'un temps donné. Et ensuite rebasculerai sur le signal de la télécommande. J'ai trouvé un module similaire mais dont les valeurs de sortie ne sont pas les bonnes et dont voici le code :
Code: [Select]
/*
 * Programm zu Steuerung und überlagerung einer Signalleitung
 * für eine CGO2 Kamera.
 */
#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 1000000UL  // 1,0 MHz (für delay.h)
 
bool signal_online = false;
byte PIN_PWM = 1;
byte PIN_SWSE = 3; //Schaltersignal Empfänger
byte PIN_SWSP = 4; // Schaltersignal Prozessor
long start_at = millis();
void setup() {
  // put your setup code here, to run once:
  pinMode(PIN_PWM,OUTPUT);
  pinMode(PIN_SWSE,OUTPUT);
  pinMode(PIN_SWSP,OUTPUT);
 
  analogWrite(PIN_PWM,0);
  digitalWrite(PIN_SWSE,LOW);
  digitalWrite(PIN_SWSP,LOW);
   
}
 
void loop() {
  long now = millis();
  /*
   * Wenn das Singnal bereits vom Empfänger Online ist
   * wird der Kanal offen gehalten.
   */
  if(signal_online){
    analogWrite(PIN_PWM,0);
    digitalWrite(PIN_SWSP,LOW);
    digitalWrite(PIN_SWSE,HIGH);
    return;
  }
 
  /*
   * Nach dem Einschalten, wird nach ca. 5 Sekunden
   * ein Signal von ca. 500us für eine Sekunde aufgelegt.
   */
  if( now - start_at > 5000 && now - start_at < 6000 ){
    digitalWrite(PIN_SWSP,HIGH);
    analogWrite(PIN_PWM,7);
    digitalWrite(PIN_SWSE,LOW);
  }
 
  /*
   * Nach ca. 6 Sekunden wird das Signal vom Prozessor das oben
   * erzeigt wurde auf 0 gesetzt und der Koppler geschlossen.
   * Dafür wird die Signalleitung des Empfängers nun freigegeben.
   */
  if( now - start_at >= 6000 ){
    analogWrite(PIN_PWM,0);
    digitalWrite(PIN_SWSP,LOW);
    digitalWrite(PIN_SWSE,HIGH);
    signal_online = true;     
  }
 
}


Pensez-vous qu'il soit possible de modifier le code ici dessus pour passer de 500 microsecondes de pulsations à le durée dont j'ai besoin ?
Merci de votre analyse.
Charlie

Artouste

Bonjour,
Je cherche à créer un petit module à base d'Attiny 45 et de 2 octocoupleurs qui , branchés sur une radiocommande à la mise sous tension me générerait à sa sortie pwm un signal à 50 Hz et une pulsation d'1 microseconde
bonjour
Il n'est pas possible de generer un creneau de largeur 1µs sur une sortie de  ton MCU (qui plus est avec un horloge à 1 MHz )

tursio

Merci de ta réponse mais j'ai fait une erreur dans mon exposé: il faut un créneau de largeur 1 milliseconde et pas microseconde... désolé mais je ne suis pas de la partie.

68tjs

Avec un avr 8 bits on ne peut pas créer le signal que l'on veut.
Les formules pour calculer les fréquences de répétition possibles sont dans la datasheet du micro de la carte que tu utilises qui est la ? ? ? ?).
Pour de faibles valeurs de fréquence de répétition il ne devrait pas y avoir de difficultés : si tu obtient 49.8 Hz au lieu de pile 50 Hz cela ne devrait pas poser de problème (49,8 = valeur choisie au pif pour l'explication).
La durée minimale de l'impulsion sera 20 ms/255 = 78 µs (pour un timer 8bits)

Tu  verra dans la datasheet qu'il existe 2 ou 3 types de PWM selon le timer utilisé.
Il est préférable de ne pas utiliser le timer 0 qui est utilisé par les fonctions de temps arduino.
Le timer 1 est 16 bits, le timer 2 est 8bits.

Chaque timer ne peut prendre le contrôle que de 2 sorties donc selon le timer utilisé les numéros de pins sont imposés.

trimarco232

#4
Aug 13, 2017, 12:15 am Last Edit: Aug 13, 2017, 12:07 pm by trimarco232
Quote
il faut un créneau de largeur 1 milliseconde
Bonjour,
...
delay(1)
...

quelle sera la fréquence de l'oscillateur ?

_pepe_

#5
Aug 13, 2017, 12:38 pm Last Edit: Aug 13, 2017, 12:40 pm by _pepe_
Bonjour

Il est tout-à-fait possible de générer une impulsion de 1µs sur un AVR 8 bit tournant à 1 MHz, dès lors que les interruptions sont désactivées afin de ne pas perturber le programme sur lequel repose le contrôle de la chronologie.

Par exemple, pour générer une impulsion d'une durée d'un cycle d'horloge système sur la sortie PB0, on peut faire :

Code: [Select]
  PINB = 1;
  PINB = 1;

ou, en forçant la main au compilateur :

Code: [Select]
  asm volatile (
    " ldi r24,1 \n"
    " out %[_PINB],r24 \n"
    " out %[_PINB],r24 \n"
    :: [_PINB] "I" (_SFR_IO_ADDR(PINB)) );


On peut a fortiori contrôler des processus plus lents, et même trèèès lents, toujours avec une précision au cycle d'horloge près.

Bien évidemment, selon ce principe (purement logiciel), le micro-contrôleur ne peut pas faire autre chose à côté qui ne soit pas précisément contrôlé en durée.

Toutefois, comme le micro-contrôleur dispose de périphériques intégrés dont les cycles de fonctionnement sont, sinon réglables, au moins connus avec précision, il est possible de le libérer de certaines de ces tâches en les mettant à profit.

Ainsi, les compteurs/timers sont eux aussi capables de générer, sur des sorties spécifiques, des impulsions pouvant être aussi courtes qu'un cycle d'horloge système, et même de les répéter automatiquement avec une période précise au cycle d'horloge près. Sur certains micro-contrôleurs, qui intègrent un circuit PLL et un ou plusieurs compteurs/timers rapides, l'horloge utilisée peut avoir une fréquence supérieure à celle de l'horloge système. Par exemple, sur un ATtiny45 cadencé par son horloge RC interne à 8 MHz, cette horloge peut tourner à 64 MHz.

Pour des durées dépassant les capacités des compteurs/timers et de leur prédiviseur de fréquence, le microcontrôleur peut reprendre la main logiciellement afin d'enchaîner des séquences de contrôles différentes, en modifiant les registres de réglage au vol mais à une fréquence et avec une précision beaucoup plus faibles que le processus généré. Par exemple avec une horloge système à 1 MHz et un compteur/timer 8 bits, on pourrait ainsi générer une impulsion de 1 µs à la fréquence de 50 Hz en paramétrant une période de 200 cycles d'horloge (soit 5 kHz) et en n'autorisant logiciellement la production de l'impulsion sur la sortie associée que durant une période de compteur toutes les 100 périodes.

_pepe_

Pour en revenir au sujet, la chronologie des signaux souhaités ne me paraît pas très claire. Un petit chronogramme explicatif ne serait pas de trop.

trimarco232

#7
Aug 13, 2017, 01:06 pm Last Edit: Aug 15, 2017, 06:57 am by trimarco232
Quote
dès lors que les interruptions sont désactivées
Bonjour _pepe_,

oui mais comment désactiver les interruptions sans risquer de ficher le bazar dans le fonctionnement d'un arduino ?
par exemple si on les désactive alors que le programme a besoin d'en déclencher une ?
ou pire, si on les rétablit alors qu'il faut qu'elles sont (temporairement) désactivées pour le bon déroulement du programme ?

bref, comment le compilateur va gérer toutes ces instructions pour le moins inhabituelles ?

_pepe_

#8
Aug 13, 2017, 03:15 pm Last Edit: Aug 13, 2017, 03:28 pm by _pepe_
Quand les interruptions doivent être utilisées concomitamment avec le déroulement du processus (et note que cela n'arrive pas tout le temps), on doit recourir aux périphériques pour réaliser les tâches qui risqueraient d'être inopportunément interrompues. Si plusieurs tâches sont réalisées en même temps, on peut être amené à prévoir des phases de re-synchronisation afin de reprendre la chronologie du processus au bon endroit.

Le compilateur ne fait que ce qu'on lui demande (ou du moins on doit faire en sorte que ce soit toujours le cas). Ce n'est pas lui qui gère ni décide ce que fait le programme. C'est au développeur de concevoir, de façon adéquate (mais en toute connaissance de cause, il lui suffit de bien lire la datasheet), la manière dont doivent cohabiter les différentes tâches réalisée matériellement et/ou logiciellement par le micro-contrôleur.

Concrètement, si l'on doit par exemple interdire provisoirement les interruptions du comptage du temps (delay(), millis(), ...) et de l'interface série (Serial), le développeur doit veiller à ce que la durée maximale de traitement de ces interruptions ne gêne pas le contrôle du processus (réalisé au travers des périphériques si la vitesse et la précision sont importantes), et que les phases ininterruptibles du processus ne retardent pas le traitement des interruptions au-delà de ce qui est permis.


Les capacités d'un microcontrôleur étant finies, il existe forcément des limites dans la multiplication des tâches simultanées et dans les performances réalisables. Mais avant de les atteindre on peut arriver à faire énormément de chose (et souvent beaucoup plus que ce qu'on croit généralement, semble-t-il...).

Toutefois, pour cela il faut considérer le micro-contrôleur comme une machine dont on va déterminer précisément les actions, et non pas simplement comme le lieu du déroulement d'algorithmes comme on le fait habituellement sur les PC. Autrement dit, on doit faire de l'électronique numérique, et non plus seulement de l'informatique.

Le logiciel Arduino et les bibliothèques logicielles associées fournissent une base permettant de commencer à réaliser, avec le minimum de connaissances et d'efforts, des systèmes présentant des fonctions clairement identifiées et relativement indépendantes les unes des autres. Mais pour tirer pleinement partie des possibilités des microcontrôleurs, il est nécessaire d'entrer beaucoup plus dans les détails, en commençant par maîtriser suffisamment le code qu'on (ré-)utilise et par s'intéresser aux fonctions matérielles qu'elles prennent en charge, puis à celles qu'elles ne gèrent pas. Cela aboutit généralement à se débarrasser d'une partie des éléments du logiciel Arduino, et à produire soi-même du code beaucoup plus spécifique au type de matériel utilisé et à la configuration des applications visées. L'environnement Arduino apparaît comme suffisamment souple pour que cette démarche soit progressive, et donc utile aux utilisateurs impliqués dans une démarche d'apprentissage.

_pepe_

#9
Aug 13, 2017, 09:59 pm Last Edit: Aug 14, 2017, 02:27 am by _pepe_
À titre d'exemple, voici un bout de code en assembleur pour ATtiny45 à 1 MHz qui génère logiciellement 10000 impulsions de 1 ms (1000 cycles machine) à la fréquence de 50 Hz (20000 cycles machine par période).

Le nombre de cycles machine pour chaque instruction est indiqué en commentaire à la fin de la ligne. Les branchements conditionnels (brne) prennent deux cycles lorsque le saut est effectué, sinon un seul.

;************************************************************************

; sauvegarde des registres
  push r25      ; 2
  push r26      ; 2
  push r27      ; 2
  push r28      ; 2
  push r29      ; 2

  ldi r25,1     ; 1

; PORTB &= b11111110
  cbi 0x18,0    ; 2
; DDRB  |= b00000001
  sbi 0x17,0    ; 2

; désactivation des interruptions
  cli           ; 1

; n=10000 (0x2710)
  ldi r28,0x10  ; 1
  ldi r29,0x27  ; 1

;== 20000 cycles : 18995+1+999+1+4 ==
1:

;--- 18995 cycles : 2+(4748*4-1)+2 --
; j=4748 (0x128C)
  ldi r26,0x8C  ; 1
  ldi r27,0x12  ; 1
2:
; --j
  sbiw r26,1    ; 2
; if (j>0) goto 2
  brne 2b       ; 1/2

  nop           ; 1
  nop           ; 1
;------------------------------------

;--- 1 cycle ------------------------
; PINB = b00000001
  out 0x16,r25  ; 1
;------------------------------------

;--- 999 cycles : 1+(249*4-1)+3 -----
; i=249
  ldi r26,249   ; 1
3:
  nop           ; 1
; --i
  subi r26,1    ; 1
; if (i>0) goto 3
  brne 3b       ; 1/2

  nop           ; 1
  nop           ; 1
  nop           ; 1
;------------------------------------

;--- 1 cycle ------------------------
; PINB = b00000001
  out 0x16,r25  ; 1
;------------------------------------

;--- 4 cycles -----------------------
; --n
  sbiw r28,1    ; 2
; if (n>0) goto 1
  brne 1b       ; 1/2
;====================================

; réactivation des interruptions
  sei           ; 1

; récupération des registres
  pop 29        ; 2
  pop 28        ; 2
  pop 27        ; 2
  pop 26        ; 2
  pop 25        ; 2

;************************************

Le même code à intégrer dans un programme en C :

Code: [Select]
asm volatile (
"  push r25      \n"
"  push r26      \n"
"  push r27      \n"
"  push r28      \n"
"  push r29      \n"
"  ldi r25,1     \n"
"  cbi 0x18,0    \n"
"  sbi 0x17,0    \n"
"  cli           \n"
"  ldi r28,0x10  \n"
"  ldi r29,0x27  \n"
"1:\n"
"  ldi r26,0x8C  \n"
"  ldi r27,0x12  \n"
"2:\n"
"  sbiw r26,1    \n"
"  brne 2b       \n"
"  nop           \n"
"  nop           \n"
"  out 0x16,r25  \n"
"  ldi r26,249   \n"
"3:\n"
"  nop           \n"
"  subi r26,1    \n"
"  brne 3b       \n"
"  nop           \n"
"  nop           \n"
"  nop           \n"
"  out 0x16,r25  \n"
"  sbiw r28,1    \n"
"  brne 1b       \n"
"  sei           \n"
"  pop 29        \n"
"  pop 28        \n"
"  pop 27        \n"
"  pop 26        \n"
"  pop 25        \n"
::);

_pepe_

#10
Aug 14, 2017, 04:15 am Last Edit: Aug 14, 2017, 04:26 am by _pepe_
Et voici un exemple de croquis pour ATtiny45 à 1 MHz qui génère sur la sortie PB4 des impulsions de 1 ms à la fréquence de 50 Hz.

Cette version utilise le compteur/timer1 pour générer l'impulsion de 1 ms sur un cycle de compteur de 2 ms, et une routine d'interruption pour allonger logiciellement la période à 20 ms en forçant la sortie à l'état bas durant 9 cycles de compteur sur 10. Contrairement au code précédent, les interruptions restent actives et un programme peut être exécuté parallèlement à la génération du signal.

Code: [Select]
volatile byte count;

void setup() {
  PORTB &= ~0x10; // PB4 default level as low
  DDRB |= 0x10;   // PB4/OC1B as output

  // WGM1[2:0] = 111 : mode 7 (Fast PWM)
  // COM1B[1:0] = 11 : inverting mode
  // CS1[2:0]  = 010 : f/8 prescaling
  TCCR1A = 0x33;
  TCCR1B = 0x0A;

  OCR1B  = 124; // duty cycle = 50 %
  OCR1A  = 249; // f = Fcpu/8/250 = 500 Hz
  TIFR   = 4;   // clear overflow interrupt flag
  TIMSK |= 4;   // overflow interrupt enable
  count = 0;
}

void loop() {
}

ISR(TIMER1_OVF_vect) {
  count++;
  if (count==1) {
    // COM1B[1:0] = 00 : normal port mode
    // PB4 set to low level
    TCCR1A = 0x03;
  } else
  if (count==10) {
    // COM1B[1:0] = 11 : PWM mode
    // for one pulse on PB4/OC1B output
    TCCR1A = 0x33;
    count = 0;
  }
}

(Non testé sur l'ATtiny45 ; testé sur le timer 2 de l'ATmega328P avec les paramètres adéquats.)

_pepe_

#11
Aug 14, 2017, 11:14 am Last Edit: Aug 14, 2017, 12:38 pm by _pepe_
Pour ceux qui voudraient tester sur un ATmega328P à 16 MHz (Arduino Uno/Nano/Mini), je mets les codes correspondants. La sortie PD3/OC2B est la pin 3 d'Arduino.

Le code en assembleur, sans timer ni interruption :

;************************************************************************

; sauvegarde des registres
  push r25      ; 2
  push r26      ; 2
  push r27      ; 2
  push r28      ; 2
  push r29      ; 2

  ldi r25,8     ; 1

; PORTD &= b11110111
  cbi 0x0B,3    ; 2
; DDRD  |= b00001000
  sbi 0x0A,3    ; 2

; désactivation des interruptions
  cli           ; 1

; n=10000 (0x2710)
  ldi r28,0x10  ; 1
  ldi r29,0x27  ; 1

;== 20000 cycles : 303995+1+15999+1+4
1:

;--- 303995 cycles : 2+(50665*6-1)+4
; j=50665 (0xC5E9)
  ldi r26,0xE9  ; 1
  ldi r27,0xC5  ; 1
2:
  nop           ; 1
  nop           ; 1
; --j
  sbiw r26,1    ; 2
; if (j>0) goto 2
  brne 2b       ; 1/2

  nop           ; 1
  nop           ; 1
  nop           ; 1
  nop           ; 1
;------------------------------------

;--- 1 cycle ------------------------
; PIND = b00001000
  out 0x09,r25  ; 1
;------------------------------------

;--- 15999 cycles : 2+(2666*6-1)+2 --
; j=2666 (0x0A6A)
  ldi r26,0x6A  ; 1
  ldi r27,0x0A  ; 1
3:
  nop           ; 1
  nop           ; 1
; --j
  sbiw r26,1    ; 2
; if (j>0) goto 3
  brne 3b       ; 1/2

  nop           ; 1
  nop           ; 1
;------------------------------------

;--- 1 cycle ------------------------
; PIND = b00001000
  out 0x09,r25  ; 1
;------------------------------------

;--- 4 cycles -----------------------
; --n
  sbiw r28,1    ; 2
; if (n>0) goto 1
  brne 1b       ; 1/2
;====================================

; réactivation des interruptions
  sei           ; 1

; récupération des registres
  pop 29        ; 2
  pop 28        ; 2
  pop 27        ; 2
  pop 26        ; 2
  pop 25        ; 2

;************************************
Le même intégré au C :

Code: [Select]
asm volatile (
"  push r25      \n"
"  push r26      \n"
"  push r27      \n"
"  push r28      \n"
"  push r29      \n"
"  ldi r25,8     \n"
"  cbi 0x0B,3    \n"
"  sbi 0x0A,3    \n"
"  cli           \n"
"  ldi r28,0x10  \n"
"  ldi r29,0x27  \n"
"1:\n"
"  ldi r26,0xE9  \n"
"  ldi r27,0xC5  \n"
"2:\n"
"  nop           \n"
"  nop           \n"
"  sbiw r26,1    \n"
"  brne 2b       \n"
"  nop           \n"
"  nop           \n"
"  nop           \n"
"  nop           \n"
"  out 0x09,r25  \n"
"  ldi r26,0x6A  \n"
"  ldi r27,0x0A  \n"
"3:\n"
"  nop           \n"
"  nop           \n"
"  sbiw r26,1    \n"
"  brne 3b       \n"
"  nop           \n"
"  nop           \n"
"  out 0x09,r25  \n"
"  sbiw r28,1    \n"
"  brne 1b       \n"
"  sei           \n"
"  pop 29        \n"
"  pop 28        \n"
"  pop 27        \n"
"  pop 26        \n"
"  pop 25        \n"
::);


Le code avec timer et interruption :

Code: [Select]
volatile byte count;

ISR(TIMER2_OVF_vect) {
  count++;
  if (count==1) {
    // COM2B[1:0] = 00 : normal port mode
    // PD3 set to low level
    TCCR2A = 0x03;
  } else
  if (count==10) {
    // COM2B[1:0] = 11 : PWM mode
    TCCR2A = 0x33;
    count = 0;
  }
}

void setup() {
  PORTD &= ~8;  // PD3 default level as low
  DDRD |= 8;    // PD3 as OC2B output

  // WGM2[2:0] = 111 : mode 7 (Fast PWM)
  // COM2B[1:0] = 11 : inverting mode
  // CS2[2:0]  = 101 : f/128 prescaling
  TCCR2A = 0x33;
  TCCR2B = 0x0D;

  OCR2B  = 124; // duty cycle = 50 %
  OCR2A  = 249; // f = Fcpu/128/250 = 500 Hz
  TIFR2   = 1;   // clear overflow interrupt flag
  TIMSK2 |= 1;   // overflow interrupt enable
  count = 0;
}

void loop() {
}

Artouste

Bonjour

Il est tout-à-fait possible de générer une impulsion de 1µs sur un AVR 8 bit tournant à 1 MHz, dès lors que les interruptions sont désactivées afin de ne pas perturber le programme sur lequel repose le contrôle de la chronologie.

Par exemple, pour générer une impulsion d'une durée d'un cycle d'horloge système sur la sortie PB0, on peut faire :

Code: [Select]
 PINB = 1;
  PINB = 1;

ou, en forçant la main au compilateur :

Code: [Select]
 asm volatile (
    " ldi r24,1 \n"
    " out %[_PINB],r24 \n"
    " out %[_PINB],r24 \n"
    :: [_PINB] "I" (_SFR_IO_ADDR(PINB)) );


On peut a fortiori contrôler des processus plus lents, et même trèèès lents, toujours avec une précision au cycle d'horloge près.

Bien évidemment, selon ce principe (purement logiciel), le micro-contrôleur ne peut pas faire autre chose à côté qui ne soit pas précisément contrôlé en durée.

Toutefois, comme le micro-contrôleur dispose de périphériques intégrés dont les cycles de fonctionnement sont, sinon réglables, au moins connus avec précision, il est possible de le libérer de certaines de ces tâches en les mettant à profit.

Ainsi, les compteurs/timers sont eux aussi capables de générer, sur des sorties spécifiques, des impulsions pouvant être aussi courtes qu'un cycle d'horloge système, et même de les répéter automatiquement avec une période précise au cycle d'horloge près. Sur certains micro-contrôleurs, qui intègrent un circuit PLL et un ou plusieurs compteurs/timers rapides, l'horloge utilisée peut avoir une fréquence supérieure à celle de l'horloge système. Par exemple, sur un ATtiny45 cadencé par son horloge RC interne à 8 MHz, cette horloge peut tourner à 64 MHz.

Pour des durées dépassant les capacités des compteurs/timers et de leur prédiviseur de fréquence, le microcontrôleur peut reprendre la main logiciellement afin d'enchaîner des séquences de contrôles différentes, en modifiant les registres de réglage au vol mais à une fréquence et avec une précision beaucoup plus faibles que le processus généré. Par exemple avec une horloge système à 1 MHz et un compteur/timer 8 bits, on pourrait ainsi générer une impulsion de 1 µs à la fréquence de 50 Hz en paramétrant une période de 200 cycles d'horloge (soit 5 kHz) et en n'autorisant logiciellement la production de l'impulsion sur la sortie associée que durant une période de compteur toutes les 100 périodes.
Bonsoir _pepe_
Merci pour la démonstration faisabilité soft :smiley-mr-green: , mais perso, si je devais faire je ne passerais très surement pas par ce biais

trimarco232

#13
Aug 15, 2017, 07:21 am Last Edit: Aug 15, 2017, 04:36 pm by trimarco232
Bonjour,

les programmes en assembleur avec les cycles en commentaire, j'ai déjà donné
(_pepe_ tu savait que pour tuer 2 cycles, tu peut faire rjmp $+1, et pour en tuer 4, un rcall directement vers  un return quelconque)

les inclusions d'asm dans le c, je savais faire, mais j'ai abandonné : top lourd, craintes vis-à-vis de la réaction du compilo, et surtout, entre-temps, j'ai acquis les connaissances pour pouvoir s'en passer

donc merci à _pepe_ pour cet exposé complet (on devrait en faire un tuto pour les ex débutants)
et +1 avec Artouste

_pepe_

#14
Aug 15, 2017, 12:37 pm Last Edit: Aug 15, 2017, 02:36 pm by _pepe_
Mon laïus avait pour but de prouver que, contrairement à ce qu'on est trop souvent porté à croire, des possibilités existent bel et bien.

Bien que l'assembleur nécessite un apprentissage spécifique, son utilisation pour réaliser un programme à la chronologie précise fait généralement partie de ces possibilités.

Mais comme je viens aussi de le démontrer, le pilotage logiciel des périphériques disponibles dans le micro-contrôleur est également une solution souvent envisageable. Et celle-ci apparaît comme beaucoup plus accessible.

De ce point de vue, le problème exposé pourra très certainement (quand on le connaîtra avec plus de précision) être réglé en une vingtaine de lignes en C comme celles que j'ai données ci-dessus.

Go Up