Afficheur RPM pour tourne disque, vs Picaxe?

[DAT44]

Bonjour,
Je voudrai fabriquer un petit montage pour afficher sur trois afficheurs 7 segments, la vitesse de rotation d'un plateau de tourne disque.
La détection serait optique (bande réfléchissante sur le coté du plateau, 1 top par rotation).
D'après mes calcul, la précision minimum de mesure du temps devais être de l'ordre de la milliseconde ...
Je ne sais pas si un Picaxe serait suffisamment rapide pour faire le job ?
J'ai vu qu'il existe une instruction settimer est-ce la bonne voie ?
Quelqu'un aurait-il un exemple de code, pour une mesure du temps de l'ordre de la milliseconde avec un Picaxe ?
-----

[Forhorse]

Mesurer un temps à la ms avec du code interprété, sur un PIC tu peux oublier.
Par contre les timers matériels et leur interruptions sont fait pour cette usage (beaucoup plus précis que la ms). Est-ce qu'on peu les exploiter sur un picaxe ? je n'en sais rien.
Sinon n'importe quel microcontrôleur, avec du code natif (ASM) ou compilé (BASIC, C,...) peut le faire.

[mag1]

Bonjour,
Je voudrai fabriquer un petit montage pour afficher sur trois afficheurs 7 segments, la vitesse de rotation d'un plateau de tourne disque.
La détection serait optique (bande réfléchissante sur le coté du plateau, 1 top par rotation).
D'après mes calcul, la précision minimum de mesure du temps devais être de l'ordre de la milliseconde ...
Je ne sais pas si un Picaxe serait suffisamment rapide pour faire le job ?
J'ai vu qu'il existe une instruction settimer est-ce la bonne voie ?
Quelqu'un aurait-il un exemple de code, pour une mesure du temps de l'ordre de la milliseconde avec un Picaxe ?

Bonjour,
Il existe des commandes spécifiques pour mesurer le temps. Par ex, la commande pulsin à, pour la fréquence horloge µC de 4MHz, une résolution de 10µs, mais un time out de 0.65536 s , si ce temps est dépassé, la réponse est 0.
Quel est donc le temps entre deux pulses?.
https://picaxe.com/basic-commands/di...output/pulsin/
Pour un TD en 33t/mn, le temps entre deux pulses est 60/33=1,81s...c'est trop. Faudrait essayer avec 4 pulses par tour.
Après, faut traduire en t/mn
Le bon vieux stroboscope, c'est bien aussi
Faut faire des essais
MM

[paulfjujo]

Bonjour,



au niveau principe ,
utiliser une entree interruptible d'un PIC , ex RB0
qui reagit immediatement à la detection d'un tour de disque
Hardware :
recepteur : capteur opto phototransistor, emetteur : diode led
element reflechissant sur le pourtour du disque..si on a pas d'autre élement de contraste lumineux.
necessite un montage mecanique precis ..
le signal photo transistor sur entree RB0
La led alimentee en permamence
l'interruption mesure le temps ecoulé par un timer entre chaque TOP
On fait donc une mesure de periode.
exemple un timer 16bits calé sur 1ms compte le temps ecoulé..
on peut tres bien gerer les depassements du compteur via un comptage des multiples de 65536
donc pas de limuite de comptage .(.hormis quand meme , d'une valeur TimeOut anormale à definr )
La periode mesurée transformée en Tr/mn par calcul
affichage multiplexé sur 3 digits rafraichi à chaque tour,
(ou un mini LCD I2C avec affichage en gros caracteres 1cm ?)

exemple de mesure, sur ce meme principe, de la vitesse de rotation d'un moteur NEMA
( mais pour ce cas un PIC plus petit devrait suffire.)

une precision de lecture à +-1mS devrait suffire (avec 3 digits) ?

[A voir en vidéo sur Futura]

[Murayama]

Bonjour!

Mesurer un temps à la ms avec du code interprété, sur un PIC tu peux oublier.

Faut voir... Les signaux dont nous parlons sont extrêmement lents. Et puis mesurer
à la ms, cela voudrait dire qu'avec un quartz de 8 MHz (donc pas le plus rapide de ce qui se fait),
nous avons 8000 clocks dans une durée de 1ms. Même un arduino peut le faire.

Je voudrai fabriquer un petit montage pour afficher sur trois afficheurs 7 segments, la vitesse de rotation d'un plateau de tourne disque.

Dabord, voyons quelle résolution il faut...
Pour mesurer avec 3 chiffres significatifs, en supposant que vous ne jouerez pas de 78 tours, il faut pouvoir afficher une valeur
entre, disons, 0 et 511. En mettant une virgule fixe, vous pourrez donc afficher aux alentours de 33.0 et de 45.0.

Comme je ne connais pas le picaxe, je viens de regarder la liste des "instructions", et il y a des instructions pour les
fonction temporelles, et il y a aussi des interruptions. Donc mettre en place un timer doit être possible, donc la mesure entre
deux événements doit pouvoir se faire extrêmement rapidement.

Pascal

[Gyrocompas]

Bonjour,
Les anciennes platines utilisaient, soit un moteur synchrone secteur, soit un moteur piloté avec une comparaison à la fréquence secteur par un effet stroboscopique par l'éclairage par un néon.
A cette époque, la plage de tolérance du réseau était comprise entre 51Hz et 48Hz.
Aujourd'hui, le réseau se situe entre 50.050 Hz et 49.950 Hz.
Une précision sur le mode d'entraînement du plateau serait utile, de plus, la vitesse du moteur est bien supérieure à 33.3 t/mn.

[Seb.26]

My 2 cents : tu mets 4 pastilles sur ton disque et tu utilise un compteur hardware pour compter les impulsions que tu relèves à intervalles réguliers et tu lisses.

https://deepbluembedded.com/arduino-counter-timer/

[Seb.26]

PS: des 7 segments ?!! ... on est en 2025 ... un petit OLED en SPI plutôt ? ça coute 2€ et c'est bô
( par exemple "OLED 0,96 pouces SSD1306" )
Tu pilote ça avec U8g2 : https://github.com/olikraus/u8g2/wiki

[mag1]

J'ai vu qu'il existe une instruction settimer est-ce la bonne voie ?
Quelqu'un aurait-il un exemple de code, pour une mesure du temps de l'ordre de la milliseconde avec un Picaxe ?

Bonjour,
J'essaye de répondre modestement à la question.
Comme déjà dit #3, le temps d'un tour complet est trop long et dépasse le time out de 0,65535 s
On passe donc au 1/4 de tour => 60/ 33,3 /4= 0,450450.
L'unité de pulsin est de 10µs la bonne valeur pour 33,3 t/mn est donc 45045
Avec 3 digits, on vise le 1/10 de tour qui correspond à 45045 / 333 = 135 unit
On compare, on divise, on ajoute ou on retranche suivant le cas.
Pour l'affichage, je reste modeste avec un TM1637, il a un digit de trop, que l'on peut occulter, ou pas
Début de code, sans affichage

;tourne disque
;temps pour un 1/4 tour à 33,3 t/mn
;60/33,3 = 1,80180 s=> 1/4 de tour =>0,45045 s
;le retour attendu pour la bonne vitesse de 333 est 45045
; delta 1/10 de tour = 45045 /333 = 135 unit
#picaxe 08M2
#no_data
symbol tmp=w13
symbol delta=w12
symbol tminut=w11
	do
		serin C.3,1,tmp
		;tmp=45454   			;valeur test
		if tmp > 45045 then		;trop lent
			delta = tmp-45045/135 	;unités à retirer de 333
			tminut= 333 - delta
		elseif tmp<45045	then	;trop rapide
			delta= 45045 - tmp/135	;unités à ajouter à 333
			tminut = 333 + delta
		else tminut=333
		endif
		gosub affich
	loop

affich:
return

On fait ce qu'on peut....
MM

[Seb.26]

Si ça t'intéresse, un Arduino tout inclus (prise USB + écran OLED) ça vaut 7€ ...
Cherche "Nano V3.0,Nano Conseil ATmega328P CH340C Int gr 0.91 OLED Affichage 128x32 SSD1306 IIC I2C Compatible pour Arduino Nano V3.3" ...
y'a probablement d'autres modèles dispo ... perso je préfère toujours ceux en SPI plutôt qu'IIC par exemple ...

Et un ptit tuto :
https://randomnerdtutorials.com/guid...-with-arduino/

[Forhorse]

Bonjour!



Faut voir... Les signaux dont nous parlons sont extrêmement lents. Et puis mesurer
à la ms, cela voudrait dire qu'avec un quartz de 8 MHz (donc pas le plus rapide de ce qui se fait),
nous avons 8000 clocks dans une durée de 1ms. Même un arduino peut le faire.

Faut pas oublier que le PICAXE c'est du code interprété, c'est à dire que le gros du boulot du µC c'est d’interprété et d’exécuter ensuite l'instruction décodé (c'est un gros gaspillage de ressources)
Je sais pas combien d'instruction il peut traiter à la seconde, mais on doit être très loin du million d'instruction par seconde en code natif avec un simple quartz à 4Mhz
Un pic ou un arduino, avec du codé compilé n'aurait aucun problème à le faire.
Après si on peut utiliser le hardware normalement requis pour ce genre de cas (timers hard / interruptions), aucun problème

[mag1]

Bonjour,
Il existe des commandes spécifiques pour mesurer le temps. Par ex, la commande pulsin à, pour la fréquence horloge µC de 4MHz, une résolution de 10µs, mais un time out de 0.65536 s , si ce temps est dépassé, la réponse est 0.
Pour un TD en 33t/mn, le temps entre deux pulses est 60/33=1,81s...c'est trop. Faudrait essayer avec 4 pulses par tour.
Après, faut traduire en t/mn
Faut faire des essais
MM

Et donc, compte tenu de tout cela, j'ai fait, avec un picaxe,évidemment, un générateur de pulses de 10µs, écartés d'un temps variable de 0,44 à 0,46 s
Le code complet, avec affichage sur TM1637:

;tourne disque MM 05/03/25
;temps pour un 1/4 tour à 33,3 t/mn
;60/33,3 = 1,80180 s=> 1/4 de tour =>0,45045 s
;le retour attendu pour la bonne vitesse de 333 est 45045
; delta 1/10 de tour = 45045 /333 = 135 unit
#picaxe 08M2
#no_data
symbol clk= pinC.2
symbol dio= pinC.1    
symbol Octet=b0    ;octet dans b0; le test est sur bit0
symbol Chiffre=b1
symbol i=b2
symbol j=b3
symbol dp=b4
;Words *****************************
symbol Div=w12

;Initialisation TM1634 *********************************************************    
;symbol TypeAdr=$40 ; adressage auto-incrémenté par défaut=>en commentaite
symbol AdrDep=$c0 ; adresse du 1er digit (poids fort)
symbol RegLum=$8c ; réglage luminosité $80 + 8(allumé, 0:éteint) + 0 à 7(intensité)  
symbol tmp=w13
symbol delta=w10
symbol tminut=w11
	pullup %1110    ;activation des résistances pullup sur
	dirs=%01111        ;pour activer les valeurs I/O pin
	dp=$80            ;pour allumage DP 
	do
		pulsin C.3,0,tmp
		;tmp=45454   						;valeur test
		if tmp > 45045 then				;trop lent			
			delta = tmp-45045/135 		;unités à retirer de 333
			tminut= 333 - delta
		elseif tmp<45045	then			;trop rapide
			delta= 45045 - tmp/135		;unités à ajouter à 333
			tminut = 333 + delta
		else tminut=333
		endif	
		gosub affich
	loop

affich:	
    clk=1: dio=1: dio=0    ; I2CStart    ;
    Octet=RegLum        ;Réglage luminosité
    gosub I2CEnvoiOctet
    clk=0: dio=0 : clk=1 : dio=1 ;I2CStop
;boucle principale *******************************************  
    clk=1: dio=1: dio=0    ; I2CStart    ;
    Octet=AdrDep        ;synchro adresse départ
    gosub I2CEnvoiOctet
    div=1000        ;initialisation diviseur pour 4 chiffres
    for j=1 to 4
      Chiffre=tminut/Div
		lookup Chiffre,($3f,$06,$5b,$4f,$66,$6d,$7d,$07,$7f,$6f), Octet ; 0-9 uniquement
;******** ajout points centraux si ncessaire *************
 		if j=3 then
          octet=octet | dp    ;ajout points centraux
     endif
;***********************************************
      gosub I2CEnvoiOctet
      Tminut=Tminut//Div    ;on garde le reste de la division
      Div=Div/10            ;prochain diviseur
    next j
    clk=0: dio=0 : clk=1 : dio=1 ;I2CStop
    return
;******* Envoi des chiffres (octet) bit à bit dans le registre ********
I2CEnvoiOctet:    ;lecture de b0 bit à bit de bit0 à bit8 poids faible en tête.
    for i=1 to 8 ; envoi de l'octet
        clk=0
        dio=bit0        ;la broche dio prend la valeur de bit0       
        Octet = Octet/2        ;décalage à droite => bit1 devient bit0
        clk=1
    next i
    clk=0 : clk=1 : clk=0     ; traitement ACK
    return
return

J'ai aussi une vidéo de démo...si intéressé...
Je sais pas si je réponds exactement à la question
MM

[mag1]

Le générateur de pulses, des fois que ça intéresse quelqu'un

;générateur TD pulses 33,3 tours
;TD pulses toutes les 0.45045 s à 33,3t/mn
#picaxe 08M2
#no_data
symbol tmp=w13
symbol delta=w12
	low C.2
	do
		readadc10 C.4, delta  ;0 à 1023
		tmp= 2 * delta + 44000  ;de 44000 à 46000
		 pulsout C.2,1	;10 µs
		pauseus tmp
	loop

MM

[mag1]

Bon, une vidéo vite faite (comme le reste)
Manque le point décimal, mais c'est un afficheur horaire...
https://youtu.be/CzmXQNUNyoA

MM

[DAT44]

Bonjour,
Merci a chacun de votre contribution, tout particulièrement a "mag1".
Je n'ai pas beaucoup de temps libre en ce moment, mais je garde toute les infos sous le coude.
Je vous tiendrait au courant, mais il ne faudra pas être trop pressé ...

Merci encore !

[Murayama]

Bonjour!

Faut pas oublier que le PICAXE c'est du code interprété, c'est à dire que le gros
du boulot du µC c'est d’interprété et d’exécuter ensuite l'instruction décodé (c'est
un gros gaspillage de ressources)

J'entends bien. Mais il ne faut pas oublier non plus que les langages de script ont
évolué et n'ont que peu à voir avec un BASIC d'il y a 50 ans. Les premiers µP avec
lesquels j'ai joué quand j'étais gamin, des chips dont plus personne ne voulait,
n'avaient pas de périphérique intégré. Il n'y avait même pas d'UART, il existait des
chips spécialisés pour UART et il fallait tout câbler et écrire un driver pour l'UART.
Pareil pour ADC, etc. Le bus adresse était multiplexé avec le bus data, etc. Le tout
avec une horloge de l'ordre d'1 ou 2 MHz.
De nos jours, il suffit d'1 ou 2 registres pour configurer complètement un UART,
par exemple, et les µP les plus lents sont dans les 8 MHz.

Je viens de regarder les instructions du picaxe. Je vois qu'il y a par exemple
une instruction servo. Donc le simple fait de le configurer envoie le signal idoine
au servo, ub genre de PWM en permanence. Même en code interprété, ça ne doit pas prendre
des plombes à configurer.

Il y a par ailleurs des interruptions, des timers, etc.

Il y a toujours cette idée persistante de ce bon vieux temps, qui dit qu'un langage
assemblé est plus rapide qu'un langage compilé, lui-même plus rapide qu'un langage
interprété. Il y a une corrélation, évidemment, mais le picaxe me semble assez
bien conçu pour être rapide.

Je sais pas combien d'instruction il peut traiter à la seconde, mais on doit être très
loin du million d'instruction par seconde en code natif avec un simple quartz à 4Mhz

Oui, mais ici, il est question de mesurer des ms, pas des µs. Même à 4 MHz, ça fait
4000 clocks par ms. Mesurer une durée, ici, consiste à avoir un capteur qui génère
des impulsions. L'impulsion appelle une interruption (mécanisme apparemment existant
dans le picaxe avec setint), et la réception de cette interruption arrête le compteur et exploite
l'info reçue. Et le calcul et l'affichage n'on pas besoin d'être faits en temps réel.

Un pic ou un arduino, avec du codé compilé n'aurait aucun problème à le faire.

Là, on rejoint ce que j'avais dit plus haut. J'avais un jour comparé Arduino
programmé avec l'API Arduino (digitalWrite) avec l'Arduino programmé par accès direct
au registre (ex. PortA |= 0x01; pour allumer la LED du portA.0). Une boucle programmée
normalement prenait une dizaine de cycles d'horloge contre 300?? avec un digitalWrite.
Je ne me souviens plus si je l'avais publié.
Donc programmé en C et compilé n'est pas une garantie d'efficacité.

Après si on peut utiliser le hardware normalement requis pour ce genre de cas
(timers hard / interruptions), aucun problème

Ça ne m'étonnerait pas que ça marche en progammant "à la Arduino" puisque le but
est de mesurer des millisecondes. Comme dit plus haut, ça fait des milliers de clocks
par milliseconde, donc même avec quelque chose d'inefficace, c'est jouable.

Pascal

PS: Je n'avais pas lu avant de poster... Apparemment, le code de mag1 fonctionne très
bien en picaxe.

[Gyrocompas]

Bonjour,
Quel est l'intérêt de la mesure, que fait-on avec ce résultat ?
L'oreille ne sait pas apprécier les fréquences, elle sait seulement les comparer.
Yvette Horner à 33.33 t/mn ou 34 t/mn donnera une impression identique.
Eric Satie composait sur un piano complètement désaccordé.

On ignore toujours le type d'entraînement du plateau...

[Seb.26]

J'avais un jour comparé Arduino
programmé avec l'API Arduino (digitalWrite) avec l'Arduino programmé par accès direct
au registre (ex. PortA |= 0x01; pour allumer la LED du portA.0). Une boucle programmée
normalement prenait une dizaine de cycles d'horloge contre 300?? avec un digitalWrite.
Je ne me souviens plus si je l'avais publié.
Donc programmé en C et compilé n'est pas une garantie d'efficacité.

il faut juste comparer ce qui est comparable... les fonctions digitaleRead et digitalWrite font des dizaines de tests et d'indirections pour savoir si le num de pin est bien connu de ton CPU, elle passe par une CLUT pour être standard avec l'écosystème Arduino,elle cherche les registre à utilises, elle verifie que la pin est bien configurée ...etc...
Si tu veux aller vite, il y faut utiliser les registrer en effet ou encore une librairie type fastIO.
Le plus rapide étant évidement de taper directement dans les registres via des macros type #define ou des fonctions "inline".

[jiherve]

Bonjour,

Bon, une vidéo vite faite (comme le reste)
Manque le point décimal, mais c'est un afficheur horaire...
https://youtu.be/CzmXQNUNyoA

MM

ben tu "oute" avec 0x80 là ou çà va bien , un petit cache sur le point supérieur et zou un afficheur décimal 2.2 qui répond à bien des situations: thermomètre,voltmètre, ampèremètre, chargeur de batterie etc etc.
J'aime bien ce petit afficheur.
JR

[Murayama]

Bonjour!

Quel est l'intérêt de la mesure, que fait-on avec ce résultat ?

Par exemple réparer un lecteur genre B790 de ReVoX (j'en ai un).
Sur ce lecteur, il y a un affichage à LED. Il y a peut-être d'autres lecteurs
à 3 digits seulement. Le ReVoX en a 4. Et il permet de faire varier la vitesse.

Mais sur le principe, vous avez raison, c'est surtout un gadget qui permettait
à ReVoX entre autre de vendre un lecteur LP 2000 francs suisses. Et dans
les années 70, date de sa parution, c'était une somme.

Pascal

[mag1]

Bonjour,
Ben oui, c'était dommage d'avoir un afficheur 4 digits et de n'en utiliser que 3.
Voici donc une version affichant le 1/100 de tour près, prouvés par des tests. Il suffit de remplacer le pulsin par un nombre (ex 44800) et de vérifier que la valeur lue est celle correspondant à: 60 / (0.44800 *4) soit 33,48 t/mn
La photo n'est pas celle du test ci dessus

Maintenant, à quoi ça sert ? Je sais pas, mais si ça sert à rien, c'est pas grave...
Code un peu modifié:

;tourne disque
;temps pour un 1/4 tour à 33,33 t/mn
;60/33,33 = 1,800180 s=> 1/4 de tour =>0,45004 s
;le retour attendu pour la bonne vitesse de 33,33 est 45004
; delta 1/100 de tour = 45004/3333= 13,5 unit env (13+14)/2

#picaxe 08M2
#no_data
symbol clk= pinC.2
symbol dio= pinC.1    
symbol Octet=b0    ;octet dans b0; le test est sur bit0
symbol Chiffre=b1
symbol i=b2
symbol j=b3
symbol dp=b4
;Words *****************************
symbol Div=w8

;Initialisation TM1634 *********************************************************    
;symbol TypeAdr=$40 ; adressage auto-incrémenté par défaut=>en commentaite
symbol AdrDep=$c0 ; adresse du 1er digit (poids fort)
symbol RegLum=$8c ; réglage luminosité $80 + 8(allumé, 0:éteint) + 0 à 7(intensité)  
symbol tmp=w13
symbol deltah=w12
symbol deltab=w11
symbol delta=w10
symbol tminut=w9
	pullup %1110    ;activation des résistances pullup sur C.1 à C.3
	dirs=%01111        ;pour activer les valeurs I/O pin
	dp=$80            ;pour allumage DP 
	do
		pulsin C.3,0,tmp
		;tmp=45500	;test		
		if tmp > 45004 then				;trop lent
			deltah = tmp-45004/13	;c'sst pas comme /13,5, mais bon...
			deltab= tmp-45004/14
			delta=deltah+deltab/2
		;unités à retirer de 3333
			tminut= 3333 - delta
		elseif tmp<45004	then			;trop rapide
			deltah = 45004-tmp/13
			deltab= 45004-tmp/14
			delta=deltah+deltab/2			
			tminut = 3333 + delta
		else tminut=3333
		endif
		gosub affich	
	loop

affich: 
    clk=1: dio=1: dio=0    ; I2CStart    ;
    Octet=RegLum        ;Réglage luminosité
    gosub I2CEnvoiOctet
    clk=0: dio=0 : clk=1 : dio=1 ;I2CStop
;boucle principale *******************************************
  
    clk=1: dio=1: dio=0    ; I2CStart    ;
    Octet=AdrDep        ;synchro adresse départ
    gosub I2CEnvoiOctet
    div=1000        ;initialisation diviseur pour 4 chiffres
    for j=1 to 4
      Chiffre=tminut/Div
		lookup Chiffre,($3f,$06,$5b,$4f,$66,$6d,$7d,$07,$7f,$6f), Octet ; 0-9 uniquement
;******** ajout points centraux si ncessaire *************
 		if j=2 then
          octet=octet | dp    ;ajout points centraux
     endif
;***********************************************
      gosub I2CEnvoiOctet
      Tminut=Tminut//Div    ;on garde le reste de la division
      Div=Div/10            ;prochain diviseur
    next j
    clk=0: dio=0 : clk=1 : dio=1 ;I2CStop
    return
;******* Envoi des chiffres (octet) bit à bit dans le registre ********
I2CEnvoiOctet:    ;lecture de b0 bit à bit de bit0 à bit8 poids faible en tête.
    for i=1 to 8 ; envoi de l'octet
        clk=0
        dio=bit0        ;la broche dio prend la valeur de bit0       
        Octet = Octet/2        ;décalage à droite => bit1 devient bit0
        clk=1
    next i
    clk=0 : clk=1 : clk=0     ; traitement ACK
    return
return

On est là pou s'amuser un peu
MM

[mag1]

ben tu "oute" avec 0x80 là ou çà va bien , un petit cache sur le point supérieur et zou un afficheur décimal 2.2 qui répond à bien des situations: thermomètre,voltmètre, ampèremètre, chargeur de batterie etc etc.
JR

Les points décimaux n'existent pas seulement ":" sur le digit 2, activé sur le nouveau code (j'attends un TM1637 avec points décimaux)
sinon, oui, on peut, si le point est sur le digit 2, masquer le point sup.
MM

[Pascal071]

Bonjour
et compter le nombre de tempos 1mS ou 10µS pour 1 tour ?
faire le calcul et afficher pendant le 2e tour?
à étalonner à cause du temps de traitement des instructions pause ou pauseus et count=count+1
ce n'est qu'une idée..

[mag1]

Bonjour
et compter le nombre de tempos 1mS ou 10µS pour 1 tour ?
faire le calcul et afficher pendant le 2e tour?
à étalonner à cause du temps de traitement des instructions pause ou pauseus et count=count+1
ce n'est qu'une idée..

Il y a sans doute d'autres méthodes, mais pour le coup, l'enchainement de commandes basic ne donnera pas la précision obtenue par la commande pulsin qui n'est pas "en interne" programmée en basic. La mesure d'un 1/4 de tour, en dizaines de µs, permet la précision du 1/100 de tour, même si il faut jongler un peu avec des entiers ne dépassant pas 65535.
On ne mesure certainement pas deux 1/4 de tour consécutifs, peut être un sur deux, mais ça n'a aucune importance pour le résultat.
MM

[mag1]

Bonjour,
Petit retour sur le tourne disque.
Comme dit #3, à 4MHz, l'unité pulsin est de 10µs d'où un time out de 10x 65535= 0,65535 s
Or, un tour à 33,33 t/mn => 1,80018 s
Ben oui, mais à 1MHz, l'unité est x par 4 et passe à 40µS et 40 x 65535 = 2621400 µs on couvre le temps d'un tour complet.
Après essai en modifiant le générateur de pulses et en réduisant la fréquence à 1MHz pour pulsin, tout fonctionne.
Le rafraichissement affichage est ralenti, on ne mesurera pas deux tours consécutifs, donc, affichage toutes les 3,6 s.
MM