---
title: pointercalibration
slug: develop/es/pointercalibration
docTags: 
createdAt: 2025-03-26T14:48:16.698Z
---

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

**IDL de pointercalibration**

```javascript
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* .

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

## PointerCalibration

**startCalibration()**

```javascript
Promise<void> startCalibration()
```

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

**getCalibrationStatus()**

```javascript
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()**

```javascript
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()**

```javascript
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.&#x20;

**isCalibrated()**

```javascript
Promise<bool> isCalibrated()
```

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

**getDiagnosticInfoHTML()**

```javascript
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()**

```javascript
Promise<void> startEventLogging()
```

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

**stopEventLogging()**

```javascript
Promise<void> stopEventLogging()
```

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

## Ejemplo

```javascript
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);
}
```