rpi-io 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -1,4 +1,11 @@
 # Changelog
+
+## [3.1.0] - 2026-07-22
+### Changed
+- log utility refactored
+### Added
+- extension classes for unipolar and bipolar stepper motors
+
 ## [3.0.0] - 2026-07-18
 ### Added
 - methods **pulseStart**(*count, edge, options*) and **pulseStop**() for output lines

package/README.md

@@ -1,7 +1,7 @@
 # rpi-io
 ![Static Badge](https://img.shields.io/badge/rpi--io-_3.y.z_-FF5500?style=flat) ![Static Badge](https://img.shields.io/badge/Nodejs-%3E_23-66cc33?logo=nodedotjs&logoColor=white) ![Static Badge](https://img.shields.io/badge/NPM-%3E_10-CC3534?logo=npm&logoColor=white) ![Static Badge](https://img.shields.io/badge/Raspberry_Pi-Zero2_4B_5B-C51A4A?logo=raspberrypi&logoColor=white) ![Static Badge](https://img.shields.io/badge/OS-Bookworm_Trixie-0D7AB9?style=flat)
 
-Current version is 3.0.0. The latest update introduces pulse sequence management methods for output lines. See [CHANGELOG.md](CHANGELOG.md) and documentation folder.
+Current version is 3.1.0. This version takes advantage of the *pulseStart()* and *pulseStop()* methods introduced in version 3.0.0 to propose extension classes for stepper motor control. See [extension](https://github.com/gdorbes/rpi-io/tree/master/extensions) and [documentation](https://github.com/gdorbes/rpi-io/tree/master/documentation) folders.
 
 **rpi-io** is a lite [ESM](https://nodejs.org/api/esm.html#modules-ecmascript-modules) module for **Node.js** to control **Raspberry Pi** GPIO: access (in, out), input event detection and [PWM](https://en.wikipedia.org/wiki/Pulse-width_modulation) peripheral control.
 
@@ -169,7 +169,7 @@ setTimeout(()=>{
 }, 5000)
 ```
 
-Pulse sequence
+##### Pulse sequence
 
 ```js
 import {RIO} from "rpi-io"

package/documentation/api.md

@@ -114,7 +114,7 @@ myOutput.pulseStart(10, "asc", {
 ```javascript
 {
   pulseWidth: 10, // pulse width in µs
-  spaceWidth: 10  // space beween pulses in µs
+  spaceWidth: 10  // space between pulses in µs
 }
 ```
 
@@ -321,7 +321,6 @@ log("This is useful info")
 ```
 
 
-
 ###  sleep(time)
 
 Similar to `setTimeout` but in async mode.

package/documentation/stepper-motor.md

@@ -0,0 +1,192 @@
+# Stepper Motor Extensions
+
+Using the basic **rpi-io** methods for output  lines (*write*, *pulseStart*, *pulseStop*), it is easy to drive stepper motors, ranging from simple hobbyist motors (e.g., 28BYJ-48) to those designed for robotics and industrial applications, such as the NEMA series (e.g., NEMA 17, 23...) using some hardware driver (e.g. DMA542).
+
+To facilitate this type of use, since version 3.1 **rpi-io** has included two stepper motor controller classes:
+
+- The *StepperUnipolar* class is intended for stepper motors without a hardware driver.
+- The *StepperBipolar* class is intended for stepper motors with a hardware driver such as the DM542.
+
+
+
+## class StepperUnipolar
+
+### Electronic wiring example
+
+![](https://rpisquare.com//img/stepper-unipolar.png)
+
+PLEASE NOTE:
+
+- **GND is shared** — the Pi's GND and the ULN2003's GND must be tied together even if you power the motor from a separate supply, or the signals won't have a common reference.
+
+- **Power source for VCC**: for light loads the Pi's 5V pin can drive the ULN2003/motor directly, but the 28BYJ-48 can draw enough current that it's safer to power VCC from a separate 5V supply, keeping only GND common with the Pi.
+
+- The four GPIO pins (17, 18, 27, 22) are just a common convention — any four free GPIO pins work, as long as your code (e.g. via `RPi.GPIO` or `gpiozero`) references the pins you actually wired.
+
+- The ULN2003 board's output side connects to the motor with its keyed 5-pin connector — it only fits one way, so no wiring decisions needed there.
+
+
+
+### Example
+
+See test [script](https://github.com/gdorbes/rpi-io/blob/master/test/stepper-motor-unipolar.js).
+
+```js
+import {StepperUnipolar, RIO, traceCfg, log, warn, sleep} from "../extensions/stepper-unipolar.mjs"
+
+traceCfg(2)
+
+// Open step controller in half step mode => Half turn forward and backward => Close
+const motor28BYJH = new StepperUnipolar(new RIO(21, "output"), new RIO(22, "output"), new RIO(24, "output"), new RIO(25, "output"), "half", 0)
+log("motor28BYJH creation status:", motor28BYJH.status)
+await motor28BYJH.rotate(2048, "forward", false)
+await motor28BYJH.rotate(2048, "backward", false)
+motor28BYJH.close()
+
+// Open step controller in full step mode => Half turn forward and backward => Close
+const motor28BYJF = new StepperUnipolar(new RIO(21, "output"), new RIO(22, "output"), new RIO(24, "output"), new RIO(25, "output"), "full", 4)
+log("motor28BYJF creation status:", motor28BYJF.status)
+await motor28BYJF.rotate(1024, "forward", false)
+await motor28BYJF.rotate(1024, "backward", false)
+motor28BYJF.close()
+```
+
+
+
+### API
+
+#### constructor StepperUnipolar(coilA, coilB, coilC, coilD, mode, delay)
+
+**Parameter(s)**
+
+- **coilA** *{Object}* **rpi-io** instance for Coil A
+
+- **coilB** *{Object}* **rpi-io** instance for Coil B
+
+- **coilC** *{Object}* **rpi-io** instance for Coil C
+
+- **coilD** *{Object}* **rpi-io** instance for Coil D
+
+- ##### **mode** *{'half','full'}* sequence mode: half step or full step
+
+- **delay** *{Number}* delay in ms between steps
+
+
+
+**Return** *{Object}* StepperUnipolar instance
+
+
+
+#### rotate(steps, direction, showStep)
+
+**Parameter(s)**
+
+- **steps** *{Number}* 
+- **direction** *{'forward'|'backward"'* 
+- **showStep** *{Boolean}* ** to display step in console (default = false)
+
+**Return** *{Promise}* 
+
+
+
+#### close()
+
+To disable coils and close rpi-io instances.
+
+
+
+## class StepperBipolar
+
+### Electronic wiring example
+
+![](https://rpisquare.com//img/stepper-bipolar.png)
+
+PLEASE NOTE:
+
+- **The junction dot** is where the Pi's 5V pin splits into two wires, tying PUL+ and DIR+ together onto one common rail.
+
+- **STEP and DIR switch low to trigger**, since GPIO pulls PUL- or DIR- down relative to the shared +5V. 
+
+- **Voltage margin is tight**: the Pi's GPIO output high is 3.3V, but the common rail here is 5V, giving only ~1.7V across the optocoupler when "off" — close to some optocouplers' turn-off threshold. Many builds get away with this, but if you see erratic stepping consider using a Darlington array (e.g. ULN2003) between RPi and DM542.
+
+- **ENA+/ENA-** would follow the same common-anode pattern if you wire it — tied into the same 5V junction, with a GPIO pin driving ENA- low to enable.
+
+
+
+### Example
+
+See test [script](https://github.com/gdorbes/rpi-io/blob/master/test/stepper-motor-bipolar.js).
+
+```js
+import {StepperBipolar, RIO, traceCfg, log, warn, sleep, ctrlC} from "../extensions/stepper-bipolar.mjs"
+
+traceCfg(2)
+
+ctrlC(() => {
+    RIO.closeAll()
+})
+
+// Open output lines GPIO21 and GPIO22
+const pul = new RIO(21, "output", {value: 0})
+const dir = new RIO(22, "output", {value: 0})
+
+// Create Bipolar Stepper Motor instance
+const bipolar = new StepperBipolar(pul, dir, "desc", 10)
+
+// Start rotating full turn (depending on hardware driver settings)
+bipolar.rotate(25600, "forward").then(stepped => {
+    log("stepped:", stepped)
+    // Reset and close lines
+    pul.write(0)
+    dir.write(0)
+    pul.close()
+    dir.close()
+})
+
+// Stop rotation after 200ms
+await sleep(200)
+log("stop rotation")
+bipolar.stop()
+```
+
+
+
+### API
+
+#### constructor StepperBipolar(pul, dir, edge, width)
+
+**Parameter(s)**
+
+- **pul** *{Object}* **rpi-io** instance for pulse pin
+
+- **dir** *{Object}* **rpi-io** instance for direction pin
+
+- ##### **edge** *{'desc','asc'}* pulse active edge: descending or ascending
+
+- **width** *{Number}* pulse width and space between two edges in µs 
+
+**Return** *{Object}* StepperBipolar instance
+
+
+
+#### rotate(steps, direction)
+
+**Parameter(s)**
+
+- **steps** *{Number}* 
+- **direction** *{'forward'|'backward"'* 
+- **showStep** *{Boolean}* ** to display step in console (default = false)
+
+**Return** *{Promise<{elapsedMs: number, pulsesCompleted: number, stopped: boolean}>}* 
+
+
+
+#### stop()
+
+To interrupt an ongoing pulse sequence if one is in progress.
+
+
+
+#### close()
+
+To disable *pul* and *dir* rpi-io instances.

package/esm/log.mjs

@@ -1,58 +1,48 @@
 // -------------------------------------------------------------------
 // RPI-IO: Custom console.log
 // -------------------------------------------------------------------
-let debug = {
-    trace: false,
-    warn: true
+const noop = function () {
 }
-
+export let log = noop
+export let warn = noop
 /** ------------------------------------------------------------------
  * @function traceCfg
  * @description Set log configuration
  * @param {Number} level    0: no log, 1: warn only, 2: warn and log
  */
 export const traceCfg = level => {
-    debug = {
-        trace: false,
-        warn: false
-    }
-    level > 1 ? debug.trace = true : false
-    level > 0 ? debug.warn = true : false
-}
 
-/** ------------------------------------------------------------------
- * @function nowStr
- * @description Return timestamp as formatted string
- * @return {String}
- */
-const nowStr = () => {
-    const date = new Date()
-    return date.toLocaleTimeString() + "." + date.getMilliseconds().toLocaleString('en', {
-        minimumIntegerDigits: 3,
-        minimumFractionDigits: 0,
-        useGrouping: false
-    })
-}
-
-/** ------------------------------------------------------------------
- * @function log
- * @description Global customized timestamped console.log
- *              Requires global variable 'debug'
- */
-export const log = function () {
-    if (debug.trace)
+    const nowStr = () => {
+        const date = new Date()
+        return date.toLocaleTimeString() + "." + date.getMilliseconds().toLocaleString('en', {
+            minimumIntegerDigits: 3,
+            minimumFractionDigits: 0,
+            useGrouping: false
+        })
+    }
+    const timeStamped = function () {
         console.log.apply(console, Array.prototype.concat.apply([nowStr(), "🔎 "], arguments))
-}
+    }
+    const timeColored = function () {
+        console.log.apply(console, Array.prototype.concat.apply([nowStr(), "⚠️ ", "\x1b[38;2;255;80;0m", ...arguments, "\x1b[0m"]))
+    }
 
-/** ------------------------------------------------------------------
- * @function warn
- * @description Colored log for error messages ⚠️ nodejs only ~ CSS color #F50
- */
-export const warn = function () {
-    if (debug.warn)
-        console.log.apply(console, Array.prototype.concat.apply([nowStr(), "⚠️", "\x1b[38;2;255;80;0m", ...arguments, "\x1b[0m"]))
+    switch (level) {
+        case 2:
+            warn = timeColored
+            log = timeStamped
+            break
+        case 1:
+            warn = timeColored
+            log = noop
+            break
+        default:
+            warn = noop
+            log = noop
+    }
 }
 
+
 // -------------------------------------------------------------------
 // EoF
 // -------------------------------------------------------------------

package/extensions/stepper-bipolar.mjs

@@ -0,0 +1,131 @@
+// -------------------------------------------------------------------
+// RPI-IO: BIPOLAR STEPPER MOTOR EXTENSION
+// -------------------------------------------------------------------
+import {RIO, traceCfg, log, warn, sleep, ctrlC} from "../esm/main.mjs"
+
+export {RIO, traceCfg, log, warn, sleep, ctrlC}
+
+/** ------------------------------------------------------------------
+ * @class StepperBipolar
+ * @description Class definition for Bipolar Stepper motors.
+ * Bipolar stepper motors (e.g. NEMA 17 or 23) require hardware driver
+ * such as DM542 or equilavent depending on motor power
+ */
+export class StepperBipolar {
+
+    static STATUS_MSG = {
+        0: "none",
+        11: "pul or dir rpi-io instance definition is missing",
+        12: "At least one rpi-io instance is not valid",
+        13: "Wrong edge {'asc','desc'}",
+        14: "Wrong pulse width (5 ≤ p ≤ 10,000,000)",
+        200: "ok"
+    }
+
+    static EDGES = ["desc", "asc"]
+
+    // Private method: Update instance status
+    #setStatus(code, data) {
+        this.status.code = code
+        this.status.msg = StepperBipolar.STATUS_MSG[code]
+        this.status.data = data
+    }
+
+    /** ------------------------------------------------------------------
+     * @method constructor
+     * @param {Object} pul           // rpi-io output instance for pulse pin
+     * @param {Object} dir           // rpi-io output instance for direction pin
+     * @param {"desc"|"asc"} edge    // pulse active edge: descending or ascending
+     * @param {Number} width         // pulse width and space between two edges in µs
+     */
+    constructor(pul, dir, edge, width) {
+
+        // Init instance construction status
+        this.status = {
+            code: 0,
+            msg: StepperBipolar.STATUS_MSG[0],
+            data: ""
+        }
+
+        // ERR11: pul or pir rpi-io instance definition is missing
+        if (typeof pul === "undefined" || typeof dir === "undefined") {
+            this.#setStatus(11, "")
+            RIO.closeAll()
+            return
+        }
+
+        // ERR12: At least one coil port rpi-io instance is not valid
+        try {
+            pul.write(0)
+            dir.write(0)
+        } catch (err) {
+            this.#setStatus(12, "")
+            RIO.closeAll()
+            return
+        }
+
+        // ERR13: Wrong edge {'asc','desc'}
+        if (StepperBipolar.EDGES.indexOf(edge) === -1) {
+            this.#setStatus(13, edge)
+            RIO.closeAll()
+            return
+        }
+
+        // ERR14: Wrong pulse width (5 ≤ p ≤ 10,000,000)
+        if (typeof width !== "number" || width < 5 || width > 10000000) {
+            this.#setStatus(14, width)
+            RIO.closeAll()
+            return
+        }
+
+        // Test successfully completed  => Init properties
+        this.ioPulse = pul
+        this.ioDir = dir
+        this.edge = edge
+        this.width = width
+        this.#setStatus(200, "")
+    }
+
+    /** ------------------------------------------------------------------
+     * @method rotate
+     * @description Rotate the motor a certain number of steps forward or backward.
+     *              Full rotation depends on hardware driver settings.
+     * @param {Number} steps
+     * @param {"forward"|"backward"} direction
+     * @return {Promise<{elapsedMs: number, pulsesCompleted: number, stopped: boolean}>}
+     */
+    async rotate(steps, direction) {
+
+        // Set direction
+        this.ioDir.write("forward" ? 1 : 0)
+
+        // Start rotation
+        log("starting rotation:", steps, "steps", direction)
+        return await this.ioPulse.pulseStart(steps, this.edge, {
+            pulseWidth: this.width,
+            spaceWidth: this.width,
+        })
+    }
+
+    /** ------------------------------------------------------------------
+     * @method stop
+     * @description Immediately interrupts an ongoing pulse sequence if one is in progress.
+     */
+    stop() {
+        this.ioPulse.pulseStop()
+    }
+
+    /** ------------------------------------------------------------------
+     * @method close
+     * @description Disable pul and dir rpi-io instances used for this step motor controller
+     */
+    close() {
+        this.ioPulse.close
+        this.ioDir.close
+        log("Bipolar controller closed")
+    }
+}
+
+// -------------------------------------------------------------------
+// EoF
+// -------------------------------------------------------------------

package/extensions/stepper-unipolar.mjs

@@ -0,0 +1,172 @@
+// -------------------------------------------------------------------
+// RPI-IO: UNIPOLAR STEPPER MOTOR EXTENSION
+// -------------------------------------------------------------------
+import {RIO, traceCfg, log, warn, sleep} from "../esm/main.mjs"
+
+export {RIO, traceCfg, log, warn, sleep}
+
+/** ------------------------------------------------------------------
+ * @class StepperUnipolar
+ * @description Class definition for Unipolar Stepper motors.
+ * Unipolar stepper motors (e.g. 28BYJ-48) are directly controlled by  RPi using
+ * a Darlington Transistor Array (e.g. ULN2003)
+ */
+export class StepperUnipolar {
+
+    static STATUS_MSG = {
+        0: "none",
+        11: "At least one coil port rpi-io instance definition is missing",
+        12: "At least one coil port rpi-io instance is not valid",
+        13: "Wrong delay parameter value (0 ≤ d ≤ 1000)",
+        14: "Wrong Unipolar sequence {'full','half'}",
+        200: "ok"
+    }
+    static MODE = ["half", "full"]
+    static STEPS = {
+        half: [
+            [1, 0, 0, 0],
+            [1, 1, 0, 0],
+            [0, 1, 0, 0],
+            [0, 1, 1, 0],
+            [0, 0, 1, 0],
+            [0, 0, 1, 1],
+            [0, 0, 0, 1],
+            [1, 0, 0, 1]
+        ],
+        full: [
+            [1, 0, 0, 1],
+            [1, 1, 0, 0],
+            [0, 1, 1, 0],
+            [0, 0, 1, 1]
+        ]
+    }
+
+    // Private method: Update instance status
+    #setStatus(code, data) {
+        this.status.code = code
+        this.status.msg = StepperUnipolar.STATUS_MSG[code]
+        this.status.data = data
+    }
+
+    /** ------------------------------------------------------------------
+     * @method constructor
+     * @param {Object} coilA         // rpi-io output instance for CoilA
+     * @param {Object} coilB         // rpi-io output instance for CoilB
+     * @param {Object} coilC         // rpi-io output instance for CoilC
+     * @param {Object} coilD         // rpi-io output instance for CoilD
+     * @param {"half"|"ful"} mode    // Full or half step sequence
+     * @param {Number} delay         // Delay between steps in ms
+     */
+    constructor(coilA, coilB, coilC, coilD, mode = "half", delay = 10) {
+
+        // Init instance construction status
+        this.status = {
+            code: 0,
+            msg: StepperUnipolar.STATUS_MSG[0],
+            data: ""
+        }
+
+        // ERR11: At least one coil port rpi-io instance definition is missing
+        if (typeof coilA === "undefined" || typeof coilB === "undefined" || typeof coilC === "undefined" || typeof coilD === "undefined") {
+            this.#setStatus(11, "")
+            RIO.closeAll()
+            return
+        }
+
+        // ERR12: At least one coil port rpi-io instance is not valid
+        try {
+            coilA.write(0)
+            coilB.write(0)
+            coilC.write(0)
+            coilD.write(0)
+        } catch (err) {
+            this.#setStatus(12, "")
+            RIO.closeAll()
+            return
+        }
+
+        // ERR13: Wrong delay parameter value (0 ≤ d ≤ 1000)
+        if (typeof delay !== "number" || delay < 0 || delay > 1000) {
+            this.#setStatus(13, delay)
+            RIO.closeAll()
+            return
+        }
+
+        // ERR14: Wrong mode {'full','half'}
+        if (StepperUnipolar.MODE.indexOf(mode) === -1) {
+            this.#setStatus(14, mode)
+            RIO.closeAll()
+            return
+        }
+
+        // Test successfully completed  => Init properties
+        this.coils = {
+            a: coilA,
+            b: coilB,
+            c: coilC,
+            d: coilD,
+        }
+        this.sequence = StepperUnipolar.STEPS[mode]
+        this.len = this.sequence.length
+        this.delay = delay
+        this.index = 0
+        this.increment = 0
+        this.#setStatus(200, "")
+    }
+
+    /** ------------------------------------------------------------------
+     * @method rotate
+     * @description Rotate the motor a certain number of steps forward or backward.
+     *              Full rotation depends on selected mode.
+     * @param {Number} steps
+     * @param {"forward"|"backward"} direction
+     * @param {Boolean} showStep
+     */
+    async rotate(steps, direction, showStep = false) {
+
+        this.increment = direction === "forward" ? 1 : -1
+
+        log("starting rotation:", steps, "steps", direction)
+
+        // Rotate
+        for (let i = 0; i < steps; i++) {
+            const [a, b, c, d] = this.sequence[this.index]
+            if (showStep) {
+                log("rotation step:", i, [a, b, c, d])
+            }
+            this.coils.a.write(a)
+            this.coils.b.write(b)
+            this.coils.c.write(c)
+            this.coils.d.write(d)
+
+            this.index = ((this.index + this.increment % this.len + this.len) % this.len)
+            await sleep(this.delay, false)
+        }
+
+        // Disable coils
+        this.coils.a.write(0)
+        this.coils.b.write(0)
+        this.coils.c.write(0)
+        this.coils.d.write(0)
+    }
+
+    /** ------------------------------------------------------------------
+     * @method close
+     * @description Disable coils and close rpi-io instances used for this step motor controller
+     */
+    close() {
+        this.coils.a.write(0)
+        this.coils.b.write(0)
+        this.coils.c.write(0)
+        this.coils.d.write(0)
+        this.coils.a.close()
+        this.coils.b.close()
+        this.coils.c.close()
+        this.coils.d.close()
+        log("Unipolar controller closed")
+    }
+}
+
+// -------------------------------------------------------------------
+// EoF
+// -------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rpi-io",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Nodejs module to control Raspberry Pi GPIO",
   "keywords": [
     "raspberry",
@@ -18,7 +18,11 @@
     "bookworm",
     "trixie",
     "iot",
-    "embedded"
+    "embedded",
+    "motor",
+    "stepper",
+    "motor control",
+    "stepper motor"
   ],
   "homepage": "https://github.com/gdorbes/rpi-io#readme",
   "bugs": {

package/test/log-warn.js

@@ -0,0 +1,41 @@
+// -------------------------------------------------------------------
+// TEST CUSTOM CONSOLE
+// -------------------------------------------------------------------
+import {traceCfg, log, warn} from "../esm/log.mjs"
+
+// Default behavior: No console
+log("nothing")
+warn("nothing")
+
+// Full console
+traceCfg(2)
+log("console display")
+warn("warning display")
+
+// Warning only
+traceCfg(1)
+log("not displayed")
+warn("warning display again")
+
+// Back to no console
+traceCfg(0)
+log("nothing again")
+warn("nothing again")
+
+// Full console
+traceCfg(2)
+log("console display again")
+warn("warning display again")
+
+// Warning only
+traceCfg(1)
+log("not displayed")
+warn("warning display again again")
+
+// Back to no console
+traceCfg(0)
+log("nothing again")
+warn("nothing again")
+// -------------------------------------------------------------------
+// EoF
+// -------------------------------------------------------------------

package/test/stepper-motor-bipolar.js

@@ -0,0 +1,36 @@
+// -------------------------------------------------------------------
+// RPI-IO: BIPOLAR STEPPER MOTOR TEST - DM542 HARDWARE DRIVER
+// -------------------------------------------------------------------
+import {StepperBipolar, RIO, traceCfg, log, warn, sleep, ctrlC} from "../extensions/stepper-bipolar.mjs"
+
+traceCfg(2)
+
+ctrlC(() => {
+    RIO.closeAll()
+})
+
+// Open output lines GPIO21 and GPIO22
+const pul = new RIO(21, "output", {value: 0})
+const dir = new RIO(22, "output", {value: 0})
+
+// Create Bipolar Stepper Motor instance
+const bipolar = new StepperBipolar(pul, dir, "desc", 10)
+
+// Start rotating full turn (depending on hardware driver settings)
+bipolar.rotate(25600, "forward").then(stepped => {
+    log("stepped:", stepped)
+    // Reset and close lines
+    pul.write(0)
+    dir.write(0)
+    pul.close()
+    dir.close()
+})
+
+// Stop rotation after 200ms
+await sleep(200)
+log("stop rotation")
+bipolar.stop()
+
+// -------------------------------------------------------------------
+// EoF
+// -------------------------------------------------------------------

package/test/stepper-motor-unipolar.js

@@ -0,0 +1,24 @@
+// -------------------------------------------------------------------
+// RPI-IO: UNIPOLAR STEPPER MOTOR TEST
+// -------------------------------------------------------------------
+import {StepperUnipolar, RIO, traceCfg, log, warn, sleep} from "../extensions/stepper-unipolar.mjs"
+
+traceCfg(2)
+
+// Open step controller in half step mode => Half turn forward and backward => Close
+const motor28BYJH = new StepperUnipolar(new RIO(21, "output"), new RIO(22, "output"), new RIO(24, "output"), new RIO(25, "output"), "half", 0)
+log("motor28BYJH creation status:", motor28BYJH.status)
+await motor28BYJH.rotate(2048, "forward", false)
+await motor28BYJH.rotate(2048, "backward", false)
+motor28BYJH.close()
+
+// Open step controller in full step mode => Half turn forward and backward => Close
+const motor28BYJF = new StepperUnipolar(new RIO(21, "output"), new RIO(22, "output"), new RIO(24, "output"), new RIO(25, "output"), "full", 4)
+log("motor28BYJF creation status:", motor28BYJF.status)
+await motor28BYJF.rotate(1024, "forward", false)
+await motor28BYJF.rotate(1024, "backward", false)
+motor28BYJF.close()
+
+// -------------------------------------------------------------------
+// EoF
+// -------------------------------------------------------------------

package/esm/step.mjs

@@ -1,212 +0,0 @@
-// -------------------------------------------------------------------
-// RPI-IO: STEP MOTOR EXTENSION ⚠️ Work in Progress
-// -------------------------------------------------------------------
-import {RIO} from "./main.mjs";
-// -------------------------------------------------------------------
-// UTILITY FUNCTIONS
-/** ------------------------------------------------------------------
- * @function tlog
- * @description Timestamped console.log
- */
-export function tlog() {
-    const date = new Date()
-    const nowMs = date.toLocaleTimeString() + "." + date.getMilliseconds().toLocaleString('en', {
-        minimumIntegerDigits: 3,
-        minimumFractionDigits: 0,
-        useGrouping: false
-    })
-    console.log.apply(console, Array.prototype.concat.apply([nowMs, "🔎 "], arguments))
-}
-
-/** ------------------------------------------------------------------
- * @function wait
- * @description Wait ms as a promise and optional tlog
- * @param {Number} ms
- * @param {Boolean} logWait
- */
-export function wait(ms, logWait = true) {
-    logWait ? tlog("sleeping", ms, "ms") : false
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-export class STEP {
-
-    static STATUS_MSG = {
-        0: "none",
-        1: "Unknown driver name",
-        11: "At least one coil port rpi-io instance definition is missing",
-        12: "At least one coil port rpi-io instance is not valid",
-        13: "Wrong delay parameter value (0 ≤ d ≤ 1000)",
-        14: "Wrong ULN2003 sequence {'full','half'}",
-        200: "ok"
-    }
-    static ULN2003_MODE = ["half", "full"]
-    static ULN2003_STEPS = {
-        half: [
-            [1, 0, 0, 0],
-            [1, 1, 0, 0],
-            [0, 1, 0, 0],
-            [0, 1, 1, 0],
-            [0, 0, 1, 0],
-            [0, 0, 1, 1],
-            [0, 0, 0, 1],
-            [1, 0, 0, 1]
-        ],
-        full: [
-            [1, 0, 0, 1],
-            [1, 1, 0, 0],
-            [0, 1, 1, 0],
-            [0, 0, 1, 1]
-        ]
-    }
-
-    // Private method: Update instance status
-    #setStatus(code, data) {
-        this.status.code = code
-        this.status.msg = STEP.STATUS_MSG[code]
-        this.status.data = data
-    }
-
-    /** ------------------------------------------------------------------
-     * @method constructor
-     * @param {String} driver       // Supported driver name
-     * @param {Object} rios         // rpi-io Instance container depending on driver
-     * @param {Object} opt          // Options depending on driver
-     */
-    constructor(driver, rios, opt) {
-
-        const defopt = {
-            // Parameters for ULN2003
-            delay: 10,
-            sequence: "half"
-        }
-        opt = {...defopt, ...opt}
-
-        // Init instance construction status
-        this.status = {
-            code: 0,
-            msg: STEP.STATUS_MSG[0],
-            data: ""
-        }
-
-        // Test parameters depending on driver
-        switch (driver) {
-            case "uln2003":
-
-                // ERR11: At least one coil port rpi-io instance definition is missing
-                if (typeof rios.coilA === "undefined" || typeof rios.coilB === "undefined" || typeof rios.coilC === "undefined" || typeof rios.coilD === "undefined") {
-                    this.#setStatus(11, "")
-                    RIO.closeAll()
-                    return
-                }
-
-                // ERR12: At least one coil port rpi-io instance is not valid
-                try {
-                    rios.coilA.write(0)
-                    rios.coilB.write(0)
-                    rios.coilC.write(0)
-                    rios.coilD.write(0)
-                } catch (err) {
-                    this.#setStatus(12, "")
-                    RIO.closeAll()
-                    return
-                }
-
-                // ERR13: Wrong delay parameter value (0 ≤ d ≤ 1000)
-                if (typeof opt.delay !== "number" || opt.delay < 0 || opt.delay > 1000) {
-                    this.#setStatus(13, opt.delay)
-                    RIO.closeAll()
-                    return
-                }
-
-                // ERR14: Wrong ULN2003 sequence {'full','half'}
-                if (STEP.ULN2003_MODE.indexOf(opt.sequence) === -1) {
-                    this.#setStatus(14, opt.sequence)
-                    RIO.closeAll()
-                    return
-                }
-
-                // Test successfully completed  => Init properties
-                this.driver = "uln2003"
-                this.props = {
-                    a: rios.coilA,
-                    b: rios.coilB,
-                    c: rios.coilC,
-                    d: rios.coilD,
-                    sequence: STEP.ULN2003_STEPS[opt.sequence],
-                    len: STEP.ULN2003_STEPS[opt.sequence].length,
-                    delay: opt.delay,
-                    inc: 0,
-                    index: 0
-                }
-                this.#setStatus(200, "")
-                break
-            default:
-                this.#setStatus(1, driver)
-        }
-    }
-
-    /** ------------------------------------------------------------------
-     * @method rotate
-     * @description Rotate the motor a certain number of steps forward or backward.
-     *              A full rotation consists of 200 steps.
-     * @param {Number} steps
-     * @param {"forward"|"backward"} direction
-     * @param {Boolean} showStep
-     */
-    async rotate(steps, direction, showStep = false) {
-
-        switch (this.driver) {
-            case "uln2003":
-                this.props.inc = direction === "forward" ? 1 : -1
-
-                tlog("starting rotation:", steps, "steps", direction)
-
-                // Rotate
-                for (let i = 0; i < steps; i++) {
-                    const [a, b, c, d] = this.props.sequence[this.props.index]
-                    if (showStep) {
-                        tlog("rotation step:", i, [a, b, c, d])
-                    }
-                    this.props.a.write(a)
-                    this.props.b.write(b)
-                    this.props.c.write(c)
-                    this.props.d.write(d)
-
-                    this.props.index = ((this.props.index + this.props.inc) % this.props.len + this.props.len) % this.props.len
-                    await wait(this.props.delay, false)
-                }
-
-                // Disable coils
-                this.props.a.write(0)
-                this.props.b.write(0)
-                this.props.c.write(0)
-                this.props.d.write(0)
-        }
-    }
-
-    /** ------------------------------------------------------------------
-     * @method close
-     * @description Disable coils and close rpi-io instances used for step motor controller
-     */
-    close() {
-
-        switch (this.driver) {
-            case "uln2003":
-                this.props.a.write(0)
-                this.props.b.write(0)
-                this.props.c.write(0)
-                this.props.d.write(0)
-                this.props.a.close()
-                this.props.b.close()
-                this.props.c.close()
-                this.props.d.close()
-                tlog("ULN2003 controller closed")
-        }
-    }
-}
-
-
-// -------------------------------------------------------------------
-// EoF
-// -------------------------------------------------------------------

package/test/step-motor.js

@@ -1,59 +0,0 @@
-// -------------------------------------------------------------------
-// RPI-IO: STEP MOTOR TEST SCRIPT ⚠️ Work in Progress
-// -------------------------------------------------------------------
-import {RIO} from "../esm/main.mjs";
-import {STEP, tlog} from "../esm/step.mjs"
-
-// Close any open rpi-io instance to prevent error
-RIO.closeAll()
-
-// Open step controller in half step mode => Half turn forward and backward => Close
-const motor28BYJH = new STEP("uln2003", {
-    coilA: new RIO(21, "output"),
-    coilB: new RIO(22, "output"),
-    coilC: new RIO(24, "output"),
-    coilD: new RIO(25, "output")
-}, {
-    delay: 0,
-    sequence: "half"
-})
-tlog("motor28BYJH creation status:", motor28BYJH.status)
-await motor28BYJH.rotate(2048, "forward", false)
-await motor28BYJH.rotate(2048, "backward", false)
-motor28BYJH.close()
-
-// Open step controller in full step mode => Half turn forward and backward => Close
-const motor28BYJF = new STEP("uln2003", {
-    coilA: new RIO(21, "output"),
-    coilB: new RIO(22, "output"),
-    coilC: new RIO(24, "output"),
-    coilD: new RIO(25, "output")
-}, {
-    delay: 4,
-    sequence: "full"
-})
-tlog("motor28BYJF creation status:", motor28BYJF.status)
-await motor28BYJF.rotate(1024, "forward", false)
-await motor28BYJF.rotate(1024, "backward", false)
-motor28BYJF.close()
-
-// A4988 drivers require one line per parameter as in the example below
-const a4988 = {
-    pulse: new RIO(5, "output"),
-    direction: new RIO(6, "output"),
-    enable: new RIO(26, "output")
-}
-
-// DM452 drivers require one line per parameter as in the example below
-const dm452 = {
-    pulse: new RIO(16, "output"),
-    direction: new RIO(17, "output"),
-    polarity: new RIO(27, "output")
-}
-
-// When done close all rpi-io instances
-RIO.closeAll()
-
-// -------------------------------------------------------------------
-// EoF
-// -------------------------------------------------------------------