DEV Community: Calum Knott

TIA Portal - TP700 - Naughts & Crosses

Calum Knott — Tue, 23 Dec 2025 16:09:28 +0000

Its time for some festive fun!

Lets play Naughts and crosses!

Here is the tutorial:

And Here are the images you need for the Graphics List

Empty : (It's a white Square!)

Naughts :

Crosses :

Christmas Background

Robotino View - Tutorial Series

Calum Knott — Sat, 22 Nov 2025 20:25:22 +0000

Robotino Tutorials

Below are a series of videos for getting started with Robotino View - It's free! Feel free to download and try it out for yourself!

Festo Robotino View & Robotino Sim - Getting Started / Installation

Getting started using Festo Robotino View.
Here we look at installing the software, and writing a basic program to drive the sumulator

Festo Robotino View & Robotino Sim - Steps and Transitions

How to deal with steps and transitions in robotino view

Festo Robotino View & Robotino Sim - Obstacle Avoidance

In this video, we write a simple program to make the robotino avoid obsticals

TIA - Programming a Light Controller State Machine

Calum Knott — Sun, 09 Nov 2025 22:37:34 +0000

Programming a small state machine light controller

Bun-ffi - Getting started with C++ and Bun

Calum Knott — Tue, 07 Oct 2025 13:19:27 +0000

This post is intended to be a little intro guide on how to call C++ code from Bun using FFI.

Repo is at the bottom!

I found some more complicated examples online, but I wanted to make a minimal example that just works out of the box.

Bun's Foreign Function Interface (FFI) lets you call native C/C++ code directly from JavaScript with near-zero overhead. This is perfect when you need performance-critical operations or want to leverage existing C++ libraries.

In this little post, we'll build a minimal example that calls C++ functions from Bun.

Why Use FFI?

Performance: C++ sometimes runs faster than JavaScript for compute-intensive tasks
Existing Libraries: Tap into unique or required C/C++ libraries
System-Level Access: Work with low-level APIs not directly available in JavaScript

Project Structure

├── cpp/
│   └── cpp_math.cpp      # C++ source code
├── bun/
│   └── index.js          # Bun FFI wrapper
├── dist/
│   └── cpp_math.dylib    # Compiled shared library
├── build_cpp.sh          # Build script for the C++ code
└── build_bun.sh          # Build script for the Bun code

Step 1: Write Your C++ Code

First, create a C++ file with functions you want to export.

cpp_math.cpp

#include <stdint.h>

// Export function with C linkage to avoid name mangling
extern "C" {
    int32_t add(int32_t a, int32_t b) {
        return a + b;
    }

    int32_t multiply(int32_t a, int32_t b) {
        return a * b;
    }
}

Important: Use extern "C" so Bun can find your functions by their simple names (add, multiply) instead of mangled C++ names.

Step 2: Compile to a Shared Library

Create a build script that compiles your C++ code into a shared library (.dylib on macOS, .so on Linux, .dll on Windows):

build_cpp.sh

#!/bin/bash
clang++ -shared -fPIC -O3 -o dist/cpp_math.dylib cpp/cpp_math.cpp

Run it:

chmod +x build_cpp.sh
./build_cpp.sh

The flags:

-shared: Create a shared library
-fPIC: Generate position-independent code (required for shared libraries)
-O3: Optimize for performance? (Co-pilot told me to add this! :D)

Step 3: Call from Bun using FFI

Now use Bun's dlopen to load and call your C++ functions:

import { dlopen, FFIType, suffix } from "bun:ffi";

// Import the dylib as an embedded asset (for compiled binaries)
import cpp_math from "../dist/cpp_math.dylib" with { type: "file" };

// Find the library (works in dev and when compiled)
const libName = `cpp_math.${suffix}`;
const libPath = cpp_math || [
    `${import.meta.dir}/${libName}`,
    `${import.meta.dir}/../dist/${libName}`,
].find(p => Bun.file(p).exists());

// Load the library and define function signatures
const cpp_math_lib = dlopen(libPath, {
    add: {
        args: [FFIType.i32, FFIType.i32],
        returns: FFIType.i32,
    },
    multiply: {
        args: [FFIType.i32, FFIType.i32],
        returns: FFIType.i32,
    }
});

// Call the C++ functions!
console.log("C++ Add:", cpp_math_lib.symbols.add(10, 20));      // 30
console.log("C++ Multiply:", cpp_math_lib.symbols.multiply(10, 20)); // 200

How It Works

dlopen(path, symbols): Opens the shared library
Function signatures: Tell Bun the argument and return types
FFIType: Maps JavaScript types to C types (i32, f64, ptr, etc.)
suffix: Platform-specific extension (dylib/so/dll)
Import with type: "file": Embeds the library for standalone compilation

Bonus: Compile to a Single Binary

You can bundle everything into a single executable:

build_bun.sh

bun build ./bun/index.js --compile --outfile dist/bun_binary

The import ... with { type: "file" } statement embeds the .dylib into the compiled binary, making it truly self-contained!

Available FFI Types

Common types you'll use:

FFIType.i32 / FFIType.i64 - Integers (32/64-bit)
FFIType.u32 / FFIType.u64 - Unsigned integers
FFIType.f32 / FFIType.f64 - Floats (32/64-bit)
FFIType.ptr - Pointers
FFIType.void - No return value
FFIType.cstring - C string (null-terminated)

When to Use FFI

✅ Good for:

CPU-intensive calculations (image processing, cryptography, physics)
Wrapping existing C/C++ libraries
Hardware/system-level operations

Conclusion

Bun's FFI makes it trivially easy to call C++ code from JavaScript. With just three files (C++ source, build script, and JS wrapper), you can achieve native performance while keeping the convenience of JavaScript.

The ability to compile everything into a single binary makes distribution simple—no need to worry about shipping separate .dylib files!

Full code: Check out this repo for the complete working example.
https://github.com/calumk/example-repo-bun-ffi-cpp

calumk / example-repo-bun-ffi-cpp

Bun's Foreign Function Interface (FFI) lets you call native C/C++ code directly from JavaScript with near-zero overhead. This is perfect when you need performance-critical operations or want to leverage existing C++ libraries.

Bun FFI Experiment

A minimal example of calling C++ functions from Bun using FFI.

Structure

cpp/cpp_math.cpp - C++ source with a simple add() function
build_cpp.sh - Compiles C++ to a shared library
bun/index.js - Bun script that calls the C++ function via FFI
build_bun.sh - Compiles the Bun script into a standalone executable, including the C++ shared library

Usage

Build the C++ library:

./build_cpp.sh

Run the Bun script:

bun run bun/index.js

Build the Bun executable:

./build_bun.sh

Run the Bun executable:

./dist/bun_binary

Expected output:

C++ Add: 10 + 20 = 30
C++ Multiply: 10 * 20 = 200
JS Add: 10 + 20 = 30
JS Multiply: 10 * 20 = 200

View on GitHub

Bun QuickLook thumbnail Cache extraction

Calum Knott — Sat, 05 Jul 2025 18:24:24 +0000

I recently stumbled upon this interesting writeup from 2016 (nearly a decade ago) that talks about extracting data from the quicklook cache com.apple.QuickLook.thumbnailcache

QuickLook thumbnails data parser - Article

OSX-QuickLook-Parser - Github

Since time has moved on a bit, I decided to see if the old python code could be ported to Bun.

Im pleased to say it can!

Gone are the Pillow/biplist/xlsxwriter dependancies, and we have an easy to use command prompt version.

Enjoy!

Script rewrite/port for Javascript / Bun.JS #2

calumk posted on Jul 05, 2025

Not really an issue, but a comment for future travellers.....

New Version for Bun.JS

I dont like python, so I have a full rewrite/port of this for Bun.JS, it runs and is tested on OSX, using Bun.js

it requires zero dependancies, or installation. as it uses bun native code

Usage

Command Line

bun run extract.js -d "/path/to/com.apple.QuickLook.thumbnailcache" -o "/path/to/output_folder"

Options

-d, --thumbcache-dir: Path to com.apple.QuickLook.thumbnailcache folder (required)
-o, --output-folder: Path to empty folder to hold report and thumbnails (required)
-t, --type: Output format, currently only supports 'tsv' (default: tsv)
-h, --help: Show help message

Example

bun run extract.js -d "/Users/username/Library/Caches/com.apple.QuickLook.thumbnailcache" -o "./output"

QuickLook Cache Location

The QuickLook cache is typically located at:

/Users/[username]/Library/Caches/com.apple.QuickLook.thumbnailcache/

This folder should contain:

index.sqlite - Database with metadata
thumbnails.data - Raw thumbnail data

Output

The script generates:

report.csv - Tab-separated values file with metadata
thumbnails/ folder - Extracted thumbnail images as PNG files
error.log - Any errors encountered during processing

Code

#!/usr/bin/env bun

/**
 * QuickLook Parser - JavaScript/Bun Port
 * Port written by Calum Knott - calum@calumk.com (using Cursor.ai)
 * 
 * Converted from the original Python script by Mari DeGrazia
 * Original: http://az4n6.blogspot.com/
 * 
 * This will parse the Mac QuickLook database which holds metadata for viewed thumbnails in the Mac Finder
 * This includes parsing out the embedded plist file in the version field as well as extracting thumbnails from the thumbnails.data folder
 * 
 * Usage:
 *   bun run extract.js -d "/path/to/com.apple.QuickLook.thumbnailcache" -o "/path/to/output_folder"
 * 
 * Required files in thumbnailcache folder:
 *   - index.sqlite
 *   - thumbnails.data
 */

import { existsSync, mkdirSync, readFileSync, writeFileSync, createWriteStream } from "fs";
import { join, dirname } from "path";
import { Database } from "bun:sqlite";

// Native plist parser using Bun's XML capabilities
function parsePlist(buffer) {
    try {
        const text = buffer.toString('utf8');
        
        // Simple plist parser for binary plists - convert to text format first
        if (text.startsWith('bplist')) {
            // For binary plists, we'll extract key-value pairs manually
            // This is a simplified parser for the common keys we need
            const result = {};
            
            // Look for common patterns in binary plist data
            const dateMatch = buffer.indexOf('date');
            if (dateMatch !== -1) {
                // Extract date value (8 bytes after 'date' key, big-endian double)
                const dateOffset = dateMatch + 4;
                if (dateOffset + 8 <= buffer.length) {
                    const dateView = new DataView(buffer.buffer, buffer.byteOffset + dateOffset, 8);
                    const timestamp = dateView.getFloat64(0, false); // big-endian
                    result.date = timestamp;
                }
            }
            
            // Look for size information
            const sizeMatch = buffer.indexOf('size');
            if (sizeMatch !== -1) {
                // Extract size value
                const sizeOffset = sizeMatch + 4;
                if (sizeOffset + 8 <= buffer.length) {
                    const sizeView = new DataView(buffer.buffer, buffer.byteOffset + sizeOffset, 8);
                    result.size = sizeView.getBigUint64(0, false);
                }
            }
            
            // Look for generator information
            const genMatch = buffer.indexOf('gen');
            if (genMatch !== -1) {
                // Extract generator string
                let genEnd = genMatch + 3;
                while (genEnd < buffer.length && buffer[genEnd] !== 0) genEnd++;
                if (genEnd > genMatch + 3) {
                    result.gen = buffer.subarray(genMatch + 3, genEnd).toString('utf8');
                }
            }
            
            return result;
        }
        
        // For XML plists, use simple XML parsing
        const xmlMatch = text.match(/<plist.*?>(.*?)<\/plist>/s);
        if (xmlMatch) {
            const plistContent = xmlMatch[1];
            const result = {};
            
            // Extract date
            const dateMatch = plistContent.match(/<key>date<\/key>\s*<date>(.*?)<\/date>/);
            if (dateMatch) {
                result.date = new Date(dateMatch[1]).getTime() / 1000;
            }
            
            // Extract size
            const sizeMatch = plistContent.match(/<key>size<\/key>\s*<integer>(.*?)<\/integer>/);
            if (sizeMatch) {
                result.size = parseInt(sizeMatch[1]);
            }
            
            // Extract generator
            const genMatch = plistContent.match(/<key>gen<\/key>\s*<string>(.*?)<\/string>/);
            if (genMatch) {
                result.gen = genMatch[1];
            }
            
            return result;
        }
        
        return {};
    } catch (error) {
        return {};
    }
}

// Native image processing using raw buffer manipulation
async function createPngFromRawRGBA(rawBuffer, width, height, outputPath) {
    try {
        // For simplicity, we'll create a simple PPM file instead of PNG
        // PPM is much simpler to generate and widely supported
        const ppmPath = outputPath.replace('.png', '.ppm');
        
        // PPM header
        const header = `P6\n${width} ${height}\n255\n`;
        const headerBuffer = new TextEncoder().encode(header);
        
        // Convert RGBA to RGB (PPM doesn't support alpha)
        const rgbBuffer = new Uint8Array(width * height * 3);
        for (let i = 0, j = 0; i < rawBuffer.length; i += 4, j += 3) {
            if (i + 3 < rawBuffer.length) {
                rgbBuffer[j] = rawBuffer[i];     // R
                rgbBuffer[j + 1] = rawBuffer[i + 1]; // G
                rgbBuffer[j + 2] = rawBuffer[i + 2]; // B
                // Skip alpha channel (i + 3)
            }
        }
        
        // Combine header and image data
        const totalSize = headerBuffer.length + rgbBuffer.length;
        const ppmBuffer = new Uint8Array(totalSize);
        ppmBuffer.set(headerBuffer, 0);
        ppmBuffer.set(rgbBuffer, headerBuffer.length);
        
        // Write to file
        await Bun.write(ppmPath, ppmBuffer);
        return true;
    } catch (error) {
        console.error(`Error creating image: ${error.message}`);
        return false;
    }
}

// Convert Mac absolute time (seconds from 1/1/2001) to human readable
function convertAbsolute(macAbsoluteTime) {
    try {
        const baseDate = new Date('2001-01-01T00:00:00Z');
        const humanTime = new Date(baseDate.getTime() + (macAbsoluteTime * 1000));
        return humanTime.toISOString();
    } catch (error) {
        return "Error on conversion";
    }
}

// Verify required files exist
function verifyFiles(thumbcacheDir) {
    const indexPath = join(thumbcacheDir, "index.sqlite");
    const thumbnailsPath = join(thumbcacheDir, "thumbnails.data");
    
    if (!existsSync(indexPath)) {
        return `Could not locate the index.sqlite file in the folder ${thumbcacheDir}`;
    }
    
    if (!existsSync(thumbnailsPath)) {
        return `Could not locate the thumbnails.data file in the folder ${thumbcacheDir}`;
    }
    
    return true;
}

// Native argument parsing using Bun.argv
function parseArguments() {
    const args = Bun.argv.slice(2);
    const parsed = {};
    
    for (let i = 0; i < args.length; i++) {
        const arg = args[i];
        
        if (arg === '-h' || arg === '--help') {
            parsed.help = true;
        } else if (arg === '-d' || arg === '--thumbcache-dir') {
            parsed.thumbcacheDir = args[++i];
        } else if (arg === '-o' || arg === '--output-folder') {
            parsed.outputFolder = args[++i];
        } else if (arg === '-t' || arg === '--type') {
            parsed.type = args[++i];
        }
    }
    
    return parsed;
}

// Main database processing function
async function processDatabase(openFolder, saveFolder, outFormat = 'csv') {
    const dbPath = join(openFolder, "index.sqlite");
    const thumbnailsDataPath = join(openFolder, "thumbnails.data");
    
    let thumbnailsFile;
    try {
        thumbnailsFile = readFileSync(thumbnailsDataPath);
    } catch (error) {
        return { error: `Error opening ${thumbnailsDataPath}: ${error.message}` };
    }
    
    let thumbnailsExported = 0;
    
    // Create output directories
    const thumbnailsFolder = join(saveFolder, "thumbnails");
    if (!existsSync(thumbnailsFolder)) {
        mkdirSync(thumbnailsFolder, { recursive: true });
    }
    
    const errorLogPath = join(saveFolder, "error.log");
    const errorLog = createWriteStream(errorLogPath);
    
    let reportFile;
    let reportPath;
    
    if (outFormat === "csv") {
        reportPath = join(saveFolder, "report.csv");
    } else {
        reportPath = join(saveFolder, "report.tsv");
    }
    
    reportFile = createWriteStream(reportPath);
    
    // Write CSV/TSV header with proper escaping for CSV
    const headers = [
        "File Row ID",
        "Folder", 
        "Filename",
        "Hit Count",
        "Last Hit Date",
        "Last Hit Date (UTC)",
        "Has thumbnail",
        "Original File Last Modified Raw",
        "Original File Last Modified(UTC)",
        "Original File Size",
        "Generator",
        "FS ID"
    ];
    
    if (outFormat === "csv") {
        // Escape CSV headers if they contain commas
        const escapedHeaders = headers.map(header => 
            header.includes(',') ? `"${header}"` : header
        );
        reportFile.write(escapedHeaders.join(",") + "\n");
    } else {
        reportFile.write(headers.join("\t") + "\n");
    }
    
    let db;
    try {
        db = new Database(dbPath, { readonly: true });
    } catch (error) {
        return { error: `Error opening database: ${error.message}` };
    }
    
    // Get number of thumbnails
    let totalThumbnails = 0;
    try {
        const thumbnailCountQuery = db.query("SELECT COUNT(*) as count FROM thumbnails");
        const result = thumbnailCountQuery.get();
        totalThumbnails = result.count;
    } catch (error) {
        db.close();
        return { error: `Error executing SQL: ${error.message}` };
    }
    
    // Main query - SQL syntax from http://www.easymetadata.com/2015/01/sqlite-analysing-the-quicklook-database-in-macos/
    const mainQuery = `
        SELECT DISTINCT 
            f_rowid,
            k.folder,
            k.file_name,
            k.version,
            t.hit_count,
            t.last_hit_date,
            t.bitsperpixel,
            t.bitmapdata_location,
            t.bitmapdata_length,
            t.width,
            t.height,
            datetime(t.last_hit_date + strftime('%s', '2001-01-01 00:00:00'), 'unixepoch') AS decoded_last_hit_date,
            k.fs_id
        FROM (
            SELECT rowid as f_rowid, folder, file_name, fs_id, version 
            FROM files
        ) k 
        LEFT JOIN thumbnails t ON t.file_id = k.f_rowid 
        ORDER BY t.hit_count DESC
    `;
    
    let rows;
    try {
        const stmt = db.query(mainQuery);
        rows = stmt.all();
    } catch (error) {
        db.close();
        return { error: `Error executing main query: ${error.message}` };
    }
    
    const totalRows = rows.length;
    
    for (let i = 0; i < rows.length; i++) {
        const row = rows[i];
        const {
            f_rowid: rowid,
            folder,
            file_name,
            version,
            hit_count,
            last_hit_date,
            bitsperpixel,
            bitmapdata_location,
            bitmapdata_length,
            width,
            height,
            decoded_last_hit_date,
            fs_id
        } = row;
        
        let versionLastModifiedRaw = "";
        let versionConvertedDate = "";
        let versionGenerator = "";
        let versionOrgSize = "";
        
        // Parse plist from version field
        if (version) {
            try {
                const plistData = parsePlist(version);
                
                for (const [key, value] of Object.entries(plistData)) {
                    if (key === "date") {
                        const convertedDate = convertAbsolute(value);
                        versionLastModifiedRaw = value.toString();
                        versionConvertedDate = convertedDate;
                    } else {
                        if (key.includes("gen")) {
                            versionGenerator = value.toString();
                        }
                        if (key.includes("size")) {
                            versionOrgSize = value.toString();
                        }
                    }
                }
            } catch (error) {
                errorLog.write(`Error parsing plist for row id ${rowid}: ${error.message}\n`);
            }
        }
        
        // Query for thumbnails for this file
        const thumbnailQuery = `
            SELECT file_id, size, width, height, bitspercomponent, bitsperpixel, 
                   bytesperrow, bitmapdata_location, bitmapdata_length 
            FROM thumbnails 
            WHERE file_id = ?
        `;
        
        let thumbRows;
        try {
            const thumbStmt = db.query(thumbnailQuery);
            thumbRows = thumbStmt.all(rowid);
        } catch (error) {
            errorLog.write(`Error on thumbnails data query for file id ${rowid}: ${error.message}\n`);
            thumbRows = [];
        }
        
        let hasThumbnail = "FALSE";
        
        if (thumbRows.length > 0) {
            hasThumbnail = "TRUE";
            
            for (let thumbIndex = 0; thumbIndex < thumbRows.length; thumbIndex++) {
                const thumb = thumbRows[thumbIndex];
                const countThumb = thumbIndex + 1;
                
                try {
                    const bitspercomponent = thumb.bitspercomponent;
                    const bytesperrow = thumb.bytesperrow;
                    const bitmapDataLocation = thumb.bitmapdata_location;
                    const bitmapDataLength = thumb.bitmapdata_length;
                    
                    // Compute the width from bytes per row
                    const computedWidth = Math.floor(bytesperrow / (bitsperpixel / bitspercomponent));
                    const thumbHeight = thumb.height;
                    
                    // Extract raw bitmap data
                    const rawBitmap = thumbnailsFile.subarray(
                        bitmapDataLocation, 
                        bitmapDataLocation + bitmapDataLength
                    );
                    
                    // Create PNG file
                    const pngFilename = `${rowid}.${file_name}_${countThumb}.png`;
                    const pngPath = join(thumbnailsFolder, pngFilename);
                    
                    if (!existsSync(pngPath)) {
                        try {
                            // Create image from raw RGBA data using native implementation
                            const success = await createPngFromRawRGBA(
                                rawBitmap,
                                computedWidth,
                                thumbHeight,
                                pngPath
                            );
                            
                            if (success) {
                                thumbnailsExported++;
                            }
                        } catch (imageError) {
                            errorLog.write(`Error creating image for row id ${rowid}: ${imageError.message}\n`);
                        }
                    }
                } catch (error) {
                    errorLog.write(`Error with thumbnail for row id ${rowid}: ${error.message}\n`);
                }
            }
        }
        
        // Write to report
        if (reportFile) {
            const reportData = [
                rowid,
                folder || "",
                file_name || "",
                hit_count || "",
                last_hit_date || "",
                decoded_last_hit_date || "",
                hasThumbnail,
                versionLastModifiedRaw,
                versionConvertedDate,
                versionOrgSize,
                versionGenerator,
                fs_id || ""
            ];
            
            if (outFormat === "csv") {
                // Escape CSV fields if they contain commas, quotes, or newlines
                const escapedData = reportData.map(field => {
                    const fieldStr = String(field);
                    if (fieldStr.includes(',') || fieldStr.includes('"') || fieldStr.includes('\n')) {
                        return `"${fieldStr.replace(/"/g, '""')}"`;
                    }
                    return fieldStr;
                });
                reportFile.write(escapedData.join(",") + "\n");
            } else {
                reportFile.write(reportData.join("\t") + "\n");
            }
        }
    }
    
    // Clean up
    db.close();
    if (reportFile) reportFile.end();
    errorLog.end();
    
    return {
        totalRows,
        totalThumbnails,
        thumbnailsExported
    };
}

// Command line interface
async function main() {
    const args = parseArguments();
    
    if (args.help) {
        console.log(`
QuickLook Parser - JavaScript/Bun Port
Usage: bun run extract.js [options]

Options:
  -d, --thumbcache-dir   Path to com.apple.QuickLook.thumbnailcache folder
  -o, --output-folder    Path to empty folder to hold report and thumbnails  
  -t, --type            Output format (csv or tsv) [default: csv]
  -h, --help            Show this help message

Example:
  bun run extract.js -d "/Users/user/Library/Caches/com.apple.QuickLook.thumbnailcache" -o "./output"
        `);
        process.exit(0);
    }
    
    const thumbcacheDir = args.thumbcacheDir;
    const outputFolder = args.outputFolder;
    const outFormat = args.type || 'csv';
    
    if (!thumbcacheDir) {
        console.error("Error: -d THUMBCACHE_DIR argument required");
        process.exit(1);
    }
    
    if (!outputFolder) {
        console.error("Error: -o OUTPUT_FOLDER argument required");
        process.exit(1);
    }
    
    // Verify files exist
    const verification = verifyFiles(thumbcacheDir);
    if (verification !== true) {
        console.error("Error:", verification);
        process.exit(1);
    }
    
    // Create output folder if it doesn't exist
    if (!existsSync(outputFolder)) {
        mkdirSync(outputFolder, { recursive: true });
    }
    
    console.log("Processing QuickLook database...");
    
    try {
        const stats = await processDatabase(thumbcacheDir, outputFolder, outFormat);
        
        if (stats.error) {
            console.error("Error:", stats.error);
            process.exit(1);
        }
        
        console.log("Processing Complete");
        console.log(`Records in table: ${stats.totalRows}`);
        console.log(`Thumbnails available: ${stats.totalThumbnails}`);
        console.log(`Thumbnails extracted: ${stats.thumbnailsExported}`);
        
    } catch (error) {
        console.error("Unexpected error:", error.message);
        process.exit(1);
    }
}

// Run the main function
if (import.meta.main) {
    main().catch(console.error);
}

View on GitHub

XR Chair Motion Simulator (Throwback)

Calum Knott — Wed, 02 Jul 2025 16:57:14 +0000

A few years ago, I had the pleasure of being involved in the development of an XR Motion Platform at Middlesex University.

The Chair/Platform/MDX Loco (It has known a few different names!) was originally designed as part of an interactive project.

You can see a much younger me at about half way through the video!

The chair is powered by 6 pneumatic muscles in an inverted stewert platform configuration.

The system is controlled by a single FESTO CPX PLC, which has 6 proportional pressure regulators onboard, providing a simple interface to allow TCP/UDP (FESTO EasyIP Protocol) messages to control the muscle lengths.

https://github.com/birchroad/fstlib (This is a good unofficial library for EasyIP)

I designed a controller using blender 2.7 (At that time, blender supported python runtime for game engine) and I was able to use that to control the chair in real time.

I could animate the chair moving around, and blender would, in live time, calculate the muscle lengths, and send this packet data to the PLC.

Sadly this blender file is now lost to the ravishes of time, however a colleague of mine (https://github.com/michaelmargolis) took over the project, and wrote code to support controlling the chair from all manner of different programs, from rollercoasters, to racing simulators, to flight simulators. At one point there was even a comode mounted on it - although that story is for another day.

So - Why Post about this now?

Finally, nearly a decade later, the controller on the chair is due a minor upgrade!

I had the pleasure of visiting the university recently, to rewrite a few lines of code I last wrote all those years ago, and port the code from legacy FST to the more recent CodeSys ST format.

Hopefully, the project will continue for many more years to come!

// Detect dark theme var iframe = document.getElementById('tweet-648866115033165824-415'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=648866115033165824&theme=dark" }

Using Bun Compile/Build to embed an Express / Vite / Vue Application into a Binary

Calum Knott — Mon, 12 May 2025 13:22:06 +0000

WHY?

OK, So your developing an internal tool using JS... or project for a customer. You want to ship them a 100% self contained binary, that they just run, to launch the tool... No installation steps for the customer, no debugging versions of bun / libraries... You also want some basic ability to avoid having to distribute the source code.

Bun Bundler/Compiler

Bun handles this build step quite well, https://bun.sh/docs/bundler/executables but does have a few small issues, related to packing the files, which can then be locally served.

The issue is the embed dir ability for bun is.... in beta, at best, and seems to have a few quirks. It is also quite hard to get the files back to serve them with express.

So the solution?

1) Build your vite project

vite build

2) Take your /dist directory, and build a virtual file system!

We can use https://github.com/seveibar/make-vfs/ to take our entire dist directory, and repack it as a single .js file. This can produce a fairly heavy file, but as we are distributing the whole thing as a binary anyway, it doesnt matter!

bunx make-vfs --dir ./dist --content-format string --outfile ./bundle/client-bundle-vfs.js

UPDATE

make-vfs seems to be fundementally broken with its implementation of base64 encoding or decoding.

I wrote a new alternative, the repo is updated.

https://gist.github.com/calumk/65d2b9352c92e7e83cbb59fbb205f123

3) Use Express to load and then serve your vfs : (See Repo)

import staticRoutes from "../../dist/client-bundle-vfs.js";
import { lookup } from "es-mime-types"
import express from "express";
import routes from "./routes.js";

const app = express();
// serve express routes
app.use(routes);
// serve the static bundled files
app.use((req, res, next) => {
  const url = new URL(req.url, `http://${req.headers.host}`);
  const path = url.pathname;
  const normalizedPath = path.replace(/^\//, "").replace(/\/$/, "");
  if (staticRoutes[normalizedPath]) {
    let mimeType = lookup(normalizedPath);
    return res.status(200).type(mimeType).send(staticRoutes[normalizedPath]);
  }
  next();
});

// Fallback to assist vue-router
app.use((req, res) => {
  return res.status(200).type("text/html").send(staticRoutes["index.html"]);
});


app.listen(3002, () => {
  console.log("Server is running on http://localhost:3002");
});

4) Build your final applicaion, as the application consumes the vfs, everything is bundled.

bun build ./src/server/main-compile.js --compile --outfile myServer

calumk / vite-express-bun-compiled

vite-express-bun-compiled shows how to compile a vite-vue application using vfs

Vue 3 + Vite + Bun + VFS!

This repository is a template for Vite + Vue 3 + Bun + VFS (Virtual File System)

It is a simple template to get you started with Vue 3 and Vite, using Bun as the package manager and VFS for file system operations.

It is designed to allow you to bundle your Vue 3 application with Vite and run it using Bun, while also providing a simple way to manage your files using VFS.

This allows a standalone application to be run without the need for a server, making it easy to deploy and share your application.

View on GitHub

Reseting IEC Timers on Older Siemens PLC's (S7-300/S7-400)

Calum Knott — Mon, 12 May 2025 12:58:10 +0000

More of a personal note than a blog, but hopefully useful for some weary internet traveler in the future.

Problem

Resetting IEC Timers for older Siemens PLC's is a bit of a pain.
They seem to behave a little differently inside or outside of case statemenents.

In newer CPU we can use RESET_TIMER(TIMER) but this is not avaliable
eg:

RESET_TIMER(#IEC_Timer_0_Instance);

So we are forced to do a little more work

Solution

Setup the timer as normal

#IEC_Timer_0_Instance(IN:=TRUE,PT:=T#5s);

Then use the following fairly verbose setup to reset it.

// This is required to reset the timer on Older CPUs.
// In newer CPU we can use RESET_TIMER(TIMER) but this is not avaliable here.
// RESET_TIMER(#IEC_Timer_0_Instance);

#IEC_Timer_0_Instance.IN := FALSE;
#IEC_Timer_0_Instance.PT := T#0s;
#IEC_Timer_0_Instance.Q := FALSE;
#IEC_Timer_0_Instance.ET := T#0s;
#IEC_Timer_0_Instance.STATE := 0;

Ulanzi TC001 - ESP32 Programming / Custom Arduino firmware

Calum Knott — Sat, 14 Dec 2024 17:49:56 +0000

I found quite a lot of tutorials on using the Ulanzi TC001 with a firmware like AWTRIX, but not much information on simply programming it from scratch.
It wasnt too dificult to figure out, but, i thought it would be nice to document a few things here, so that others might be encouraged to give this nice little unit a try.

So this is a collection of notes designed to assist anyone who wants to do some "from scratch" programming, with the help of a few libraries, of course.

Setup

You can program the Ulanzi TC001 using a standard Arduino IDE.

Install the ESP32 boards in the board manager.

Then select board time "NODEMCU-32S"

When you download to the board, you will get a high pitch noise. Im not sure why, but in order to fix this, you need to add the following lines to your setup function.

  pinMode(15, INPUT_PULLDOWN); //Stops the High pitch noise!
  pinMode(27, INPUT_PULLUP); // Does something with the buttons
  pinMode(26, INPUT_PULLUP); // Does something with the buttons

Getting Started

A simple program can be written that shows how the pixels are arranged. They can be though of as essentially a strip of LEDs, that runs each row in alternating directions
001 -> 032
064 <- 033

#include <FastLED.h>

#define NUM_LEDS 256
#define DATA_PIN 32

CRGB leds[NUM_LEDS];

void setup() {

  pinMode(15, INPUT_PULLDOWN); //Stops the High pitch noise!
  pinMode(27, INPUT_PULLUP);
  pinMode(26, INPUT_PULLUP);

  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(50);
}

void loop() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i] = CRGB::Red;
    FastLED.show();
    delay(50);
    leds[i] = CRGB::Black;
  }
}

To fix this, we can use a helper function function "setLED" which will allow us to set any pixel simply by referring to its X,Y position, and will deal with the alternating direction of the rows.

void setLED(int x, int y, CRGB color) {
  if (x < 0 || x >= MATRIX_WIDTH || y < 0 || y >= MATRIX_HEIGHT) return;
  int index = (y % 2 == 0) ? y * MATRIX_WIDTH + x : (y + 1) * MATRIX_WIDTH - 1 - x;
  leds[index] = color;
}

Here is an example of filling the display in the expected order:

#include <FastLED.h>

#define NUM_LEDS 256
#define DATA_PIN 32

#define MATRIX_WIDTH 32
#define MATRIX_HEIGHT 8

CRGB leds[NUM_LEDS];

void setup() {
  pinMode(15, INPUT_PULLDOWN);
  pinMode(27, INPUT_PULLUP);
  pinMode(26, INPUT_PULLUP);

  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(50);
}

void setLED(int x, int y, CRGB color) {
  if (x < 0 || x >= MATRIX_WIDTH || y < 0 || y >= MATRIX_HEIGHT) return;
  int index = (y % 2 == 0) ? y * MATRIX_WIDTH + x : (y + 1) * MATRIX_WIDTH - 1 - x;
  leds[index] = color;
}

void loop() {
  // Loop Through each pixel and turn it on
  for (int i = 0; i < MATRIX_HEIGHT; i++) {
    for (int j = 0; j < MATRIX_WIDTH; j++) {
        setLED(j,i,CRGB::Red);
        FastLED.show();
        delay(50);
    }
  }

  // Set all LEDs to black
  for(int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CRGB::Black; 
  }
}

Its then fairly simple to add extra features, and begin to build a usable system.

The following code will allow you to display the time!

#include <FastLED.h>
#include <WiFi.h>
#include <time.h>

#define NUM_LEDS 256
#define DATA_PIN 32
#define MATRIX_WIDTH 32
#define MATRIX_HEIGHT 8

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* ntpServer = "pool.ntp.org";
const long  gmtOffset_sec = 0;
const int   daylightOffset_sec = 3600;

CRGB leds[NUM_LEDS];

// 3x5 font for digits
const uint8_t digits[10][5] = {
  {0b111, 0b101, 0b101, 0b101, 0b111}, // 0
  {0b010, 0b110, 0b010, 0b010, 0b111}, // 1
  {0b111, 0b001, 0b111, 0b100, 0b111}, // 2
  {0b111, 0b001, 0b111, 0b001, 0b111}, // 3
  {0b101, 0b101, 0b111, 0b001, 0b001}, // 4
  {0b111, 0b100, 0b111, 0b001, 0b111}, // 5
  {0b111, 0b100, 0b111, 0b101, 0b111}, // 6
  {0b111, 0b001, 0b010, 0b010, 0b010}, // 7
  {0b111, 0b101, 0b111, 0b101, 0b111}, // 8
  {0b111, 0b101, 0b111, 0b001, 0b111}  // 9
};

void setup() {
  Serial.begin(115200);
  pinMode(15, INPUT_PULLDOWN);
  pinMode(27, INPUT_PULLUP);
  pinMode(26, INPUT_PULLUP);

  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(50);

  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected to WiFi");

  // Init and get the time
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
}

void setLED(int x, int y, CRGB color) {
  if (x < 0 || x >= MATRIX_WIDTH || y < 0 || y >= MATRIX_HEIGHT) return;
  int index = (y % 2 == 0) ? y * MATRIX_WIDTH + x : (y + 1) * MATRIX_WIDTH - 1 - x;
  leds[index] = color;
}

void drawDigit(int x, int y, int digit, CRGB color) {
  for (int row = 0; row < 5; row++) {
    for (int col = 0; col < 3; col++) {
      if (digits[digit][row] & (1 << (2 - col))) {
        setLED(x + col, y + row, color);
      }
    }
  }
}

void drawTime(int hours, int minutes, int seconds, CRGB color) {
  drawDigit(0, 1, hours / 10, color);
  drawDigit(4, 1, hours % 10, color);
  setLED(8, 2, color);
  setLED(8, 4, color);
  drawDigit(10, 1, minutes / 10, color);
  drawDigit(14, 1, minutes % 10, color);
  setLED(18, 2, color);
  setLED(18, 4, color);
  drawDigit(20, 1, seconds / 10, color);
  drawDigit(24, 1, seconds % 10, color);
}

void loop() {
  struct tm timeinfo;
  if(!getLocalTime(&timeinfo)){
    Serial.println("Failed to obtain time");
    return;
  }

  FastLED.clear();
  drawTime(timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec, CRGB::White);
  FastLED.show();
  delay(1000);
}

WSCCS

Calum Knott — Wed, 18 Sep 2024 16:54:16 +0000

With #WorldSkills Lyon 2024 behind us, I can share some more information on the software platform I developed to support the Mechatronics & I4.0 Competitions. - "WSCCS"

Viktor Öhlén and I have worked on this project on and off for the best part of the last year, and it was a pleasure to see it work so well to manage the communication and file distribution to 100's of competitors across the two competitions.

We trialed the system in #EuroSkills Gdansk 2023, but since then underwent an almost complete rewrite to support AI Translation hints, and support/improve access for interpreters.

We are not finished with development, and have a few exciting features in the pipline for EuroSkills Herning 2025....

If anyone is interested in using this in their own national competitions / other international competitions - Please get in touch - We may be able to help.

https://wsccs.cloud

🤖 Techy Stuff 👇

We use Vite, Vue3, Node.js, and pocketbase.io for the majority of the application.

WebSockets are used to maintain realtime subscriptions, and monitor system events.

The AI is an offline LLM running using Transformers.js.

WorldSkills Lyon 2024

Calum Knott — Mon, 16 Sep 2024 09:05:31 +0000

After 2 years of hard work it was once again a pleasure to lead a team to represent the UK on the world stage.

A big thanks to Ben & Lucy

As Lucy said, "We know each other’s strengths and weaknesses inside out and work together to optimise our abilities." This teamwork is precisely what Ben and Lucy demonstrated while competing in… | WorldSkills UK

As Lucy said, "We know each other’s strengths and weaknesses inside out and work together to optimise our abilities." This teamwork is precisely what Ben and Lucy demonstrated while competing in Mechatronics at WorldSkills Lyon, where they earned a Medallion for Excellence. #WSC2024 Read more about their journey to WorldSkills Lyon here: https://lnkd.in/eUgaGb_6 #TeamUK, powered by WorldSkills UK, in partnership with Pearson BTEC and Apprenticeships Siemens / Tameside College

linkedin.com

Pocketbase pb_hooks - checking user authentication

Calum Knott — Fri, 09 Aug 2024 14:29:26 +0000

The documentation for pocketbase is not as clear as it could be about how to check for an authenticated user when using the pb_hooks

It turns out that it is really simple

Docs :

https://pocketbase.io/docs/js-routing/#sending-request-to-custom-routes-using-the-sdks

https://pocketbase.io/jsvm/functions/_apis.requireAdminOrRecordAuth.html

Example :

// main.pb.js
// This is a simple GET route, that is protected
routerAdd("GET", "/private", (c) => {
    const data = { 
        message : "This can only be accessed if you are logged in"
    }
    return c.json(200, data)
    // Adding the $apis.requireAdminOrRecordAuth() argument, ensures the route is protected unless the user is logged in.
}, $apis.requireAdminOrRecordAuth());


// This is a simple GET route, that is public
routerAdd("GET", "/public", (c) => {
    const data = { 
        message : "This can be be accessed by public"
    }
    return c.json(200, data)
});

Then simply call the route using the pocketbase

// 
let fetchData = async () => {
    let resp = await pocketBaseClient.pb.send("/private", {
    });
    console.log(resp)
}