omega2-oled/index.js

A library to wrap the OLED CLI

'use strict';

const spawn = require('child_process').spawn;

const SCROLL_DIRECTIONS = {
  left: 'left',
  right: 'right',
  diagonalLeft: 'diagonal-left',
  diagonalRight: 'diagonal-right',
  stop: 'stop'
};

module.exports = {
  clear: clear,
  cursor: cursor,
  cursorPixel: cursorPixel,
  dim: dim,
  draw: draw,
  init: init,
  invert: invert,
  scroll: scroll,
  power: power,
  write: write,
  SCROLL_DIRECTIONS: SCROLL_DIRECTIONS
}

/**
 * @function clear
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the screen has been cleared
 */
function clear() {
  const clearer = spawn('oled-exp', ['-c']);
  return wrapProcess(clearer);
}

/**
 * @function cursor
 * @param {Int} row - The row to move the cursor to
 * @param {Int} column - The column to move the cursor to
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the cursor has been moved
 */
function cursor(row, column) {
  const cursor = spawn('oled-exp', ['cursor', row + ',' + column])
  return wrapProcess(cursor);
}

/**
 * @function cursorPixel
 * @param {Int} row - The row to move the cursor to
 * @param {Int} pixel - The pixel column to move the cursor to, 0 to 127
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the cursor has been moved
 */
function cursorPixel(row, pixel) {
  const cursor = spawn('oled-exp', ['cursor', row + ',' + pixel])
  return wrapProcess(cursor);
}

/**
 * @function dim
 * @param {Boolean} dimState - True for dimmed False for normal
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the screen has been dimmed
 */
function dim(dimState) {
  const dimProcess = spawn('oled-exp', ['dim', dimState ? 'on' : 'off']);
  return wrapProcess(dimProcess);
}

/**
 * @function drawImage
 * @param {String} imagePath - The path for the image to draw
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the screen has been dimmed
 */
function draw(imagePath) {
  const drawProcess = spawn('oled-exp', ['draw', imagePath]);
  return wrapProcess(drawProcess);
}

/**
 * @function init
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects once the screen has been initialized
 */
function init(stringToWrite) {
  const init = spawn('oled-exp', ['-i']);
  return wrapProcess(init);
}

/**
 * @function invert
 * @param {Boolean} invertState - True for inverted False for normal
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the screen has been inverted
 */
function invert(invertState) {
  const invertProcess = spawn('oled-exp', ['invert', invertState ? 'on' : 'off']);
  return wrapProcess(invertProcess);
}

/**
 * @function scroll
 * @param {SCROLL_DIRECTION} direction - Directions for scroll
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the screen has been inverted
 */
function scroll(direction) {
  const directionProcess = spawn('oled-exp', ['scroll', direction]);
  return wrapProcess(directionProcess);
}

/**
 * @function power
 * @param {Boolean} powerState - True for on False for off
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the screen has been powered on or off
 */
function power(powerState) {
  const powerProcess = spawn('oled-exp', ['power', powerState ? 'on' : 'off']);
  return wrapProcess(powerProcess);
}

/**
 * @function write
 * @param {String} stringToWrite - The string to write to the screen
 * @returns Promise<ReturnCode, Error> - A promise that resolves or rejects after the content has been written
 */
function write(stringToWrite) {
  const writer = spawn('oled-exp', ['write', stringToWrite]);
  return wrapProcess(writer);
}

function wrapProcess(process) {
  return new Promise((resolve, reject) => {
    let error = '';
    let results = '';

    process.stdout.on('data', (data) => {
      results += data;
    });

    process.stderr.on('data', (data) => {
      error += data
    });

    process.on('close', (code) => {
      if (error && error.length) {
        return reject(error);
      }

      resolve(code);
    });
  });
}