soem-node/dist/index.d.ts

Bindings Node-API pour SOEM (Simple Open EtherCAT Master)

/**
 * Représentation d'une interface réseau retournée par `SoemMaster.listInterfaces()`.
 */
export interface NetworkInterface {
    /** Nom de l'interface (ex: "eth0", "Ethernet 2") */
    name: string;
    /** Description lisible de l'interface, si disponible */
    description: string;
}
/**
 * Wrapper TypeScript autour du binding natif SOEM (N-API).
 *
 * Contrat (résumé):
 * - Entrées: nom d'interface réseau (string) optionnel dans le constructeur.
 * - Sorties: méthodes renvoyant des types JS primitifs ou Buffers.
 * - Modes d'erreur: la plupart des méthodes renvoient un booléen ou un code; le binding natif
 *   peut jeter pour les erreurs fatales (ex: problème d'initialisation).
 *
 * Usage typique:
 * const m = new SoemMaster('eth0');
 * if (m.init()) {
 *   const slaves = m.configInit();
 *   ...
 *   m.close();
 * }
 */
export declare class SoemMaster {
    private _m;
    /**
     * Crée une instance du Master SOEM en se liant à une interface réseau.
     * @param ifname Le nom de l'interface réseau à utiliser. Défaut: 'eth0' (modifiable pour Windows).
     */
    constructor(ifname?: string);
    /**
     * Initialise le master (ouvre l'interface, prépare SOEM).
     * @returns true si l'initialisation a réussi, false sinon.
     */
    init(): boolean;
    /**
     * Lance la découverte et la configuration des esclaves EtherCAT sur le bus.
     * @returns nombre d'esclaves détectés (0 si aucun).
     */
    configInit(): number;
    /**
     * Configure la map des PDOs après `configInit()`.
     * Ne renvoie rien; l'appel peut lever une erreur côté natif si mal utilisé.
     */
    configMapPDO(): void;
    /**
     * Retourne l'état courant du master / bus (valeur numérique dépendant du binding).
     * Voir la documentation SOEM pour l'interprétation des codes d'état.
     */
    state(): number;
    /**
     * Force la lecture de l'état (rafraîchit la représentation interne) et renvoie le code d'état.
     */
    readState(): number;
    /**
     * Lit un SDO d'un esclave.
     * @param slave Index (1-based) de l'esclave sur le bus.
     * @param index Index de l'objet SDO (ex: 0x1000).
     * @param sub Sous-index de l'objet SDO (ex: 0).
    * @param ca optional Complete Access flag (true = Complete Access)
    * @returns Buffer contenant les octets lus, ou null/undefined si la lecture a échoué.
    */
    sdoRead(slave: number, index: number, sub: number, ca?: boolean): Buffer | null;
    /**
     * Écrit un SDO sur un esclave.
     * @param slave Index (1-based) de l'esclave.
     * @param index Index de l'objet SDO.
     * @param sub Sous-index de l'objet SDO.
     * @param data Buffer contenant les octets à écrire.
    * @param data Buffer contenant les octets à écrire.
    * @param ca optional Complete Access flag (true = Complete Access)
    * @returns true si l'écriture a réussi, false sinon.
    */
    sdoWrite(slave: number, index: number, sub: number, data: Buffer, ca?: boolean): boolean;
    /**
     * Envoie les données process (processdata) au réseau EtherCAT pour le cycle courant.
     * @returns nombre d'octets envoyés ou un code WKC selon l'implémentation.
     */
    sendProcessdata(): number;
    /**
     * Reçoit les données process (processdata) depuis le réseau EtherCAT pour le cycle courant.
     * @returns code WKC (working counter) ou nombre d'octets reçus selon le binding.
     */
    receiveProcessdata(): number;
    /**
     * Ferme le master et libère les ressources (sockets/bruts, handles natifs).
     */
    close(): void;
    /**
     * Écrit l'état demandé sur un esclave (ou master si slave=0).
     * @returns workcounter ou code d'erreur.
     */
    writeState(slave: number, state: number): number;
    /**
     * Vérifie l'état d'un esclave (blocking).
     * @param timeout en ms (optionnel)
     */
    stateCheck(slave: number, reqstate: number, timeout?: number): number;
    /**
     * Reconfigure un esclave (blocking). Retourne l'état final.
     */
    reconfigSlave(slave: number, timeout?: number): number;
    /**
     * Récupère un esclave (blocking). Retourne >0 si successful.
     */
    recoverSlave(slave: number, timeout?: number): number;
    /**
     * Active la mailbox cyclique pour un esclave.
     */
    slaveMbxCyclic(slave: number): number;
    /**
     * Configure et active Distributed Clocks (DC).
     */
    configDC(): boolean;
    /**
     * Retourne un tableau décrivant les esclaves détectés (name, state, outputs, inputs, ...).
     */
    getSlaves(): any[];
    initRedundant(if1: string, if2: string): boolean;
    configMapGroup(group?: number): Buffer | null;
    sendProcessdataGroup(group?: number): number;
    receiveProcessdataGroup(group?: number, timeout?: number): number;
    mbxHandler(group?: number, limit?: number): number;
    elist2string(): string;
    SoEread(slave: number, driveNo: number, elementflags: number, idn: number): Buffer | null;
    SoEwrite(slave: number, driveNo: number, elementflags: number, idn: number, data: Buffer): boolean;
    readeeprom(slave: number, eeproma: number, timeout?: number): number;
    writeeeprom(slave: number, eeproma: number, data: number, timeout?: number): number;
    APRD(ADP: number, ADO: number, length: number, timeout?: number): Buffer | null;
    APWR(ADP: number, ADO: number, data: Buffer, timeout?: number): number;
    LRW(LogAdr: number, length: number, buf: Buffer, timeout?: number): number;
    LRD(LogAdr: number, length: number, timeout?: number): Buffer | null;
    LWR(LogAdr: number, data: Buffer, timeout?: number): number;
    dcsync0(slave: number, act: boolean, CyclTime: number, CyclShift: number): boolean;
    dcsync01(slave: number, act: boolean, CyclTime0: number, CyclTime1: number, CyclShift: number): boolean;
    /**
     * Liste les interfaces réseau disponibles pour l'usage EtherCAT.
     * @returns tableau d'objets `{ name, description }`.
     */
    static listInterfaces(): NetworkInterface[];
}