Journal Taptempo en Zig

Bonjour Nal,

Entrons tout de suite dans le vif du sujet : j'ai écrit un Taptempo en Zig.
Il ne gère aucun argument, n'a aucune fonctionnalité marrante, mais il fonctionne.
Il suffit d'appuyer sur une touche pour l'activer, puis d'appuyer en cadence jusqu'à cinq fois. On peut arrêter l'enregistrement en appuyant sur la touche q, qui permet aussi de quitter le programme.
Le voici donc ci-dessous :

// taptempo.zig
//
//! Copyright 2023 alberic89 <alberic89@gmx.com>
//!
//! This program is free software; you can redistribute it and/or modify
//! it under the terms of the GNU General Public License as published by
//! the Free Software Foundation; either version 3 of the License, or
//! (at your option) any later version.
//!
//! This program is distributed in the hope that it will be useful,
//! but WITHOUT ANY WARRANTY; without even the implied warranty of
//! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//! GNU General Public License for more details.
//!
//! You should have received a copy of the GNU General Public License
//! along with this program. If not, see <https://www.gnu.org/licenses/>. 
//!
//! Compilé avec succès avec zig 0.11.0-dev.4406+d370005d3 (2 août 2023)
//! Retouvez le code source à <https://github.com/alberic89/taptempo-zig>
//
// Pour compiler :
// ```bash
// zig build-exe taptempo.zig
// ```
// Sur une idée de François Mazen
// https://linuxfr.org/users/mzf/journaux/un-tap-tempo-en-ligne-de-commande
//
// Merci à Leon Henrik Plickat pour son exemple d'application zig "Uncooked"
// https://zig.news/lhp/want-to-create-a-tui-application-the-basics-of-uncooked-terminal-io-17gm
//

const std = @import("std");
const stdout = std.io.getStdOut().writer();
const fs = std.fs;
const os = std.os;
const time = std.time;

/// Cette fonction va capturer et calculer le tempo de la frappe au clavier.
/// Peut retourner une erreur.
pub fn captureTempo(tty: fs.File) !void {
    // On enregistre 5 frappes
    var tap: [5]?i64 = [5]?i64{null, null, null, null, null};
    try stdout.print("Capture du tempo", .{});
    for (tap, 0..) |_, index| {
        var buffer: [1]u8 = undefined;
        _ = try tty.read(&buffer);
        // Si la touche q est pressée, on arrête d'enregistrer la frappe
         if (buffer[0] == 'q') {
            break;
        } else {
            // La précision d'enregistrement est *au maximum* de l'ordre
            // de la milliseconde, mais peut être plus faible en fonction
            // du matériel et de l'OS
            tap[index] = time.milliTimestamp();
            try stdout.print(".", .{});
        }
    }
    try stdout.print(" Terminé.\n", .{});
    var ecart: [4]?i64 = [4]?i64{null, null, null, null};
    // On calcule l'écart entre les frappes, en prévoyant le cas où il
    // n'y a pas eu 5 frappes
    for (tap[1..], 0..) |ftime, index| {
        if (ftime != null) {
            ecart[index] = ftime.? - tap[index].?;
        }
    }
    var ecart_moy: ?f64 = null;
    // On calcule l'écart moyen
    for (ecart) |inter| {
        if (inter != null) {
            if (ecart_moy != null) {
                var inter_f: f64 = @floatFromInt(inter.?);
                ecart_moy = ( ecart_moy.? + inter_f ) / 2;
            } else {
                ecart_moy = @floatFromInt(inter.?);
            }
        }
    }
    // Si il y a eu moins de 2 frappes, on ne peut pas calculer le tempo
    if (ecart_moy == null) {
        try stdout.print("Tu n'as pas le rythme dans la peau !\n", .{});
        return;
    }
    // Le tempo est donné avec un entier en battements par minute
    var bpm: u64 = @intFromFloat((60 * time.ms_per_s) / ecart_moy.?);
    try stdout.print("Tempo : {} bpm\n", .{bpm});
    return;
}

pub fn main() !void {
    // On récupère la sortie standart
    var tty = try fs.cwd().openFile("/dev/tty", .{ .mode = .read_write });
    defer tty.close();

    // On enregistre l'état du terminal
    const original = try os.tcgetattr(tty.handle);
    var raw = original;

    // On active un certain nombre de paramètres :
    //   ECHO: Le terminal n'affiche plus les touches pressées.
    // ICANON: Désactive le mode d'entrée canonique ("cooked").
    //         Permet de lire l'entrée byte-par-byte au lieu de
    //         ligne-par-ligne.
    raw.lflag &= ~@as(
        os.linux.tcflag_t,
        os.linux.ECHO | os.linux.ICANON,
    );
    // BRKINT: Désactive la conversion de l'envoi de SIGNINT en cas de crash.
    //         N'as normalement pas d'effet sur les systèmes modernes.
    //  INPCK: Désactive le contrôle de la parité.
    //         N'as normalement pas d'effet sur les systèmes modernes.
    // ISTRIP: Désactive la suppression du 8ème bit des caractères.
    //         N'as normalement pas d'effet sur les systèmes modernes.
    raw.iflag &= ~@as(
        os.linux.tcflag_t,
        os.linux.BRKINT | os.linux.INPCK | os.linux.ISTRIP,
    );

    // On met la taille des caractères à 8 bits.
    // N'as normalement pas d'effet sur les systèmes modernes.
    raw.cflag |= os.system.CS8;

    raw.cc[os.system.V.TIME] = 0;
    raw.cc[os.system.V.MIN] = 1;

    // Applique les changements
    try os.tcsetattr(tty.handle, .FLUSH, raw);

    try stdout.print(
        "Bienvenue dans Taptempo !\nPour commencer, appuyez sur une touche.\n(q pour arrêter)\n",
        .{});

    while (true) {
        var buffer: [1]u8 = undefined;
        _ = try tty.read(&buffer);
        if (buffer[0] == 'q') {
            break;
        } else {
            try captureTempo(tty);
        }
    }
    try stdout.print("Au revoir !\n", .{});
    // Restaure l'état original du terminal
    try os.tcsetattr(tty.handle, .FLUSH, original);
    return;
}

Pour ceux que le côté technique intéresse, voici quelques détails :
- certaines fonctionnalités du terminal sont désactivées pour pouvoir intercepter correctement la frappe au clavier,
- la précision est de l'ordre de la milliseconde, mais le résultat affiché est le produit d'une conversion un peu bourine des bpm en un entier,
- il n'y a aucune dépendance externe mis à part la bibliothèque standard.

Des exécutables pour x86_64 et aarch64 sont disponibles sur la page des releases du dépôt GitHub.

Si vous voulez en apprendre plus sur Zig, sachez qu'une dépêche sur le sujet est en cours de rédaction.