Journal Portage de TapTempo en Tcl

Posté par (page perso) . Licence CC by-sa
Tags :
17
8
mar.
2018

Bonjour Nal,

Malgré le déferlement de journaux provoqué par le premier TapTempo, il manquait toujours Tcl à l'appel, donc voilà une version pour ce vénérable petit langage de script facile à apprendre et bien pratique.

#!/usr/bin/env tclsh8.6                                                                                                                            
package require cmdline                                                                                                                            

set options {                                                                                                                                      
    {p.arg 0 "Précision du tempo (nombre de décimales)"}                                                                                           
    {s.arg 5 "Nombre d'échantillons pour le calcul du tempo"}                                                                                      
    {r.arg 5 "Temps de remise à zéro du calcul (secondes)"}                                                                                        
    {v "Afficher la version"}                                                                                                                      
}                                                                                                                                                  
set usage ": ./taptempo.tcl \[options\]"                                                                                                           
try {                                                                                                                                              
    array set params [::cmdline::getoptions ::argv $options $usage]                                                                                
} trap {CMDLINE USAGE} {msg} {                                                                                                                     
    puts stderr $msg                                                                                                                               
    exit 1                                                                                                                                         
}                                                                                                                                                  
if {$params(v)} {                                                                                                                                  
    puts "a02"                                                                                                                                     
    exit 0                                                                                                                                         
}                                                                                                                                                  
puts "Appuyer sur la touche entrée en cadence (q pour quitter)."                                                                                   
while {[set key [gets stdin]] ne "q"} {                                                                                                            
    set now [expr {[clock microseconds] / 1e6}]                                                                                                    
    lappend times $now                                                                                                                             
    if {[llength $times] < 2 || $now - [lindex $times end-1] > $params(r)} {                                                                       
        puts "Appuyer encore sur la touche entrée pour lancer le calcul du tempo…"                                                                 
        set times [list $now]                                                                                                                      
        continue                                                                                                                                   
    }                                                                                                                                                                                                                                        
    set times [lrange $times end-[expr {$params(s)+1}] end]                                                                                        
    set mean 0.0                                                                                                                                   
    for {set i 0} {$i < [llength $times] - 1} {incr i} {                                                                                           
        set mean [expr {$mean + [lindex $times $i+1] - [lindex $times $i]}]                                                                        
    }                                                                                                                                              
    set mean [expr {$mean / [llength $times]}]                                                                                                     
    set tempo [expr {60 / $mean}]
    puts -nonewline [format "Tempo: %.$params(p)f bpm  " $tempo]                                                                                   
    flush stdout                                                                                                                                   
}                                                                                                                                                  
puts "Au revoir !"

Il faut le paquet tcllib pour les options avec cmdline (il y a des chances qu'il soit déjà installé, mais pas forcément). D'ailleurs, j'ai pas vu comment faire des options longues avec, donc il n'y a que les versions courtes.

  • # Regroupement

    Posté par (page perso) . Évalué à 8.

    Avec toutes ces variations, vous n'avez plus qu'à monter un équivalent de 99 Bottles of Beer. Bon, y'a encore de la marge avant d'avoir autant de variations dans les langages.

    Python 3 - Apprendre à programmer en Python avec PyZo et Jupyter Notebook → https://www.dunod.com/sciences-techniques/python-3

    • [^] # Re: Regroupement

      Posté par . Évalué à 4.

      cela ne devrait pas être trop difficile de monter un repository github avec toutes les versions centralisés. Par contre, il faut une personne qui s'en occupe.

      "La première sécurité est la liberté"

  • # Hello World

    Posté par . Évalué à 3.

    TamTempo is the new Hello

  • # Petite erreur…

    Posté par (page perso) . Évalué à 3.

       set mean [expr {$mean / [llength $times]}]

    Il manque un -1, m'en suis rendu compte en faisant la version en C. D'ailleurs, tout le calcul du tempo se simplifie en :

       set tempo [expr {60 * ([llength $times] - 1) / ($now - [lindex $times 0])}]

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.