Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/djipco/hpgl

A Node.js library to communicate with HPGL-compatible plotters and printers.
https://github.com/djipco/hpgl

hpgl pen-plotter

Last synced: 2 months ago
JSON representation

A Node.js library to communicate with HPGL-compatible plotters and printers.

Lists

README 

        
# hpgl

**A Node.js library to control HPGL-compatible plotters**



[![npm](https://img.shields.io/npm/v/hpgl.svg)](https://www.npmjs.com/package/hpgl)

[![npm](https://img.shields.io/npm/dt/hpgl.svg)](https://www.npmjs.com/package/hpgl)



### About



The `hpgl` library makes it possible to interact with plotters that support the *Hewlett-Packard 

Graphics Language* (a.k.a. **hpgl**). This language is the *de facto* standard for most plotters. 



**Warning: This library is still in early stages of development. It should not be used in 

production.**



### Compatibility



This library relies on external modules for serial communication. To use it in a pure Node.js, 

environment, you will need to install and use the 

[serialport](https://www.npmjs.com/package/serialport) module. If you want to use this library 

inside [Chrome Apps](https://developer.chrome.com/apps/about_apps) or [NW.js](http://nwjs.io/)

applications, you will need to install the [browser-serialport](https://www.npmjs.com/package/browser-serialport) 

module instead (**version 2.1.0 or greater**). 



> *Note: it is possible to use `node-serialport` within NW.js and Electron projects but it needs to 

> be specifically recompiled for those environment.*



So far, the library has only beed tested with [HP 7475A](http://hpmuseum.net/display_item.php?hw=74), 

[HP 7440A](http://hpmuseum.net/display_item.php?hw=80) and 

[Roland DXY-1300](https://archive.org/details/rolanddxy130012001100commandreferencemanualaf**) 

plotters. If you have success with other makes or models, [let me know](https://twitter.com/djipco). 

Beware that some HP plotters are only equipped with a proprietary HPIB or GPIB interface. To use 

this library, your plotter must have a **serial** interface (RS-232-C).



### Coordinate System



The plotting coordinate system is anchored in the top-left corner, just like a computer screen. 

This means positive `x` goes right and positive `y` goes down. By default, plotters usually work 

differently, but I find it easier to stick with the computer screen standard.



### Getting Started



To get started, you will need a few pieces of hardware:



- HPGL-compatible plotter with a serial interface;

- USB-to-Serial adapter (unless your computer has a serial port);

- Male DB-25 to female DB-9 cable (a.k.a. null modem cable);

- Pens that fit your plotter;

- Paper.



Your plotter needs to be set to a line speed of 9600 baud with 

[8-N-1](https://en.wikipedia.org/wiki/8-N-1) settings. Chances are high this is already the case. If

not, you may need to adjust some dip switches on your device. Refer to the manufacturers's 

documentation.



### Example



The first thing you need to do to get plotting is instantiate the object used for serial 

communication. If you are working on a Node.js project using the `serialport` module, this is how 

you would do it:



```javascript

// Import the 'serialport' module and instantiate it. Do not forget to set 'autoOpen' to false in 

// the options.

const SerialPort = require("serialport");

var transport = new SerialPort("/dev/tty.usbserial", {autoOpen: false});



```



If you are working on a Chrome or NW.js application, the procedure is slightly different:



```javascript

// Import the 'browser-serialport' module and instantiate it. Pass 'false' as the third parameter of

// the SerialPort constructor so no automatic connection attempt is made.

const SerialPort = require("browser-serialport").SerialPort;

var transport = new SerialPort("/dev/tty.usbserial", {}, false);

```



Once the `transport` variable is ready, the remainining of the code is exactly the same no matter

which transport you use. For example, here is the code necessary to draw "Hello, World!".



```javascript



// Import the 'Plotter' class and instantiate it

const Plotter = require("hpgl").Plotter;

var plotter = new Plotter();



// Connect the device and add a callback to draw some text.

plotter.connect(transport, {}, function(error) {



  if (error) {

    console.log(error);

    return;

  }



  this

    .moveTo(1, 1)

    .drawText("Hello, World!");



});

```



As you can see above, you first need to create a `Plotter` object and call its `connect()` method 

passing in the `transport` variable, some optionnal settings and a function to trigger once the 

device is ready. Note that `this` is bound to the `Plotter` object and that plotting methods are 

chainable.



### Using Multiple Plotters



This library can be used to connect several plotters to the same host. However, not all 

USB-to-Serial chipsets support this. 



For example, the Prolific 2303 driver crashes my computer when I try use more than one adapter. On 

the other hand, the Texas Instrument/TI driver works beautifully with multiple devices.



### Documentation



I will try to maintain an up-to-date [API documentation](https://djipco.github.io/hpgl/). A good

place to start is the [Plotter class](https://djipco.github.io/hpgl/Plotter.html). If you find

errors, please [file an issue](https://github.com/djipco/hpgl/issues) on GitHub.



## Support the Project



If you find this library useful, you can 💜 [**sponsor the project**](https://github.com/sponsors/djipco)

as a token of your appreciation. This would automatically make you even more awesome than you already 

are!



Cheers!