Skip to main content
100%

node server for talking to XY Plotter

✓ Published0🌍 Public
Aaman-tiwari
Last edited Jun 17, 2016
Created on Jun 17, 2016

A Node.js server translates incoming JSON coordinates from a web client into GCODE commands for a serial-connected XY plotter. It listens on port 8999, parses POST requests with `x` and `y` floats, flips the coordinate system, and writes movement commands like `G1 X... Y...` via the `serialport` library. The server also issues pen-up/down commands (`M2 U/D`) and homes the plotter after each point, with optional CORS headers enabled. The code uses `body-parser` for JSON handling and logs serial port data.

AI-generated description

Similar vizzes

Loading thumbnail…

Node + MySQL + JSON

This example demonstrates a Node.js server that serves JSON data from a MySQL database to a front-end visualization. It sets the server’s timezone to UTC and uses Express to handle HTTP requests, with the `connect-gzip` middleware compressing responses. A GET endpoint for `/things/:id.json` queries a MySQL table named `things` via the `mysql` client, selecting fields like `name`, `favorite_color`, and `airspeed_velocity` based on the numeric ID from the URL, then returns the result as JSON. The code shows a direct pipeline from database query to API response, ready for consumption by a client-side chart.

Mmbostock
59% match
Loading thumbnail…

Node.js server for composing map tiles using modestmaps.js

This example demonstrates a Node.js server that dynamically composes map tiles into a single static image. The HTTP endpoint `/map` accepts zoom, latitude, longitude, width, and height parameters, then uses the modestmaps.js library to calculate which tiles are needed, fetches them via the `get` library, and draws them onto a Canvas using the `canvas` package. The OpenStreetMap tile provider is referenced directly, and the final composite is returned as a PNG.

RRandomEtc
54% match
Loading thumbnail…

Directly render and serve d3 visualizations from a nodejs server.

This example demonstrates how to render D3 visualizations directly from a Node.js server, showing a line chart of normally distributed sample data. The server uses Node’s HTTP module and the D3.js library to generate SVG markup programmatically, then sends it to the browser as an `image/svg+xml` response. It constructs linear scales (`d3.scale.linear`), axes (`d3.svg.axis`), and a basis-interpolated line (`d3.svg.line`) entirely on the server side. The visualization is styled with simple SVG attributes, and the data is randomly generated via `d3.random.normal`, highlighting a server-side rendering approach where all D3 computations and SVG generation occur in Node before transmission.

CCaged
54% match
Loading thumbnail…

Gist 75fe6f98cacb874f8d9ebce7248b1b66

This example presents a web-based client-server application that serves static files and handles socket connections. The server is built with Express and Socket.IO, listening on a configurable port, and delegates all routes to a single `index.html` file. It uses the `body-parser` middleware for JSON parsing and the `path` module to resolve file locations. The rendering approach is not specified, but the code clearly establishes the infrastructure for delivering a front-end visualization, with the server acting as the backbone for real-time communication and static asset delivery.

RRonolibert
54% match
Loading thumbnail…

Node.js app to harvest a georss feed into CartoDB

A Node.js app harvests live GeoRSS incident reports from Portland’s 911 feed and inserts new records into a CartoDB table. The animation shows a continuously updating map of emergency locations as fresh entries are parsed from XML using `xml2js`, then posted via CartoDB’s SQL API with `http.request`. Each feed item’s title, timestamps, category label, and point coordinates are extracted and formatted into an SQL `VALUES` insert, skipping duplicates. The process runs repeatedly, appending visible points to the map over time.

Aandrewxhill
54% match
Loading thumbnail…

Express server and serial port reading

This example shows a live data pipeline that reads sensor values from an Arduino over a serial port and exposes them through a simple HTTP endpoint. The Arduino sketch generates random temperatures between -5 and 15 degrees Celsius every five seconds and prints them to the serial monitor. Two JavaScript libraries, `serialport` and `express`, handle the communication: the serial port parser (`serialport.parsers.Readline`) captures each line of incoming data, while the Express server responds to root requests with the latest stored value. The result is a minimal web page displaying the current temperature reading.

SServuc
53% match
Loading thumbnail…

Gist c8fa96678eda5a2e92a93b8777bf1e1a

This example uses a custom JavaScript implementation with the D3.js library to render a small collection of user-supplied x,y coordinates as a scatterplot. The code computes an attraction-repulsion force simulation via a bespoke `d3.forceSimulation`-like routine, drawing nodes and connecting edges on an SVG canvas. The five data points (100,100; 130,120; 80,180; 180,80; 180,40) are displayed without axes or labels, clearly showing their relative spatial arrangement and the network structure formed by the force-directed layout. The rendering relies on SVG `<circle>` and `<line>` elements, with interaction limited to the static initial placement.

JJuannovo
53% match
Loading thumbnail…

Gist 660bf021ec250dfb10016d384d524bd7

This example shows a real-time chat application where users exchange messages through a Node.js server. The visualization tracks message flow and user activity using a force-directed graph rendered with D3.js’s `d3.forceSimulation` for node positioning and link physics. Each user appears as a node, with edges connecting them to messages they send, while color and size encode online status and message frequency. The code uses Socket.IO for live data updates and D3’s `transition.attrTween` to animate new nodes and links smoothly as events arrive, making the conversation pattern immediately visible.

FFrankieFabuloso
52% match