rpi-io 2.2.4 → 3.1.0

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/pulse.js

@@ -0,0 +1,43 @@
+// -------------------------------------------------------------------
+// TEST - Simple slow and fast pulse trains
+// -------------------------------------------------------------------
+import {RIO, traceCfg, log, sleep, ctrlC, lineNumber} from "../esm/main.mjs"
+
+(async () => {
+    traceCfg(2)
+
+    // Read line number from command line
+    const line = lineNumber(2)
+    if (line < 0) return
+
+    // Init output line and ctrl+c to close it
+    const led = new RIO(line, "output", {value: 0})
+    log("led:", led)
+    ctrlC(() => {
+        led.close()
+    })
+
+    // Slow pulse x10, ascending edge, w = 0.5 s, s = 0.5 s
+    const pulseStatus = await led.pulseStart(10, "asc", {
+        pulseWidth: 500000,
+        spaceWidth: 500000
+    })
+    log("pulse status stopped when completed:", pulseStatus)
+
+    // Fast pulse x1000, descending edge, w = 5µs, s = 5µs
+    led.write(1) // Init line according to edge
+    led.pulseStart(1000, "desc", {
+        pulseWidth: 5,
+        spaceWidth: 5
+    }).then(pulseStatus => {
+        log("pulse status stopped when stopped:", pulseStatus)
+        led.write(0) // Reset line
+        led.close()
+    })
+    await sleep(5)
+    led.pulseStop() // Stop pulse train after 5ms
+
+})()
+// -------------------------------------------------------------------
+// EoF
+// -------------------------------------------------------------------

package/test/read.js

@@ -5,6 +5,8 @@ import {RIO, traceCfg, log, sleep, ctrlC, lineNumber} from "../esm/main.mjs"
 
 (async () => {
     traceCfg(2)
+
+    // Read line number from command line
     const line = lineNumber(2)
     if (line < 0) return
 

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/test/write.js

@@ -6,6 +6,7 @@ import {RIO, traceCfg, log, sleep, ctrlC, lineNumber} from "../esm/main.mjs"
 (async () => {
     traceCfg(2)
 
+    // Read line number from command line
     const line = lineNumber(2)
     if (line < 0) return
 

package/esm/uln2003.mjs

@@ -1,115 +0,0 @@
-// -------------------------------------------------------------------
-// RPI-IO: ULN2003 STEP MOTORS CONTROL
-// -------------------------------------------------------------------
-
-import {RIO} from "./main.mjs";
-
-export class ULN2003 {
-
-    static RPi_GPIO_STD = [5, 6, 16, 17, 20, 21, 22, 23, 24, 25, 26, 27]
-    static RPi_GPIO_PWM = [12, 13, 18, 19]
-
-    /** ------------------------------------------------------------------
-     * @function isValidGpio
-     * @description Check if pin a valid multipurpose GPIO
-     * @param {Number} pin
-     * @return {Boolean}
-     */
-    static static isValidGpio(pin) {
-        return [...ULN2003.RPi_GPIO_STD, ...ULN2003.RPi_GPIO_PWM].GPIOS.includes(pin);
-    }
-
-    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]
-        ]
-    }
-
-
-    /** ------------------------------------------------------------------
-     * @method constructor
-     * @param {Array} pins - Array of 4 GPIO BCM port number e.g. [21,22,24,25]
-     * @param {Object} opt - Delay between steps and sequencing mode. See below
-     */
-    constructor(pins, opt) {
-
-        // Init options with default values and check validity
-        const defopt = {
-            // Delay between two steps in 1 ≤ ms ≤ 1000
-            delayMs: 10,
-            // Sequencing mode: 'full' or 'half' (default)
-            seqMode: ULN2003.MODE[0]
-        }
-        opt = {...defopt, ...opt}
-        opt.seqMode = opt.seqMode.toLowerCase()
-
-        //  Check if pins
-        pins.forEach(pin => {
-            if (!ULN2003.isValidGpio(pin)) {
-                throw new Error("Invalid pin number: " + pin)
-            }
-        })
-
-
-        rpiIoInstances.forEach(instance => {
-            if (!instance instanceof RIO) throw new Error("Invalid instance")
-            if (instance.mode !== "output") throw new Error("Invalid instance mode")
-        })
-
-        // Reset option values if not valid
-        if (ULN2003.MODE.indexOf(opt.seqMode) === -1) opt.seqMode = defopt.seqMode
-        if (typeof opt.delayMs !== "number" || opt.delayMs < 1 || opt.delayMs > 1000) opt.delayMs = defopt.delayMs
-
-
-        // Throw error if list of rpi-io instances is not valid: wrong number, wrong instance, wrong mode
-        if (!Array.isArray(rpiIoInstances) || rpiIoInstances.length !== 4) throw new Error("Invalid instance list.")
-        rpiIoInstances.forEach(instance => {
-            if (!instance instanceof RIO) throw new Error("Invalid instance")
-            if (instance.mode !== "output") throw new Error("Invalid instance mode")
-        })
-
-        // No option error here
-
-        this.coils = rpiIoInstances
-        this.sequence = ULN2003.STEPS[opt.seqMode]
-        this.len = this.sequence.length
-        this.delay = opt.delayMs
-        this.A = rpiIoInstances[0]
-        this.B = rpiIoInstances[1]
-        this.C = rpiIoInstances[2]
-        this.D = rpiIoInstances[0]
-        this.inc = 0
-        this.index = 0
-    }
-}
-
-const toto = new ULN2003()
-
-
-/** ------------------------------------------------------------------
- * @method uln2003
- * @description To control step motors based on ULN20003-like drivers.
- *              This function used 4 rpi-io output instances to control
- *              step motors back and forth.
- * @param {Object} pins
- * @param {Number}  steps     - Nombre de pas (entier > 0)
- * @param {'fwd'|'rev'} dir  - Direction : 'fwd' = avant, 'rev' = arrière
- */
-
-// -------------------------------------------------------------------
-// EoF
-// -------------------------------------------------------------------

package/test/exampleUln2003.js

@@ -1,103 +0,0 @@
-// -------------------------------------------------------------------
-// TEST - ULN 2003
-// -------------------------------------------------------------------
-import {RIO, traceCfg, log, sleep, ctrlC, lineNumber} from "../esm/main.mjs"
-
-(async () => {
-    traceCfg(2)
-
-    // Init outputs
-    const pins = {
-        A: new RIO(21, 'output', {value: 0}),
-        B: new RIO(22, 'output', {value: 0}),
-        C: new RIO(24, 'output', {value: 0}),
-        D: new RIO(25, 'output', {value: 0}),
-    }
-
-    const HALF_STEP = [
-        [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],
-    ]
-
-    const FULL_STEP = [
-        [1, 0, 0, 1],
-        [1, 1, 0, 0],
-        [0, 1, 1, 0],
-        [0, 0, 1, 1],
-    ]
-
-    /** ------------------------------------------------------------------
-     * @function write
-     * @param {Number} port
-     * @param {Number} value
-     */
-    const write = (port, value) => {
-        pins[port].write(value)
-    }
-
-    const reset = () => {
-        for (const [port, instance] of Object.entries(pins)) {
-            instance.write(0)
-        }
-    }
-
-    const test = async () => {
-        for (const [port, instance] of Object.entries(pins)) {
-            instance.write(1)
-            await sleep(500)
-            instance.write(0)
-            await sleep(500)
-        }
-    }
-
-    // Close ports on ctrl+c
-    ctrlC(() => {
-        reset()
-        RIO.closeAll();
-    })
-
-    /** --------------------------------------------------------------
-     * @function stepMotor
-     * @param {Object} opts
-     * @param {Number}  opts.steps     - Nombre de pas (entier > 0)
-     * @param {'fwd'|'rev'} opts.dir  - Direction : 'fwd' = avant, 'rev' = arrière
-     * @param {number}  opts.delayMs  - Délai entre deux pas en millisecondes (≥ 1)
-     * @param {'half'|'full'} [opts.mode='half'] - Mode de séquençage
-     * @returns {Promise<void>}
-     */
-    async function stepMotor({steps, dir = 'fwd', delayMs = 10, mode = 'half'}) {
-        const sequence = mode === 'half' ? HALF_STEP : FULL_STEP;
-        const len = sequence.length;
-        const inc = dir === 'fwd' ? 1 : -1;
-        let index = 0;
-
-        for (let i = 0; i < steps; i++) {
-            const [a, b, c, d] = sequence[index];
-            write('A', a);
-            write('B', b);
-            write('C', c);
-            write('D', d);
-            index = ((index + inc) % len + len) % len;
-            await sleep(delayMs);          // sleep() natif rpi-io
-        }
-
-        // Désactivation des bobines
-        write('A', 0);
-        write('B', 0);
-        write('C', 0);
-        write('D', 0);
-    }
-
-
-    await stepMotor({ steps: 1600, dir: 'rev', delayMs: 8 })
-
-})()
-// -------------------------------------------------------------------
-// EoF
-// -------------------------------------------------------------------