pointercalibration

8 min

El objeto pointercalibration le permite calibrar una pantalla táctil conectada al reproductor.

IDL de pointercalibration

interface PointerCalibration {
    Promise<void> startCalibration();
    Promise<int> getCalibrationStatus();
    Promise<void> setCalibrationRanges(int XMin, int XMax, int YMin, int YMax);
    Promise<bool> clearStoredCalibration();
    Promise<bool> isCalibrated();

    Promise<String> getDiagnosticInfoHTML(bool deviceInfo = true, bool events = true);
    Promise<void> startEventLogging();
    Promise<void> stopEventLogging();
};

Creación de objetos

Para crear un objeto pointcalibration , primero cargue el módulo brightsign/pointercalibration usando el método require() . Luego cree una instancia de la clase pointcalibration .

var pointerCalibrationClass = require("@brightsign/pointercalibration");
var pointerCalibration = new pointerCalibrationClass();

PointerCalibration

startCalibration()

Promise<void> startCalibration()

Inicia la calibración de la pantalla táctil. Este método puede fallar si no hay dispositivos adecuados presentes.

getCalibrationStatus()

Promise<int> getCalibrationStatus()

Devuelve el estado actual de calibración de la pantalla táctil como un entero. Este método puede fallar si no hay dispositivos adecuados presentes. Los siguientes son valores de retorno posibles:

0: Calibrando el punto superior izquierdo

1: Calibrando el punto superior derecho

2: Calibrando el punto inferior derecho

100: Calibración completada

setCalibrationRanges()

Promise<void> setCalibrationRanges(int XMin, int XMax, int YMin, int YMax)

Sobrescribe los valores de rango de pantalla proporcionados por la pantalla táctil. Este método es útil cuando la totalidad de la salida de video no se muestra en la superficie táctil. El uso práctico de este método normalmente requiere un script de calibración personalizado, imágenes adecuadas y una configuración de calibración adaptada a una configuración específica.

clearStoredCalibration()

Promise<bool> clearStoredCalibration()

Borra la configuración de calibración almacenada para una pantalla táctil. Este método puede fallar si no hay dispositivos adecuados presentes.

isCalibrated()

Promise<bool> isCalibrated()

Devuelve verdadero si hay datos de calibración presentes en el software del sistema.

getDiagnosticInfoHTML()

Promise<DOMString> getDiagnosticInfoHTML(bool deviceInfo, bool events)

Devuelve diagnósticos de la pantalla táctil. Si deviceInfo es verdadero, este método devolverá información de hardware y configuración del kernel; si eventos es verdadero, este método devolverá un registro de eventos (el registro de eventos se elimina hasta ese punto).

startEventLogging()

Promise<void> startEventLogging()

Inicia el registro de eventos de la pantalla táctil.

stopEventLogging()

Promise<void> stopEventLogging()

Detiene el registro de eventos de la pantalla táctil.

Ejemplo

const pointerClass = require("@brightsign/pointer");
var pointer = new pointerClass();
const pointerCalibClass = require("@brightsign/pointercalibration");
var pointerCalib = new pointerCalibClass();
var bsMessage = new BSMessagePort();
var present = {
    mouse: undefined,
    TouchScreen: undefined
}

function runThis() {
    pointerCalib.startEventLogging().then(() => {
        console.log("Started Event Logger.");
        bsMessage.PostBSMessage({
            startLogger: "Success"
        });
    }).catch((err) => {
        console.log("ERROR: " + err);
        bsMessage.PostBSMessage({
            startLogger: "Failed"
        });
    });
    function eventInfo() {
        pointerCalib.getDiagnosticInfoHTML(false, true).then((val) => {
            console.log("----------------------------Events Info-----------------------------")
            console.log(val);
        }).catch((err) => {
            console.log("ERROR: " + err);
        });
    }

    function checkPeripherals() {
        pointer.isMousePresent().then((val) => {
            console.log("Checking to see if a mouse if present.");
            present.Mouse = val;
            if (val === false) {
                console.log("No mouse attached.");
                console.log("value: " + val);
                bsMessage.PostBSMessage({
                    mouse: "Success"
                });
            } else if (val === true) {
                console.log("Mouse Detected.");
                console.log("value: " + val);
                bsMessage.PostBSMessage({
                    mouse: "Success"
                });
            } else {
                console.log("Recieved unexpected return value.");
                console.log("value: " + val);
                bsMessage.PostBSMessage({
                    mouse: "Failed"
                });
            }
        }).catch((err) => {
            console.log("ERROR: " + err);
            bsMessage.PostBSMessage({
                mouse: "Failed"
            });
        });
        pointer.isMultiTouchPresent().then((val) => {
            present.TouchScreen = val;
            if (val === true) {
                console.log("TouchScreen found.");
                console.log(val);
                bsMessage.PostBSMessage({
                    touch: "Success"
                });
            } else {
                console.log("TouchScreen not found.");
                console.log(val);
                bsMessage.PostBSMessage({
                    touch: "Success"
                });
            }
        }).catch((err) => {
            console.log("ERROR: " + err);
            console.log("isMultiTouchPresent failed.");
            bsMessage.PostBSMessage({
                touch: "Failed"
            });
        });
    }

    function Calibrate() {
        pointerCalib.setCalibrationRanges(0, 1920, 0, 1080).then((val) => {
            console.log("Range has been set.");
            bsMessage.PostBSMessage({
                CalibRange: "Success"
            });
        }).catch((err) => {
            console.log("ERROR: " + err);
            console.log("SetCalibrationRanges Failed.");
            bsMessage.PostBSMessage({
                CalibRange: "Failed"
            });
        });
        pointerCalib.startCalibration().then((value) => {
            console.log("Starting Calibration:");
            bsMessage.PostBSMessage({
                Calib: "Success"
            });
            pointerCalib.getCalibrationStatus().then((val) => {
                console.log("Calibration Status: " + val);
                bsMessage.PostBSMessage({
                    CalibStat: "Success"
                });
            }).catch((err) => {
                console.log("ERROR: " + err);
                console.log("getCalibrationStatus Failed.");
                bsMessage.PostBSMessage({
                    CalibStat: "Failed"
                });
            });
        }).catch((err) => {
            console.log("ERROR: " + err);
            console.log("startCalibration Failed.");
            bsMessage.PostBSMessage({
                Calib: "Failed"
            });
        });
    }

    function CheckandClear() {
        pointerCalib.isCalibrated().then((value) => {
            console.log("Checking for calibration.");
            if (value === true) {
                console.log("Calibrated: " + value);
                bsMessage.PostBSMessage({
                    isCalib: "Success"
                });
                pointerCalib.clearStoredCalibration().then((val) => {
                    console.log("Attempting to clear calibration.");
                    if (value === true) {
                        console.log("Calibration Cleared: " + val);
                        bsMessage.PostBSMessage({
                            clearCalib: "Success"
                        });
                    } else {
                        console.log("Calibration Cleared: " + val);
                        bsMessage.PostBSMessage({
                            clearCallib: "Success"
                        });
                    }
                }).catch((err) => {
                    console.log("ERROR: " + err);
                    console.log("Failed to clear calibration.");
                    bsMessage.PostBSMessage({
                        clearCalib: "Failed"
                    });
                });
            } else {
                console.log("Calibrated: " + value);
                bsMessage.PostBSMessage({
                    isCalib: "Success"
                });
            }
        }).catch((err) => {
            console.log("ERROR: " + err);
            console.log("Calibration Check Failed.");
            bsMessage.PostBSMessage({
                isCalib: "Failed"
            });
        });
    }

    function diagInfHTML() {
        pointerCalib.getDiagnosticInfoHTML(true, true).then((value) => {
            console.log("Success in getting diagnostics info. Printing below.");
            console.log("Info: " + value);
            bsMessage.PostBSMessage({
                getDiagInf: "Success"
            });
        }).catch((err) => {
            console.log("ERROR: " + err);
            console.log("Failed to get diagnostics information.");
            bsMessage.PostBSMessage({
                getDiagInf: "Failed"
            });
        });
    }

    bsMessage.PostBSMessage({
        BSMessagePort: "CREATED"
    });
    setTimeout(checkPeripherals, 1000);
    setTimeout(() => {
        if (present.TouchScreen === true) {
            setTimeout(Calibrate, 4000);
            setTimeout(CheckandClear, 8000);
        } else {
            console.log("TouchScreen Not Found. Calibration Tests Skipped.");
            console.log("TouchScreen Value: " + present.TouchScreen);
            console.log("Mouse Value: " + present.Mouse);
            bsMessage.PostBSMessage({
                CalibTest: "Skipped"
            });
        }
    }, 3000);
    setTimeout(diagInfHTML, 10000);
    setTimeout(eventInfo, 11500);
    setTimeout(() => {
        console.log("Ending Test.");
        pointerCalib.stopEventLogging().then(() => {
            console.log("Stopped Event Logger.");
            bsMessage.PostBSMessage({
                stopLogger: "Success"
            });
        }).catch((err) => {
            console.log("ERROR STOPPING EVENT LOGGER: " + err);
            bsMessage.PostBSMessage({
                stopLogger: "Failed"
            });
        });
    }, 12000);
    setTimeout(() => {
        bsMessage.PostBSMessage({
            BSMessagePort: "COMPLETE"
        });
    }, 16000);
}